Умножение в паскале как пишется на английском

Редактировать

ЗАДАЧА №691 Номера автобусов

(Время: 1 сек. Память: 16 Мб Сложность: 16%)

Однажды Вася очень долго просидел на остановке, прежде чем дождался своего автобуса. Чтобы как-то занять время, он решил записывать на листочке государственные регистрационные номера проходящих мимо автобусов, следующих по другому маршруту, нежели нужен был Васе. При этом производилась запись лишь основного номера, без учета региональной принадлежности. В итоге Васе удалось записать N таких номеров.

Основная часть государственного регистрационного номера состоит из 6 символов: трех букв и трех цифр. Сначала идет буква, затем 3 цифры и еще 2 буквы заканчивают запись. В качестве цифр могут использоваться любые цифры от 0 до 9, а в качестве букв только прописные буквы, обозначения которых присутствуют как в английском, так и в русском алфавите, т.е. только следующие символы: A, B, C, E, H, K, M, O, P, T, X, Y. Например, «P204BT» — правильный номер, а «X182YZ» и «ABC216» — нет.

Ваша задача заключается в проверке правильности проделанной Васей работы. А именно, нужно определить, какие из номеров соответствуют принятому стандарту, а какие нет.

Входные данные
Первая строка входного файла INPUT.TXT содержит единственное натуральное число N – количество записанных Васей номеров (N ≤ 50). Далее следует N строк с записями номеров автобусов. Длины строк от 1 до 300 и содержат только символы с кодами ASCII от 33 до 127 (не содержат пробелов, специальных и русских символов).

Выходные данные
В выходной файл OUTPUT.TXT выведите N строк, в i-й строке должно содержаться «Yes», если соответствующая i-я запись номера верна и «No» в противном случае.

begin
  foreach var s in ReadSeqString(ReadlnInteger) do
    Println((s = s.MatchValue('[ABCEHKMOPTXY]d{3}[ABCEHKMOPTXY]{2}')) ? 'Yes' : 'No')
end.

Здесь представляется удобным использовать регулярное выражение, соответствующее “правильному” госномеру. Критерием правильности будем считать совпадение исходной строки с полученной после сопоставления с регулярным выражением. Регулярное выражение построено по схема “буква” — три цифры — две “буквы”, где каждая “буква” должна быть одной из допустимых.

Сопоставление производится в цикле для каждой строки из входной последовательности. По результату сопоставления выводится Yes или No.

ЗАДАЧА №231 Распаковка строки

(Время: 1 сек. Память: 16 Мб Сложность: 25%)

Будем рассматривать только строчки, состоящие из заглавных английских букв. Например, рассмотрим строку AAAABCCCCCDDDD. Длина этой строки равна 14. Поскольку строка состоит только из английских букв, повторяющиеся символы могут быть удалены и заменены числами, определяющими количество повторений. Таким образом, данная строка может быть представлена как 4AB5C4D. Длина такой строки 7. Описанный метод мы назовем упаковкой строки.

Напишите программу, которая берет упакованную строчку и восстанавливает по ней исходную строку.

Входные данные
Входной файл INPUT.TXT содержит одну упакованную строку. В строке могут встречаться только конструкции вида nA, где n — количество повторений символа (целое число от 2 до 99), а A — заглавная английская буква, либо конструкции вида A, то есть символ без числа, определяющего количество повторений. Строка содержит от 1 до 80 символов.

Выходные данные
В выходной файл OUTPUT.TXT выведите восстановленную строку. При этом строка должна быть разбита на строчки длиной ровно по 40 символов (за исключением последней, которая может содержать меньше 40 символов).

begin
  var s := '';
  foreach var w in ReadlnString.MatchValues('d*[A-Z]') do
  begin
    var l := w.Length;
    s += l = 1 ? w : w[:l].ToInteger * w[l]
  end;
  s.Batch(40, c -> c.JoinIntoString).PrintLines
end.

При помощи регулярного выражения разбираем строку на элементы вида «буква» или «число»«буква». Формируем выходную строку s, в которую заносим либо найденную букву, либо “число” такик букв. Затем с помощью s.Batch(40) разрезаем полученную строку на 40-символьные последовательности, каждую из которых снова объединяем в строку. Последовательность строк выводим с помощью PrintLines.

ЗАДАЧА №838 Шаблон программы

(Время: 1 сек. Память: 16 Мб Сложность: 30%)

Многие команды, участвующие в командных соревнованиях по программированию, используют так называемый «шаблон программы». Он набирается в самом начале соревнования и содержит общее для всех решений — например, открытие и закрытие входных и выходных файлов.

Трехкратный чемпион мира по версии AMC команда Dream Team – не исключение. Во многом их успехи связаны с тем, что они очень тщательно готовятся к соревнованиям, продумывая даже очень мелкие детали. Например, перед последним финалом они во время пробного тура рассчитали, сколько джоулей энергии потратится на набор шаблона.

Организаторы финала использовали весьма странные клавиатуры — жесткость различных клавиш была различной. Таким образом, на нажатие разных клавиш требовалось различное количество энергии.

Эксперименты, проведенные командой Dream Team во время пробного тура, показали следующее. На набор строчной буквы английского алфавита требуется количество энергии, равное сумме цифр ее порядкового номера в алфавите (буквы нумеруются с единицы). На нажатие клавиши «Shift» требуется 10 джоулей энергии (таким образом набор заглавной буквы английского алфавита требует на 10 джоулей больше, чем набор соответствующей ей строчной буквы), нажатие клавиши «Пробел» требует 4 джоуля энергии. Набор цифры x требует (13 – x) джоулей энергии, набор точки – 5 джоулей, точки с запятой – 7 джоулей, запятой – 2 джоуля. Знак равенства, плюс, минус, одинарная и двойная кавычка требуют по 3 джоуля энергии. Закрывающая и открывающая круглые скобки требуют по 1 джоулю, а фигурные, квадратные и угловые (т.е. символы < и >) – по 8. При этом для всех упомянутых знаков препинания на клавиатуре, используемой на финале, существуют отдельные клавиши, и другой возможности набрать соответствующий символ нет. Нажатие клавиши «Enter» (перевод строки) оказалось настолько легким, что энергозатраты на него можно считать нулевыми.

Ваша задача – написать программу, которая по тексту шаблона вычислит энергозатраты на его набор.

Входные данные
Входной файл INPUT.TXT содержит шаблон программы, энергетические затраты на набор которого необходимо вычислить. Он содержит только цифры, пробелы, строчные и заглавные буквы английского алфавита, точки, запятые, знаки равенства, плюсы, точки с запятыми, двойные кавычки (“), одинарные кавычки (‘), закрывающие и открывающие круглые, фигурные и квадратные скобки. Его размер не превышает 20000 байт.

Выходные данные
В выходной файл OUTPUT.TXT выведите ответ на задачу.

begin
  var D := new Dictionary<char, integer>;
  var k: integer;
  for var i := 1 to 26 do
  begin 
    k := i div 10 + i mod 10;
    D.Add(Chr(Ord('A') + i - 1), k + 10);
    D.Add(Chr(Ord('a') + i - 1), k);
  end;
  for var i := 0 to 9 do
    D.Add(Chr(Ord('0') + i), 13 - i);
  var s := ' .,;+-="''()<>[]{}'+#13#10;
  var a := Arr(4,5,2,7,3,3,3,3,3,1,1,8,8,8,8,8,8,0,0);
  for var i := 1 to s.Length do
    D.Add(s[i], a[i-1]);
  var r := ReadAllText('input.txt');
  r.Select(c -> D[c]).Sum.Print
end.

Алгоритм решения тут очень простой. Создается таблица, в которой каждому символу сопоставляется числовое значение (“энергия в джоулях”). Читаются друг за другом исходные символы, каждый символ заменяется выбранным из таблицы числовым значеним и эти значения суммируются. После исчерпания входных символов накопленная сумма выводится в качестве результата.

В качестве “таблицы” в приведенной программе выбрана стандартная коллекция Dictionary (словарь). Ключом является символ, значением — энергия в джоулях. Словарь удобен тем, что в нем поиск по ключу быстрый (бинарный), а значение выбирается путем указания ключа в качестве индекса — в программе это D[c].

Основная часть программы — это заполнение словаря, само же решение занимает две строки. Словарь вначале пополняется символами латиницы (в обоих регистрах), затем символами цифр и последними — всеми прочими знаками, которые пришлось просто перечислить.

Редактировать

В PascalABC.NET рекомендуется использовать динамические массивы. В отличие от статических, они имеют огромное количество методов и операций, просты в создании, заполнении и выводе.

Описание и выделение памяти

Динамический массив описывается так:

begin
  var a: array of integer;
end.

Память под динамический массив a выделяется в момент работы программы:

begin
  var a: array of integer;
  var n := ReadInteger;
  a := new integer[n];
end.

Здесь — первое преимущество динамических массивов — в переменной a может храниться массив любого размера, память выделяется в процессе работы программы. Кроме того, выделенная память гарантированно автоматически заполняется нулевыми значениями.

Можно совместить описание и выделение памяти — тип динамического массива выводится автоматически:

begin
  var n := ReadInteger;
  var a := new integer[n];
end.

Обычно в PascalABC.NET совмещают описание динамического массива, выделение памяти и заполнение значениями. Самый простой способ — заполнить n нулями:

begin
  var n := ReadInteger;
  var a := |0| * n;
end.

Индексация в динамических массивах и использование статических массивов

Динамические массивы индексируются с нуля — это эффективно. В качестве индексов в динамических массивах могут выступать только целые.

Статические массивы тем не менее иногда удобно использовать — в задачах, где индексы либо символьные, либо по-существу начинаются не с нуля. Например, для подсчёта количества слов на каждую букву может использоваться стаический массив

  var a := array ['a'..'z'] of integer;

Заполнение статических массивов — увы — производится в цикле. Кроме того, они не помнят свою длину и передача таких массивов в качестве параметров подпрограмм связана с техническими сложностями 40-летней давности, не нужными начинающим.

Простейшее заполнение

Важную роль играют функции заполнения динамических массивов. Перед заполнением они выделяют для массива память, поэтому в одной строке можно совмещать описание, выделение памяти и заполнение.

Простейшее заполнение — набором значений:

Заполнение диапазоном целых или символьных значений делается с использованием функции Arr:

var a := Arr(1..9);
var b := Arr('a'..'z');

Заполнение определённым значением осуществляется с помощью операции умножения массива на число:

begin
  var n := ReadInteger;
  var a := |0| * n; // массив из n нулей
end.

Для заполнения можно также использовать функцию ArrFill:

begin
  var n := ReadInteger;
  var a := ArrFill(n,0); // массив из n нулей
end.

Для заполнения массива случайными значениями следует использовать

begin
  var n := ReadInteger;
  var a := ArrRandomInteger(n); // по умолчанию значения от 0 до 100
  var a1 := ArrRandomInteger(n,1,10); // случайные от 1 до 10
  var r := ArrRandomReal(n); // по умолчанию значения от 0 до 10
  var r1 := ArrRandomReal(n,2,5); // случайные вещественные от 2 до 5
end.

Не рекомендуется использовать алгоритм для заполнения массива случайными в каждой задаче:

begin
  var n := ReadInteger;
  var a := new integer[n];
  for var i:=0 to n-1 do
    a[i] := Random(0,100);
end.

Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.

Ввод и вывод элементов массива

Для ввода элементов массива базовых типов используются функции

begin
  var n := ReadInteger;
  var a := ReadArrInteger(n);
  var r := ReadArrReal(n);
  var s := ReadArrString(n);
  // ...
end.

Стандартная процедура вывода Write или Print выводит значения в массиве в квадратных скобках черезх запятую:

begin
  var a := Arr(1..9);
  Print(a); // [1,2,3,4,5,6,7,8,9]
end.

Однако лучше всего для вывода воспользоваться методом Print, выводящим все значения в массиве через пробел:

begin
  var a := Arr(1..9);
  a.Print; // 1 2 3 4 5 6 7 8 9 
end.

Не рекомендуется вводить и выводить элементы массива в цикле

begin
  var n := ReadInteger;
  var a := new integer[n];
  for var i:=0 to n-1 do
    a[i] := ReadInteger;
end.

Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.

Циклы по массиву

Для обработки элементов массива используются следующие циклы:

1. Цикл for по индексам (если требуется менять элементв или нужна информация об индексах)

   for var i:=0 to a.Length-1 do
     a[i] *= 2;
   

2. Цикл foreach по элементам (если индексы не видны и мы не меняем массив)

   var sum := 0;
   foreach var x in a do
     sum += x;
   

3. Цикл foreach по индексам

   foreach var i in a.Indices do
     a[i] += 2;
   

4. Цикл foreach по диапазону индексов

   var (K,L) := ReadInteger2;
   foreach var i in K..L do
     a[i] := 777;
   

Пример. Найти количество чётных элементов, стоящих на чётных местах

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  var count := 0;
  foreach var i in a.Indices do
    if i.IsEven and a[i].IsEven then
      count += 1;
  Print(count);    
end.

Методы массива

Массивы содержат большое количество стандартных методов:

a.Length - длина массива
a.Min - минимальный элемент в массиве
a.Max - максимальный элемент в массиве
a.IndexMin - индекс первого минимального элемента в массиве
a.IndexMax - индекс первого максимального элемента в массиве
a.Sum - сумма элементов в числовом массиве
a.Product - произведение элементов в числовом массиве
a.Average - среднее элементов в числовом массиве
a.First - первый элемент в массиве
a.Last - последний элемент в массиве
a.IndexOf(x) - индекс первого значения x или -1 если не найдено
a.Replace(x,y) - заменить в массиве все значения x на y

Кроме того, доступны процедуры

Sort(a) - сортировка элементов по возрастанию
SortDescending(a) - сортировка элементов по убыванию
Reverse(a) - инвертирование элементов массива

Методика. Обращаем внимание, что в методических целях естественно рассказывать, как эти алгоритмы устроены “внутри”.
Но потом следует пользоваться стандартными алгоритмами, а не заставлять учеников во всех задачах использовать рукописные сортировки или рукописный поиск минимума. Например, рекомендуется показать, как накопить сумму элементов массива:

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  var sum := 0;
  foreach var x in a do
    sum += x;
  Print(sum);    
end.

Здесь следует обратить внимание, что этот алгоритм может быть легко модифицирован в алгоритм нахождения суммы элементов по условию: например, всех чётных элементов:

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  var sum := 0;
  foreach var x in a do
    if x.IsEven then
      sum += x;
  Print(sum);    
end.

Отметим, что заполнение случайными и вывод — это технические части программы, которые делаются в PascalABC.NET в одну строку, позволяя концентрироваться на алгоритме.

Если условие надо накладывать на индексы, то в этом случае (и только в этом случае) следует использовать цикл for по индексам:

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  var sum := 0;
  for var i:=0 to a.Length-1 do
    if i.IsEven then
      sum += a[i];
  Print(sum);    
end.

Для нахождения суммы без условия необходимо использовать стандартный метод a.Sum:

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  Print(a.Sum);    
end.

Отметим также, что для поиска суммы по условию также имеется короткая однострочная запись. Она требует использование стандартного метода Where с параметром, являющимся лямбда-выражением. Лямбда-выражения мы будем рассматривать далее:

begin
  var a := ArrRandomInteger(10);
  a.Println; 
  Print(a.Where(x -> x.IsEven).Sum);
end.

Методика. Поскольку данная запись использована здесь впервые, обращаем внимание на её высокую универсальность: алгоритмы фильтрации и поиска суммы не слиты в один алгоритм, а используются порознь один за другим, что позволяет:

1. Лучше читать код (потому что он записан компактно и методами с понятными и очевидными названиями)
2. Лучше модифицировать код
3. Решать более сложные и более прикладные задачи за одно и то же время урока

Далее лямбда-выражения объясняются подробно и тщательно и используются повсеместно.

Операции с массивами

x in a - возвращает true если значение x содержится в a
a1 + a2 - возвращает массив, образованный слиянием массивов a1 и a2
a1 * n - возвращает массив, состоящий из n раз повторенных значений массива a

Изменение размера динамического массива

Если в процессе работы программы требуется чтобы динамический массив менял свой размер, то следует … пользоваться типом List!
Это — динамический массив с возможностью эффективного измненения размера и рядом дополнительных методов. Основным является методы Add — добавить в конец:

begin
  var l := new List<integer>;
  l.Add(1);
  l.Add(3);
  l.Add(5);
  l.Print
end.

Для первоначального заполнения списков List используется короткая фунеция Lst:

begin
  var l := Lst(1,3,5);
  l.Print
end.

При необходимости список List можно преобразовать к динамическому массиву, вызвав метод .ToArray:

begin
  var l := Lst(1,3,5);
  var a := l.ToArray;
end.

Большинство методов, которые имеются в массивах, есть и в списках List. Поэтому выбор типа List или array of для контейнера при решении задач определяется тем, будет ли данный контейнер расширяться по ходу работы программы.

Редактировать

Внимание!

Мы рекомендуем всем, кто готовит и готовится к сдаче ЕГЭ, ограничиться возможностями PascalABC.NET 3.8. Эта версия вышла в начале марта 2021 года. Язык продолжает развиваться и совершенствоваться, но невозможно обеспечить на станциях ЕГЭ наличие самой последней версии программного обеспечения. Использование более ранних версий лишит школьника некоторых имеющихся в языке возможностей и потребует самостоятельно искать для них эквивалентные замены.

Мы призываем тех работников образования, от которых зависит состояние программных средств на станциях ЕГЭ, заблаговременно установить любую доступную сборку версии 3.8 или выше.

Просим руководство учебных заведений принять к сведению, что многие школьники, занимаясь самостоятельно или с репетиторами, используют именно эту версию и, обнаружив на экзамене версию более старую, могут показать результат гораздо ниже своих возможностей.

Рекомендуется скачивать текущую версию на сайте.

Об этом документе

Здесь представлены решения некоторых задач
демонстрационного варианта ЕГЭ по информатике 2021.

Решения даются с кратким описанием алгоритма и концентрируются в основном на демонстрации возможностей языка.

Решения сбалансированы по простоте записи и восприятия в балансе с новыми возможностями.

В сети можно встретить либо более длинные и непонятные решения на старом языке Паскаль либо переусложнённые и малопонятные для школьника решения с использованием всех возможностей языка. Ни тот ни другой стиль записи программ нами не рекомендуется.

Великолепный разбор задач типа 25 и 26 ЕГЭ по информатике 2021 на чистом PascalABC.NET дан К.Ю.Поляковым в данной презентации. Здесь представлены наиболее эффективные и неочевидные решения.

О PascalABC.NET

PascalABC.NET – современный диалект языка программирования Паскаль, позволяющий записывать код компактно и понятно, используя современные языковые возможности. Это делает программу яснее и как следствие сокращает число возможных ошибок на ЕГЭ по информатике, связанных с волнением и другими субъективными причинами.

Данный текст составлен разработчиками языка и рассматривает ряд вопросов, связанных с использованием PascalABC.NET при сдаче ЕГЭ по информатике. Он ориентирован:

• на школьников, использующих при сдаче ЕГЭ PascalABC.NET как язык реализации программ
• на преподавателей, которые при подготовке школьников к сдаче ЕГЭ по информатике используют PascalABC.NET

Важно! Данный текст не рассматривает вопросы, связанные с методикой решения задач. Он лишь описывает то, как на PascalABC.NET сделать запись алгоритмов лучше, сохранив при этом эффективность.

PascalABC.NET имеет множество языковых возможностей и множество стилей программирования, поскольку обобщает современные языковые и библиотечные возможности сразу нескольких современных языков программирования (C#, Python, Kotlin).

При решении задач ЕГЭ по информатике мы рекомендуем использовать лишь ограниченный набор возможностей PascalABC.NET, которые делают текст программы яснее и короче, позволяя концентрироваться на сути алгоритма, а не на технических деталях.

К базовым возможностям языка, рекомендуемым нами при решении задач ЕГЭ, относятся:

1. Описания переменных внутри блока в том месте, где они впервые потребовались. Это ликвидирует длинные перечни описания переменных до beginа основной программы, ухудшающие читаемость и лёгкость написания программы.
2. Автовывод типа переменной при описании с инициализацией (var a := 1).
3. Использование описания счётчика цикла for в заголовке цикла (for var i).
4. Функции ввода вида ReadInteger, ReadReal, ReadInteger2 и т.д., позволяющие одной строкой описывать и вводить переменную в любом месте операторного блока программы (var a := ReadInteger).
5. Процедуры вывода Print, Println, автоматически разделяющие элементы вывода пробелами.
6. Цикл loop – аналог цикла for, использующийся когда счётчик цикла не нужен.
7. Кортежи и распаковка кортежей в переменные, называемая также множественным присваиванием: (a,b) := (1,1).

Кроме того, в некоторых задачах уместно использование лямбда-выражений как параметров стандартных методов.

Все представленные здесь решения сбалансированно сочетают простоту и понятность записи и использование новых возможностей.

Задача 17

Рассматривается множество целых чисел, принадлежащих числовому
отрезку [1016; 7937], которые делятся на 3 и не делятся на 7, 17, 19, 27.
Найдите количество таких чисел и максимальное из них.
В ответе запишите два целых числа: сначала количество, затем
максимальное число.

Решение 1. Минимум новых возможностей; длинная запись условия, уводящая от сути

begin
  var count := 0;
  var max := -MaxInt;
  for var x := 1016 to 7937 do
    if (x mod 3 = 0) and (x mod 7 <> 0) and (x mod 17 <> 0) and 
       (x mod 19 <> 0) and (x mod 27 <> 0) then
    begin
      count += 1;
      if x > max then
        max := x;
    end;
  Print(count,max);
end.

Ответ.
1568 7935

Решение 2. Использование методов Divs и DivsAny

begin
  var count := 0;
  var max := -MaxInt;
  for var x := 1016 to 7937 do
    if x.Divs(3) and not x.DivsAny(7, 17, 19, 27) then
    begin
      count += 1;
      if x > max then
        max := x;
    end;
  Print(count,max);
end.

Решение 2а. Заметим, что максимальный элемент является последним удовлетворяющим условию

begin
  var count := 0;
  var last := 0;
  for var x := 1016 to 7937 do
    if x.Divs(3) and not x.DivsAny(7, 17, 19, 27) then
    begin
      count += 1;
      last := x;
    end;
  Print(count,last);
end.

Решение 3. Использование последовательностей

begin
  // Рассмотрим последовательность целых от 1016 до 7937, делящихся на 3 и не делящихся ни на одно из 7, 17, 19, 27
  var seq := (1016..7937).Where(x -> x.Divs(3) and not x.DivsAny(7, 17, 19, 27));
  // Выведем количество элементов этой последовательности и ее максимальный элемент
  Print(seq.Count,seq.Max);
end.

Замечание. Аналогично предыдущему вместо seq.Max можно использовать seq.Last

Задача 25

Напишите программу, которая ищет среди целых чисел, принадлежащих
числовому отрезку [174457; 174505], числа, имеющие ровно два различных
натуральных делителя, не считая единицы и самого числа. Для каждого
найденного числа запишите эти два делителя в таблицу на экране с новой
строки в порядке возрастания произведения этих двух делителей. Делители
в строке таблицы также должны следовать в порядке возрастания.

Решение 1

Для получения всех делителей составим функцию, которая будет помещать все получаемые делители в список.
Это неэффективно (нужны только числа с ровно двумя делителями), но для приводимых на ЕГЭ значений
программа выполняется мгновенно, поэтому писать более оптимальный алгоритм не следует.

function Divisors(N: integer): List<integer>;
begin
  Result := new List<integer>;
  for var i:=2 to N-1 do
    if N.Divs(i) then
      Result.Add(i);
end;

begin
  for var N := 174457 to 174505 do
  begin
    var d := Divisors(N);
    if d.Count = 2 then
      Println(d[0],'|',d[1]);
  end;
end.

Ответ.

3 | 58153
7 | 24923
59 | 2957 
13 | 13421
149 | 1171 
5 | 34897
211 | 827
2 | 87251 

Решение 2

Без использования функции

begin
  for var N := 174457 to 174505 do
  begin
    var d := new List<integer>;
    for var i:=2 to N-1 do
      if N mod i = 0 then
        d.Add(i);
    if d.Count = 2 then
      Println(d[0],'|',d[1]);
  end;
end.

Решение 3

Более эффективное, в котором список делителей не пополняется если уже содержит более двух делителей.
Это решение — на случай достаточно больших значений N, что трудно представить на ЕГЭ

begin
  for var N := 174457 to 174505 do
  begin
    var d := new List<integer>;
    for var i:=2 to N-1 do
    begin  
      if N mod i = 0 then
        d.Add(i);
      if d.Count > 2 then // Это условие даёт более эффективное решение
        break;
    end;  
    if d.Count = 2 then
      Println(d[0],'|',d[1]);
  end;
end.

Данное решение тем не менее будет медленно работать при очень больших N, однако подобное усложнение невозможно на ЕГЭ — оно делает задачу олимпиадной. Однако, решение есть и в этом случае. Оптимизации решения задачи 25 рассмотрены в презентации К.Ю. Полякова.

Задача 26

Системный администратор раз в неделю создаёт архив пользовательских
файлов. Однако объём диска, куда он помещает архив, может быть меньше,
чем суммарный объём архивируемых файлов.
Известно, какой объём занимает файл каждого пользователя.
По заданной информации об объёме файлов пользователей и свободном
объёме на архивном диске определите максимальное число пользователей,
чьи файлы можно сохранить в архиве, а также максимальный размер
имеющегося файла, который может быть сохранён в архиве, при условии,
что сохранены файлы максимально возможного числа пользователей.

Входные данные.

В первой строке входного файла находятся два числа: S – размер свободного
места на диске (натуральное число, не превышающее 10 000)
и N – количество пользователей (натуральное число, не превышающее
1000). В следующих N строках находятся значения объёмов файлов каждого
пользователя (все числа натуральные, не превышающие 100), каждое
в отдельной строке.
Запишите в ответе два числа: сначала наибольшее число пользователей, чьи
файлы могут быть помещены в архив, затем максимальный размер
имеющегося файла, который может быть сохранён в архиве, при условии,
что сохранены файлы максимально возможного числа пользователей.

Пример входного файла:

При таких исходных данных можно сохранить файлы максимум двух
пользователей. Возможные объёмы этих двух файлов 30 и 40, 30 и 50 или 40
и 50. Наибольший объём файла из перечисленных пар – 50, поэтому ответ
для приведённого примера:

Решение 1

begin 
  Assign(input, '26.txt'); 
  var (S,N) := ReadInteger2;
  var data := ReadArrInteger(N);
  Sort(data);  
  var (total,count) := (0,0);
  while (count < N) and (total + data[count] <= S) do
  begin
    total += data[count];
    count += 1;
  end;
  var delta := S - total;
  Println(count, data.Last(x -> x - data[count-1] <= delta));
end. 

Решение скорее всего позаимствовано с сайта К. Полякова с косметическими правками в стиле PascalABC.NET.

Решения аналогичных задач на чистом PascalABC.NET содержатся в презентации К.Ю. Полякова.

Ответ.

Задача 27

Имеется набор данных, состоящий из пар положительных целых чисел.
Необходимо выбрать из каждой пары ровно одно число так, чтобы сумма
всех выбранных чисел не делилась на 3 и при этом была максимально
возможной. Гарантируется, что искомую сумму получить можно.
Программа должна напечатать одно число – максимально возможную
сумму, соответствующую условиям задачи.

Входные данные.

Даны два входных файла (файл A и файл B), каждый из которых содержит
в первой строке количество пар N (1 ≤ N ≤ 100000). Каждая из следующих
N строк содержит два натуральных числа, не превышающих 10 000.

Пример организации исходных данных во входном файле:

6
1 3
5 12
6 9
5 4
3 3
1 1

Для указанных входных данных значением искомой суммы должно быть
число 32.
В ответе укажите два числа: сначала значение искомой суммы для файла А,
затем для файла B.
Предупреждение: для обработки файла B не следует использовать
переборный алгоритм, вычисляющий сумму для всех возможных вариантов,
поскольку написанная по такому алгоритму программа будет выполняться
слишком долго.

Решение 1

begin
  Assign(input,'27-b.txt');
  var (s, d) := (0, MaxInt);
  var n := ReadInteger;
  loop n do
  begin
    var (a,b) := ReadInteger2;
    s += Max(a,b);
    var diff := Abs(a-b);
    if diff mod 3 <> 0 then
      d := Min(d, diff)
  end;  
  if s mod 3 <> 0 then
    Print(s)
  else Print(s-d)
end.

Решение скорее всего позаимствовано с сайта К. Полякова с косметическими правками в стиле PascalABC.NET.

Ответ.

Далее рассматриваются задачи, которые не требуют решения в виде программы, однако с помощью программы можно проверить ответ.

Задача 5

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему
новое число R следующим образом.

1. Строится двоичная запись числа N.
2. К этой записи дописываются справа ещё два разряда по следующему
   правилу:

а) складываются все цифры двоичной записи числа N, и остаток
от деления суммы на 2 дописывается в конец числа (справа). Например,
запись 11100 преобразуется в запись 111001;

б) над этой записью производятся те же действия – справа дописывается
остаток от деления суммы её цифр на 2.

Полученная таким образом запись (в ней на два разряда больше, чем
в записи исходного числа N) является двоичной записью искомого числа R.
Укажите такое наименьшее число N, для которого результат работы
данного алгоритма больше числа 77. В ответе это число запишите
в десятичной системе счисления.

Пояснение

Для решения используется функция Bin модуля School, содержащего ряд базовых математических алгоритмов:

uses School;

begin
  for var NN := 1 to 100 do
  begin
    var N := NN;
    var rem := Bin(N).Count(d->d='1') mod 2;
    N := 2*N + rem;
    rem := Bin(N).Count(d->d='1') mod 2;
    N := 2*N + rem;
    Println(NN,N);
  end;
end.

Задача 12

Исполнитель Редактор получает на вход строку цифр и преобразовывает её.
Редактор может выполнять две команды, в обеих командах v и w обозначают
цепочки цифр.

А) заменить (v, w).

Эта команда заменяет в строке первое слева вхождение цепочки v на
цепочку w. Например, выполнение команды
заменить (111, 27)
преобразует строку 05111150 в строку 0527150.
Если в строке нет вхождений цепочки v, то выполнение команды
заменить (v, w) не меняет эту строку.

Б) нашлось (v).

Эта команда проверяет, встречается ли цепочка v в строке исполнителя
Редактор. Если она встречается, то команда возвращает логическое значение
«истина», в противном случае возвращает значение «ложь». Строка
исполнителя при этом не изменяется.

Цикл

ПОКА условие
  последовательность команд
КОНЕЦ ПОКА

выполняется, пока условие истинно.

В конструкции

ЕСЛИ условие
  ТО команда1
  ИНАЧЕ команда2
КОНЕЦ ЕСЛИ

выполняется команда1 (если условие истинно) или команда2 (если условие
ложно).

Какая строка получится в результате применения приведённой ниже
программы к строке, состоящей из 70 идущих подряд цифр 8? В ответе
запишите полученную строку.

НАЧАЛО
  ПОКА нашлось (2222) ИЛИ нашлось (8888)
    ЕСЛИ нашлось (2222)
      ТО заменить (2222, 88)
      ИНАЧЕ заменить (8888, 22)
    КОНЕЦ ЕСЛИ
  КОНЕЦ ПОКА
КОНЕЦ

Решение. Условие — слишком длинное ))

begin
  var s := 70 * '8';
  
  while ('2222' in s) or ('8888' in s) do
    if '2222' in s
      then s := s.Replace('2222', '88', 1)
    else s := s.Replace('8888', '22', 1);
  Print(s);
end.

Ответ

Задача 14

Значение арифметического выражения: 49⁷ + 7²¹ – 7 – записали в системе
счисления с основанием 7. Сколько цифр 6 содержится в этой записи?

Решение.

begin
  var bb := 49bi ** 7 + 7bi ** 21 - 7;
  
  var count := 0;
  repeat
    if bb mod 7 = 6 then
      count += 1;  
    bb := bb div 7;
  until bb = 0;
  
  Count.Print; 
end.

Пояснение 49bi, 7bi — это константы типа BigInteger

Ответ

Решение 2. Используем стандартный метод ToBase модуля School и стандартный метод последовательностей CountOf:

uses School;

begin
  (49bi ** 7 + 7bi ** 21 - 7).ToBase(7).CountOf('6').Print
end.

Задача 15

Обозначим через ДЕЛ(n, m) утверждение «натуральное число n делится без
остатка на натуральное число m».
Для какого наибольшего натурального числа А формула

¬ДЕЛ(x, А) → (ДЕЛ(x, 6) → ¬ДЕЛ(x, 9))

тождественно истинна (то есть принимает значение 1 при любом
натуральном значении переменной х)?

Решение.

begin
  // Возьмём большой диапазон a: от 1 до 10000
  for var a := 10000 downto 1 do
    // Если для всех натуральных x (возьмём некоторый большой диапазон) 
    // выполняется условие задачи, то мы нашли a
    if (1..100000).All(x -> not x.Divs(a) <= (x.Divs(6) <= not x.Divs(9))) then
    begin  
      Print(a);
      break;
    end;
end.

Пояснение Импликация → в PascalABC.NET описывается операцией <=. Это легко показать таблицей истинности.

Пояснение

Тип BigInteger указан “на всякий случай” — если будут возникать очень большие целые. В задачах ЕГЭ — вряд ли

Задача 16

Алгоритм вычисления значения функции F(n), где n – натуральное число,
задан следующими соотношениями:

F(n) = 1 при n = 1;
F(n) = n + F(n − 1), если n – чётно,
F(n) = 2 × F(n − 2), если n > 1 и при этом n – нечётно.

Чему равно значение функции F(26)?

Решение.

function F(n: integer): BigInteger;
begin
  if n = 1 then Result := 1
  else if n.IsEven then Result := n + F(n - 1)
  else Result := 2 * F(n - 2);
end;

begin
  F(26).Print 
end.

Ответ

Омонимы — это слова, которые пишутся и произносятся одинаково, но имеют разное значение. Примеры:

• лук — овощ и лук — метательное оружие;
• коса — причёска и коса — сельскохозяйственный инструмент;
• ключ — родник и ключ — для запирания замка.

Виды омонимов: омофоны, омографы, омоформы, лексические

Существуют омонимы: фонетические/омофоны, графические/омографы, грамматические/омоформы и лексические.

Фонетические, графические и грамматические омонимы

Омофоны (фонетические) — это слова, которые звучат одинаково, но различны в написании. Например: плод и плот, луг и лук, она договорится и можно договориться.

Омографы (графические) — это слова, которые совпадают в том, как пишутся, но различны в произношении. Например: за́мок и замо́к, бе́лки — белки́, при́стань — приста́нь.

Омоформы (грамматические) — это слова, которые совпадают только в одной грамматической форме (иногда в нескольких). Например: мой (местоимение) и мой (глагол), стекло (глагол) и стекло (сущ.).

Лексические омонимы

У них одна и та же часть речи и совпадает грамматическое оформление, эти слова одинаково пишутся и произносятся, однако у них разные значения. Они делятся на полные и частичные.

Полные лексические омонимы (или абсолютные)

Эти слова имеют совпадение во всей системе форм (по падежам, числительным); например: ключ (от замка) и ключ (источник), мешать (что-то в миске) и мешать (кому-то).

Частичные лексические омонимы (или неполные)

У этих слов одна и та же часть речи, но совпадает не вся система форм (например, совпадает только единственное число, именительный падеж, совершенный вид, но не в других падежах и/или множественном числе). Например: лук — метательное оружие и лук — овощ (множественного числа не существует).

Примеры омонимов

Примеры омоформ

Примеры омографов

Примеры омофонов

Омонимы и многозначные слова

Многозначные слова — это те, в которых есть связь между значениями, они чем-то схожи; например: хвост (животного, самолёта, очереди и т. д.), морж (морское животное и человек, купающийся в ледяной воде).

А у омонимов нет никакой связи между значениями; например: мотив (причина/основание) и мотив (мелодия/лейтмотив).

Синонимы и антонимы

Синонимы — это слова, которые пишутся и произносятся по-разному, но имеют идентичное или схожее значение. Например: большой и крупный, выбор и предпочтение, произведение и творение.

Антонимы — это слова, которые имеют противоположное значение. Например: большой и маленький, выбор и безальтернативность, произведение и поглощение.

Омонимы в английском языке

Омонимы существуют не только в русском языке, но и в английском. Например:

• bright — очень умный или наполненный светом;
• current — актуальный или поток воды;
• express — сделать что-то очень быстро или выразить что-то словами;
• kind — вид/тип или заботливый;
• match — объединить похожие предметы или спичка;
• rock — музыкальный жанр или камень;
• rose — встать или роза;
• well — хорошо / в добром здравии или колодец.

Узнайте также, что такое Паронимы, Многозначные слова и Антонимы.