<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="ru">
	<id>http://synset.com/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Den</id>
	<title>synset - Вклад участника [ru]</title>
	<link rel="self" type="application/atom+xml" href="http://synset.com/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Den"/>
	<link rel="alternate" type="text/html" href="http://synset.com/wiki/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F:%D0%92%D0%BA%D0%BB%D0%B0%D0%B4/Den"/>
	<updated>2026-11-20T21:16:54Z</updated>
	<subtitle>Вклад участника</subtitle>
	<generator>MediaWiki 1.31.15</generator>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1285</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1285"/>
		<updated>2010-02-21T13:16:15Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании, обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Целочисленная арифметика|Целочисленная арифметика]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:системы исчисления|Cистемы исчисления]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:длинная арифметика|Длинная арифметика]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Разное|Разное]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1284</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1284"/>
		<updated>2010-02-21T13:14:03Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Целочисленная арифметика|Целочисленная арифметика]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:системы исчисления|Cистемы исчисления]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:длинная арифметика|Длинная арифметика]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Разное|Разное]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1283</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1283"/>
		<updated>2010-02-21T13:13:43Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Целочисленная арифметика|Целочисленная арифметика]]&lt;br /&gt;
[[Pascal:системы исчисления|Cистемы исчисления]]&lt;br /&gt;
[[Pascal:длинная арифметика|Длинная арифметика]]&lt;br /&gt;
[[Pascal:Разное|Разное]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1282</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1282"/>
		<updated>2010-02-21T13:13:19Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Целочисленная арифметика|Целочисленная арифметика]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Разное|Разное]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:системы исчисления|Cистемы исчисления]]&lt;br /&gt;
&lt;br /&gt;
[[Pascal:длинная арифметика|Длинная арифметика]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1281</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1281"/>
		<updated>2010-02-21T13:08:55Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Pascal:Целочисленная арифметика|Целочисленная арифметика]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1278</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1278"/>
		<updated>2010-02-21T13:04:23Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Целочисленная_арифметика]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1277</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1277"/>
		<updated>2010-02-21T13:03:48Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Паскаль''' (англ. ''Pascal'') — высокоуровневый язык программирования общего назначения. Один из наиболее известных языков программирования, широко применяется в промышленном программировании[4], обучении программированию в высшей школе, является базой для большого числа других языков. Был создан Никлаусом Виртом в 1968-69 годах (опубликован в 1970 году) после его участия в работе комитета разработки стандарта языка Алгол-68.&lt;br /&gt;
&lt;br /&gt;
Ниже представлен список разделов, в которых находятся описания и реализация программ на языке Pascal. Данные программы могут быть полезны в написании более сложных программ.&lt;br /&gt;
&lt;br /&gt;
[[Целочисленная арифметика]]&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A0%D0%B0%D0%B7%D0%BD%D0%BE%D0%B5&amp;diff=1276</id>
		<title>Pascal:Разное</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A0%D0%B0%D0%B7%D0%BD%D0%BE%D0%B5&amp;diff=1276"/>
		<updated>2010-02-21T12:59:56Z</updated>

		<summary type="html">&lt;p&gt;Den: Новая страница: «== Работа с текстовыми файлами. Чтение и запись: ==   &amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt; var    f1,f2:text;    sum,a,b:i…»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B_%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F&amp;diff=1275</id>
		<title>Pascal:системы исчисления</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B_%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F&amp;diff=1275"/>
		<updated>2010-02-21T12:59:01Z</updated>

		<summary type="html">&lt;p&gt;Den: Новая страница: «== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==  &amp;lt;pre…»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1274</id>
		<title>Pascal:Целочисленная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1274"/>
		<updated>2010-02-21T12:56:57Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Целочисленная арифметика(описание) ==&lt;br /&gt;
&lt;br /&gt;
В данном разделе представлены описания и реализация программ которые могут быть полезны в решении задач с целочисленной арифметикой.&lt;br /&gt;
== Функция для определения принадлежности числа к простым: ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наибольший общий делитель: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наименьшее общее кратное ==&lt;br /&gt;
Для нахождения НОК удобно использовать следующее свойство: для любых натуральных чисел a и b верно равенство НОД(a,b)*НОК(a,b)=a*b , откуда получаем, что НОК(a,b)=a*b/НОД(a,b).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program SCM;&lt;br /&gt;
&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Read(a,b);&lt;br /&gt;
   WriteLn(f2,a*b div GCD(A,B));&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1273</id>
		<title>Pascal:Целочисленная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1273"/>
		<updated>2010-02-21T12:56:03Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Целочисленная арифметика(описание) ==&lt;br /&gt;
&lt;br /&gt;
В данном разделе представлены описания и реализация программ которые могут быть полезны в решении задач с целочисленной арифметикой.&lt;br /&gt;
== Функция для определения принадлежности числа к простым: ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наибольший общий делитель: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наименьшее общее кратное ==&lt;br /&gt;
Для нахождения НОК удобно использовать следующее свойство: для любых натуральных чисел a и b верно равенство &amp;lt;math&amp;gt;НОД(a,b)*НОК(a,b)=a*b&amp;lt;/math&amp;gt; , откуда получаем, что &amp;lt;math&amp;gt;НОК(a,b)=a*b/НОД(a,b)&amp;lt;/math&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program SCM;&lt;br /&gt;
&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Read(a,b);&lt;br /&gt;
   WriteLn(f2,a*b div GCD(A,B));&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1272</id>
		<title>Pascal:Целочисленная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1272"/>
		<updated>2010-02-21T12:55:23Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Целочисленная арифметика(описание) ==&lt;br /&gt;
&lt;br /&gt;
В данном разделе представлены описания и реализация программ которые могут быть полезны в решении задач с целочисленной арифметикой.&lt;br /&gt;
== Функция для определения принадлежности числа к простым: ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наибольший общий делитель: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наименьшее общее кратное ==&lt;br /&gt;
Для нахождения НОК удобно использовать следующее свойство: для любых натуральных чисел a и b верно равенство НОД(a,b)*НОК(a,b)=a*b , откуда получаем, что НОК(a,b)=a*b/НОД(a,b).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program SCM;&lt;br /&gt;
&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Read(a,b);&lt;br /&gt;
   WriteLn(f2,a*b div GCD(A,B));&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1271</id>
		<title>Pascal:Целочисленная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1271"/>
		<updated>2010-02-21T12:53:49Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Целочисленная арифметика(описание) ==&lt;br /&gt;
&lt;br /&gt;
В данном разделе представлены описания и реализация программ которые могут быть полезны в решении задач с целочисленной арифметикой.&lt;br /&gt;
== Функция для определения принадлежности числа к простым: ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наибольший общий делитель: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Наименьшее общее кратное ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program SCM;&lt;br /&gt;
&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Read(a,b);&lt;br /&gt;
   WriteLn(f2,a*b div GCD(A,B));&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1270</id>
		<title>Pascal:Целочисленная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1270"/>
		<updated>2010-02-21T12:33:16Z</updated>

		<summary type="html">&lt;p&gt;Den: Новая страница: « == Целочисленная арифметика(описание) ==  В данном разделе представлены описания и реализа…»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== Целочисленная арифметика(описание) ==&lt;br /&gt;
&lt;br /&gt;
В данном разделе представлены описания и реализация программ которые могут быть полезны в решении задач с целочисленной арифметикой.&lt;br /&gt;
== Функция для определения принадлежности числа к простым: ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1269</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1269"/>
		<updated>2010-02-21T12:28:48Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== Длинная арифметика(описание)==&lt;br /&gt;
&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1268</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1268"/>
		<updated>2010-02-21T12:28:28Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика==&lt;br /&gt;
&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1267</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1267"/>
		<updated>2010-02-21T12:28:09Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Длинная арифметика'''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика==&lt;br /&gt;
&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1266</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1266"/>
		<updated>2010-02-21T12:27:52Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Длинная арифметика'''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика&lt;br /&gt;
 ==&lt;br /&gt;
&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1265</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1265"/>
		<updated>2010-02-21T12:27:05Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Длинная арифметика'''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1264</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1264"/>
		<updated>2010-02-21T12:26:48Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Длинная арифметика'''&lt;br /&gt;
== Текст заголовка ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1263</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1263"/>
		<updated>2010-02-21T12:26:28Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Длинная арифметика&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1262</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1262"/>
		<updated>2010-02-21T12:25:55Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Длинная арифметика&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1261</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1261"/>
		<updated>2010-02-21T12:25:38Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Длинная арифметика&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1260</id>
		<title>Pascal:длинная арифметика</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal:%D0%B4%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0&amp;diff=1260"/>
		<updated>2010-02-21T12:25:04Z</updated>

		<summary type="html">&lt;p&gt;Den: Новая страница: «Длинная арифметика  == А+В ==   Длинная арифметика - раздел программирования позволяющий удо…»&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Длинная арифметика&lt;br /&gt;
&lt;br /&gt;
== А+В ==&lt;br /&gt;
 &lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. &lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А-В ==&lt;br /&gt;
&lt;br /&gt;
Данная программа осуществляет нахождения разности двух больших чисел.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A-B;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Function CompLong(s1,s2:string):integer; {функция CompLong сравнивает две строки как большие числа}&lt;br /&gt;
Label&lt;br /&gt;
    Lb;&lt;br /&gt;
var&lt;br /&gt;
   a,len1,len2,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   a:=0;&lt;br /&gt;
   len1:=length(s1);&lt;br /&gt;
   len2:=length(s2);&lt;br /&gt;
   if len1&amp;gt;len2 then begin a:= 1; goto LB end;&lt;br /&gt;
   if len1&amp;lt;len2 then begin a:=-1; goto LB end;&lt;br /&gt;
   for i:=1 to len1 do begin&lt;br /&gt;
      if Ord(s1[i])-48&amp;gt;Ord(s2[i])-48 then begin a:= 1; break; end;&lt;br /&gt;
      if s1[i]&amp;lt;s2[i] then begin a:=-1; break; end;&lt;br /&gt;
   end;&lt;br /&gt;
   Lb:&lt;br /&gt;
   CompLong:=a;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   i,len,c,x:integer;&lt;br /&gt;
   a,b:array[1..1000] of integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT'); Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   ReadLn(f1,s1); c:=0;&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   if Complong(s1,s2)&amp;lt;0 then begin&lt;br /&gt;
      Write(f2,'-');&lt;br /&gt;
      len:=length(s2);&lt;br /&gt;
      for i:=1 to len do begin&lt;br /&gt;
         x:=a[i];&lt;br /&gt;
         a[i]:=b[i];&lt;br /&gt;
         b[i]:=x;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]-b[i]+10;&lt;br /&gt;
      a[i]:= c mod 10;                       {результат будет храниться в массиве a}&lt;br /&gt;
      if c &amp;lt; 10 then c:=-1 else c:=0;&lt;br /&gt;
    end;&lt;br /&gt;
   while (a[len]=0) and (len&amp;gt;1) do len:=len-1;&lt;br /&gt;
   for i:=len downto 1 do {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2)&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== А*В ==&lt;br /&gt;
&lt;br /&gt;
Следующая программа проводит умножение двух больших чисел&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program A*B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   s1:string;&lt;br /&gt;
   b,i,c:integer;&lt;br /&gt;
   a:array[0..105] of integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   a[0]:=length(s1);&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
      a[a[0]-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
&lt;br /&gt;
   for i:=1 to a[0] do&lt;br /&gt;
    begin&lt;br /&gt;
      a[i]:=c+a[i]*b;&lt;br /&gt;
      c:=a[i] div 10;&lt;br /&gt;
      a[i]:=a[i] mod 10;&lt;br /&gt;
    end;&lt;br /&gt;
   While c&amp;gt;0 do&lt;br /&gt;
   begin&lt;br /&gt;
      a[0]:=a[0]+1;&lt;br /&gt;
      a[a[0]]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
   end;&lt;br /&gt;
   if a[a[0]]=0 then Write(f2,0)&lt;br /&gt;
   else&lt;br /&gt;
   for i:=a[0] downto 1 do&lt;br /&gt;
    Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
На основе этих программ могут быть созданы программы нахождения факториала, возведения в степень и т.д. позводяющие работать с большими числами.&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1259</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1259"/>
		<updated>2010-02-21T11:40:38Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Стандартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика ==&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. По анологии с этой программой, могут быть решены задачи умножения, деления, возведения в степень, получение факториала больших чисел.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная c будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив а} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1258</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1258"/>
		<updated>2010-02-21T11:39:56Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Стандартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика ==&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. По анологии с этой программой, могут быть решены задачи умножения, деления, возведения в степень, получение факториала больших чисел.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);                      {разбиение строк в елементы массивов}&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];         {переменная ''c'' будет в дальнейшем использоваться для переноса числа в следующия ряд}&lt;br /&gt;
      a[i]:=c mod 10;         {результат сложения запишем в массив ''а''} &lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do     {вывод результата в файл}&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=1257</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=1257"/>
		<updated>2010-02-21T11:33:47Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Стандартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Длинная арифметика ==&lt;br /&gt;
Длинная арифметика - раздел программирования позволяющий удобно работать с числами которые не могут быть помещены в стандартные типы языка. Ниже представлен код программы реализующий сложение двух чисел, длина которых ограничивается только оперативной памятью. По анологии с этой программой, могут быть решены задачи умножения, деления, возведения в степень, получение факториала больших чисел.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
program A+B;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   s1,s2:string;&lt;br /&gt;
   a,b:array[1..100] of integer;&lt;br /&gt;
   len,i,c:integer;&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'INPUT.TXT');  Reset(f1);&lt;br /&gt;
   Assign(f2,'OUTPUT.TXT'); ReWrite(f2);&lt;br /&gt;
   c:=0;&lt;br /&gt;
   ReadLn(f1,s1);&lt;br /&gt;
   ReadLn(f1,s2);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   len:=length(s1);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      a[len-i+1]:=Ord(s1[i])-48;&lt;br /&gt;
   len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
      b[len-i+1]:=Ord(s2[i])-48;&lt;br /&gt;
&lt;br /&gt;
   if length(s1)&amp;gt;length(s2) then len:=length(s1)&lt;br /&gt;
   else len:=length(s2);&lt;br /&gt;
   for i:=1 to len do&lt;br /&gt;
    begin&lt;br /&gt;
      c:=c+a[i]+b[i];&lt;br /&gt;
      a[i]:=c mod 10;&lt;br /&gt;
      c:=c div 10;&lt;br /&gt;
    end;&lt;br /&gt;
   if c&amp;gt;0 then begin&lt;br /&gt;
      len:=len+1;&lt;br /&gt;
      a[len]:=c;&lt;br /&gt;
    end;&lt;br /&gt;
   for i:=len downto 1 do&lt;br /&gt;
      Write(f2,a[i]);&lt;br /&gt;
   close(f2);&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=894</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=894"/>
		<updated>2010-02-18T18:44:07Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Стандартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=893</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=893"/>
		<updated>2010-02-18T18:41:48Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
На данной странице представлены небольшие программы которые могут быть полезными в написании различных программ.&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=892</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=892"/>
		<updated>2010-02-18T18:41:17Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
На данной странице представлены небольшие программы которые могут быть полезными в написании различных программ.&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=732</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=732"/>
		<updated>2010-02-16T19:42:14Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым:  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=731</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=731"/>
		<updated>2010-02-16T19:41:44Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения принадлежности числа к простым  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=730</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=730"/>
		<updated>2010-02-16T19:37:16Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=729</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=729"/>
		<updated>2010-02-16T19:36:48Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=728</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=728"/>
		<updated>2010-02-16T19:30:20Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Функция для определения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Функция для определения наибольшего общего делителя: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function GCD(a,b:longint):longint;&lt;br /&gt;
var&lt;br /&gt;
   x,y:longint;&lt;br /&gt;
begin&lt;br /&gt;
   x:=a;&lt;br /&gt;
   y:=b;&lt;br /&gt;
   While x&amp;lt;&amp;gt;y do&lt;br /&gt;
      if x&amp;gt;y then x:=x-y&lt;br /&gt;
      else y:=y-x;&lt;br /&gt;
   GCD:=x;&lt;br /&gt;
end;&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=727</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=727"/>
		<updated>2010-02-16T19:19:54Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Наиболее оптимальная функция нахождения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=726</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=726"/>
		<updated>2010-02-16T19:19:35Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
== '''Станадартные программы для реализации алгоритмов на языке Pascal ''' ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Наиболее оптимальная функция нахождения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=725</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=725"/>
		<updated>2010-02-16T19:19:02Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
== Наиболее оптимальная функция нахождения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=724</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=724"/>
		<updated>2010-02-16T19:18:43Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Наиболее оптимальная функция нахождения простых чисел  ==&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
Function Prime(n:longint):boolean;&lt;br /&gt;
var&lt;br /&gt;
   p,i:longint;&lt;br /&gt;
   b:boolean;&lt;br /&gt;
begin&lt;br /&gt;
   b:=true;&lt;br /&gt;
   if (n=1) or ((n&amp;gt;3) and (n mod 2=0)) then&lt;br /&gt;
   b:=false&lt;br /&gt;
   else&lt;br /&gt;
   begin&lt;br /&gt;
      p:=trunc(sqrt(n));&lt;br /&gt;
      i:=3;&lt;br /&gt;
      While (i&amp;lt;=p) and b do&lt;br /&gt;
      begin&lt;br /&gt;
         b:=n mod i&amp;lt;&amp;gt;0;&lt;br /&gt;
         i:=i+2;&lt;br /&gt;
      end;&lt;br /&gt;
   end;&lt;br /&gt;
   Prime:=b;&lt;br /&gt;
end; &lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=723</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=723"/>
		<updated>2010-02-16T19:15:58Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==  ==&lt;br /&gt;
 &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=722</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=722"/>
		<updated>2010-02-16T19:15:20Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== &lt;br /&gt;
---- ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=721</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=721"/>
		<updated>2010-02-16T19:14:52Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=720</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=720"/>
		<updated>2010-02-16T19:14:34Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=719</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=719"/>
		<updated>2010-02-16T19:14:18Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=718</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=718"/>
		<updated>2010-02-16T19:14:00Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt; '''Станадартные программы для реализации алгоритмов на языке Pascal '''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=717</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=717"/>
		<updated>2010-02-16T19:13:30Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== '''Станадартные программы для реализации алгоритмов на языке Pascal '''==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=716</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=716"/>
		<updated>2010-02-16T19:13:10Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== '''Станадартные программы для реализации алгоритмов на языке Pascal '''==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=715</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=715"/>
		<updated>2010-02-16T19:12:45Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''== Станадартные программы для реализации алгоритмов на языке Pascal =='''&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=714</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=714"/>
		<updated>2010-02-16T19:12:26Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ывлдаыдлватыдлв&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
	<entry>
		<id>http://synset.com/wiki/index.php?title=Pascal&amp;diff=713</id>
		<title>Pascal</title>
		<link rel="alternate" type="text/html" href="http://synset.com/wiki/index.php?title=Pascal&amp;diff=713"/>
		<updated>2010-02-16T19:10:33Z</updated>

		<summary type="html">&lt;p&gt;Den: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Станадартные программы для реализации алгоритмов на языке Pascal ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Работа с текстовыми файлами. Чтение и запись: ==&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
var&lt;br /&gt;
   f1,f2:text;&lt;br /&gt;
   sum,a,b:integer;&lt;br /&gt;
begin&lt;br /&gt;
   Assign(f1,'input.dat');&lt;br /&gt;
   Assign(f2,'output.sol');&lt;br /&gt;
   Rewrite(f2);&lt;br /&gt;
   Reset(f1);&lt;br /&gt;
   Read(f1, a);&lt;br /&gt;
   Read(f1, b);&lt;br /&gt;
   close(f1);&lt;br /&gt;
   sum:=a+b;&lt;br /&gt;
   Write(f2, sum);&lt;br /&gt;
   close(f2);&lt;br /&gt;
 end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из десятичной системы исчисления в систему исчисления с основанием m: ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program Сonversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
const&lt;br /&gt;
   nmax=1000000000;&lt;br /&gt;
var&lt;br /&gt;
   i,v,x,m,j:integer;&lt;br /&gt;
   a:array[1..nmax] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   i:=0;&lt;br /&gt;
   ReadLn(x,m);   {Вводим число x которое необходимо перевести в систему исчисления с основанием m}&lt;br /&gt;
   v:=x;&lt;br /&gt;
   While v&amp;gt;0 do&lt;br /&gt;
    begin&lt;br /&gt;
      inc(i);&lt;br /&gt;
      a[i]:=v mod m;&lt;br /&gt;
      v:=v div m&lt;br /&gt;
    end;&lt;br /&gt;
   Write(x,' in the calculus of reason ',m,' = ');&lt;br /&gt;
   for j:=i downto 1 do&lt;br /&gt;
      Write(a[j]);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Перевод числа из системы исчисления с основанием m в десятичную систему: ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre class=&amp;quot;brush:pascal; gutter: false;&amp;quot;&amp;gt;&lt;br /&gt;
program OppositeToConversion;&lt;br /&gt;
&lt;br /&gt;
uses&lt;br /&gt;
  SysUtils;&lt;br /&gt;
Function Power(x,n:integer):integer;  {функция для возведения в степень n числа x}&lt;br /&gt;
var&lt;br /&gt;
   p,i:integer;&lt;br /&gt;
begin&lt;br /&gt;
   if n=0 then Power:=1&lt;br /&gt;
   else begin&lt;br /&gt;
   p:=x;&lt;br /&gt;
   for i:=2 to n do&lt;br /&gt;
      p:=p*x;&lt;br /&gt;
   Power:=p;&lt;br /&gt;
   end;&lt;br /&gt;
end;&lt;br /&gt;
&lt;br /&gt;
var&lt;br /&gt;
   st:string;&lt;br /&gt;
   i,v,sum,m:integer;&lt;br /&gt;
   a:array[1..1000000] of byte;&lt;br /&gt;
begin&lt;br /&gt;
   ReadLn(st);&lt;br /&gt;
   ReadLn(m);&lt;br /&gt;
   v:=length(st);&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      a[v-i+1]:=StrToInt(st[v-i+1]); &lt;br /&gt;
   sum:=0;&lt;br /&gt;
   for i:=1 to v do&lt;br /&gt;
      sum:=sum+Power(m,i-1)*a[v-i+1];&lt;br /&gt;
   WriteLn(sum);&lt;br /&gt;
   ReadLn;&lt;br /&gt;
end.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
--[[Участник:Den|Den]] 19:09, 16 февраля 2010 (UTC)&lt;/div&gt;</summary>
		<author><name>Den</name></author>
		
	</entry>
</feed>