Целые числа. Решение тематических задач

Эта страница является прямым продолжением прошлого раздела "Целые числа: введение", и для изучения нижеизложенного материала я рекомендую предварительно с ним (разделом) ознакомится.

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

  • N белок нашли K орехов и решили разделить их поровну. Определите, сколько орехов останется после того, как все белки возьмут себе равное количество орехов. На вход дается два целых положительных числа N и K, каждое из которых не превышает 10000. Выведите одно целое число - ответ на задачу.

  • Количество белок: 3
    Количество орехов: 14
    Остаток: 2
  • Для решения этой задачи необходимо найти остаток от деления одного числа на другое. Для этого в Аде используется оператор rem (A := B rem C означает что в переменной A будет содержаться остаток от деления B на С. Например, A := 5 rem 2. В данном случае переменная A будет равна 1).

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
    	subtype Sub_Int is Integer range 0..10000; --Создаём подтип для задания ограничений
                                                   --(вводимые числа лежат в диапазоне от 1 до 10000)
    	N, K, Res : Sub_Int;
    begin
    	Put("Количество белок: ");
    	Get(N);
    	Put("Количество орехов: ");
    	Get(K);
    	Res := K rem N;                          --взятие остатка от деления
    	Put("Остаток: ");
    	Put(Item => Res, Width => 1);            --Вывод на экран. Можно Put(Res, 1) или Put(Res)
    end main;


  • Дано натуральное число, выведите его последнюю цифру. На вход дается натуральное число N, не превосходящее 10000. Выведите одно целое число - ответ на задачу.

  • Введите натуральное число: 753
    3
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
    	subtype Sub_Int is Integer range 1..10000;
    	x : Sub_Int;
    begin
    	Put("Введите натуральное число: ");
    	Get(x);
    	Put(Item => (x rem 10), Width => 1);     --Вычисление результата происходит внутри
                                                 --процедуры вывода. Такая запись сокращает код программы
    end main;


  • Дано двузначное число. Выведите его первую цифру (число десятков). На вход дается натуральное двузначное число N. Выведите одно целое число - ответ на задачу.

  • Введите двузначное число: 42
    4
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure Main is
    	subtype Sub_Int is Integer range 10..99;     --Так как по условию задачи вводится двузначное число
    	x : Sub_Int;
    begin
    	Put("Введите двузначное число: ");
    	Get(x);
    	Put(Item => (x / 10), Width => 1);           --Так как используются переменные целого типа, то
                                                     --остаток от деления (дробная часть) будет отброшен
    end Main;


  • Дано целое неотрицательное число N, определите число десятков в нем (предпоследнюю цифру числа). Если предпоследней цифры нет, то можно считать, что число десятков равно нулю. На вход дается целое положительное число N (0 ≤ N ≤ 1000000). Выведите одно целое число - ответ на задачу.

  • Введите целое неотрицательное число: 73
    7
  • По условию задачи максимальное значение вводимого числа равно 1000000. Как мы уже знаем из прошлого раздела, переменные типа Integer не могут превышать 32767. Для решения этой задачи понадобится более вместительный тип. Для хранения чисел, превышающих тип Integer, существует тип Long_Integer (–231+1 .. +231-1 или -2147483648..+2147483647). Его размер, конечно же, тоже зависит от архитектуры компьютера, но будем считать что он вмещает числа из указанного диапазона (атрибуты Long_Integer'First и Long_Integer'Last покажут точные границы этого типа для каждой конкретной архитектуры). Существуют и более вместительные типы, но для наших целей пока хватит Long_Integer.

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Long_Integer_Text_IO; use Ada.Long_Integer_Text_IO; --Задействуем новый тип данных
                                                             --Long_Integer и делаем доступными для него
                                                             --операции ввода/вывода (Get() b Put())
    procedure Main is
    	subtype Sub_LI is Long_Integer range 0..1000000; --Создаём подтип для ограничение вводимых данных
    	Res, X : Sub_LI;
    begin
    	Put("Введите целое неотрицательное число: ");	
    	Get(X);
    	Res := X rem 100; --Отсекаем от введённого числа 2 последние цифры
    	Res := Res / 10;   --Берём число десятков
    	Put(Item => Res, Width => 1);
    end Main;


  • Дано целое трехзначное число. Найдите сумму его цифр. На вход дается число от 100 до 999. Выведите одно целое число - ответ на задачу.

  • Введите целое трехзначное число: 476
    17
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure Main is
    	subtype Sub_Int is Integer range 100..999;
    	X: Sub_Int; 
    	Res : Integer;
    begin
    	Put("Введите целое трехзначное число: ");
    	Get(X);
    	Res := (X / 100) + ((X rem 100) / 10) + (X rem 10); 
                                           --(X / 100) - получаем первую цифру трёхзначного числа
                                           --((X rem 100) / 10) - получаем вторую цифру трёхзначного числа
                                           --(X rem 10) - получаем третью цифру трёхзначного числа
    	Put(Item => Res, Width => 1);
    end Main;


  • На вход дается натуральное число N. Выведите следующее за ним четное число. На вход дается целое положительное число N, не превышающее 10000. Выведите одно целое число - ответ на задачу.

  • Пример 1:

    Введите целое число: 7
    Следующее чётное число: 8

    Пример 2:

    Введите целое число: 8
    Следующее чётное число: 10

  •  

    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure Main is
    	subtype Sub_Int is Integer range 1..10000;
    	X : Sub_Int;
    	Res : Integer; --Если X будет равен 10000, то следующее положительное число будет 10002,
                       --а это больше, чем может вместить тип Sub_Int, поэтому результат имеет более
                       --широкий тип - Integer
    begin
    	Put("Введите целое число: ");
    	Get(X);
    	if X rem 2 /= 0 then
    		Res := X + 1;
    	else
    		Res := X + 2;
    	end if;
    	Put("Следующее чётное число: ");
    	Put(Item => Res, Width => 1);
    end Main;


  • В некоторой школе решили набрать три новых математических класса и оборудовать кабинеты для них новыми партами. За каждой партой может сидеть два учащихся. Известно количество учащихся в каждом из трех классов. Выведите наименьшее число парт, которое нужно приобрести для них. Каждый класс сидит в своем кабинете. Программа получает на вход три целых неотрицательных числа: количество учащихся в каждом из трех классов (числа не превышают 1000). Выведите одно целое число - ответ на задачу.

  • Пример 1:

    Количество учащихся в первом классе: 20
    Количество учащихся во втором классе: 21
    Количество учащихся в третьем классе: 22
    Нужно приобрести парт: 32

    Пример 2:

    Количество учащихся в первом классе: 16
    Количество учащихся во втором классе: 18
    Количество учащихся в третьем классе: 20
    Нужно приобрести парт: 27

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
    	subtype Sub_Int is Integer range 1..1000;
    	X, Y, Z: Sub_Int;
    	Res : Integer;
    begin
    	Res := 0;
    	Put("Количество учащихся в первом классе: "); Get(X);
    	Put("Количество учащихся во втором классе: "); Get(Y);
    	Put("Количество учащихся в третьем классе: "); Get(Z);
    	Res := X / 2 + X rem 2 + Y / 2 + Y rem 2 + Z / 2 + Z rem 2; --Все вычисления в одной строке
    	Put("Нужно приобрести парт: "); Put(Item => Res, Width => 1);
    end main;


  • Пирожок в столовой стоит A рублей и B копеек. Определите, сколько рублей и копеек нужно заплатить за N пирожков. Программа получает на вход три числа: A, B, N - целые, положительные, не превышают 10000. Программа должна вывести два числа через пробел: стоимость покупки в рублях и копейках.

  • Пример ввода 1:
    10 15 2
    Пример вывода 1:
    20 30

    Пример ввода 2:
    2 50 4
    Пример вывода 2:
    10 0

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO; --Будем использовать Put() для вывода пробела
     
    procedure Main is
    	subtype Sub_Int is Integer range 1..1000;
    	A, B, N: Sub_Int;
    	Rub, Cop : Integer;
    begin
    	Get(A); Get(B); Get(N);
     
    	Rub := A * N + (B * N) / 100;      --Считаем рубли
    	Cop := (B * N) rem 100;            --Считаем копейки
     
    	Put(Item => Rub, Width => 1);
    	Put(" ");
    	Put(Item => Cop, Width => 1);
    	New_Line;
    end Main;

  • Вывод строк и чисел можно осуществлять с помощью одного оператора Put() или Put_Line(). В GNAT для этого предусмотрена операция преобразования числа в строку. Для вывода двух чисел в предыдущей задаче можно было сделать так: Put("Result is" & Integer'image(Rub) & Integer'image(Cop)) или Put("Result is" & Integer'image(Integer(Rub)) & Integer'image(Integer(Cop))). Чем отличаются эти две операции рекомендую выяснить самостоятельно :). Т.е. решение можно переписать иначе:

    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
     
    procedure Main is
    	subtype Sub_Int is Integer range 1..1000;
    	A, B, N: Sub_Int;
    	Rub, Cop : Integer;
    begin
    	Get(A); Get(B); Get(N);
     
    	Rub := A * N + (B * N) / 100;      --Считаем рубли
    	Cop := (B * N) rem 100;            --Считаем копейки
     
    	Put_Line(Integer’image(Rub) & Integer’image(Cop));	
     
    end Main;


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

  • Пример ввода 1:
    1 1 1 2 2 2
    Пример вывода 1:
    3661

    Пример ввода 2:
    1 2 30 1 3 20
    Пример вывода 2:
    50

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure Main is
    	h1, m1, s1, h2, m2, s2 : Integer;
    	res : Integer;
    begin
    	Get(h1); Get(m1); Get(s1);
    	Get(h2); Get(m2); Get(s2);
    	res := (h2 - h1) * 3600 + (m2 - m1) * 60 + (s2 - s1);
    	Put(Item => res, Width => 1);
    end Main;


  • Длина Московской кольцевой автомобильной дороги — 109 километров. Байкер Вася стартует с нулевого километра МКАД и едет со скоростью V километров в час. На какой отметке он остановится через T часов? Программа получает на вход целые числа V и T. Если V > 0, то Вася движется в положительном направлении по МКАД, если же значение V < 0, то в отрицательном. 0 ≤ T ≤ 1000, -1000 ≤ V ≤ 1000. Программа должна вывести целое число от 0 до 108 — номер отметки, на которой остановится Вася.

  • Пример 1:
    Скорость: 60
    Время: 2
    Номер отметки: 11

    Пример 2:
    Скорость: -1
    Время: 1
    Номер отметки: 108

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure Main is
    	subtype Time is Integer range 0..1000;      --Время по условию задачи ограничено 1000 часами
    	subtype Speed is Integer range -1000..1000; --Скорость ограничена 1000 км.ч и имеет знак '+' или '-'
                                                    --в зависимости от направления движения
    	S : constant Integer := 109;                --Объявление константы. Т.к. дорога кольцевая и путь
                                                    --никогда не меняется, следовательно длина одного круга -
                                                    --величина постоянная => константа
    	Res : Integer;
    	V : Speed;
    	T : Time;
    begin
    	Put("Скорость: "); Get(V);
    	Put("Время: "); Get(T);
     
    	Res := V * T rem S;                         --Расчёт. Так как дорога кольцевая, то точка, в которой
                                                    --оказался рокер равна остатку от деления пройденного
                                                    --расстояния на длину круга
    	if Res < 0 then --Если мотоцикл ехал в обратном направлении
    		Res := Res + S;
    	end if;
    	Put("Номер отметки: ");
    	Put(Item => Res, Width => 1);	
    end Main;

    В этой задаче введён новый элемент - константа. Константа - это постоянная, которая никогда не меняется. Её величина задаётся при объявлении.


  • Дано четырехзначное число. Определите, является ли его десятичная запись симметричной. Если число симметричное, то выведите "Симметричное", иначе выведите "Несимметричное". Число может иметь меньше четырех знаков, тогда нужно считать, что его десятичная запись дополняется слева незначащими нулями.

  • Пример 1:
    Число: 2002
    Симметричное

    Пример 2:
    Число: 2008
    Несимметричное

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    procedure main is
    	X : Integer;
    	First_Part, Second_Part : Integer;
    begin
    	Get(X);
    	First_Part := X / 100;                                      --Первая часть числа
    	Second_Part := X rem 100;                                   --Вторая часть числа
    	First_Part := (First_Part rem 10) * 10 + (First_Part / 10); --Если длина числа меньше четырёх
                                                                    --символов
    	if X = 0 then                                               --Если введён ноль
    		Put("Несимметричное");
    	elsif First_Part = Second_Part then                         --Число симметрично
    		Put("Симметричное");
    	else
    		Put("Несимметричное");                             --Число не симметрично
    	end if;
    end main;


  • Улитка ползет по вертикальному шесту высотой H метров, поднимаясь за день на A метров, а за ночь спускаясь на B метров. На какой день улитка доползет до вершины шеста? Программа получает на вход целые неотрицательные числа H, A, B, причем H > B. Числа не превосходят 100. Программа должна вывести одно натуральное число. Гарантируется, что A > B.

  • Длина шеста: 10
    Подъём за день: 3
    Спуск за ночь: 2
    Улитка доползёт до вершины шеста на 8 день

  • Для решения этой задачи может понадобится оператор цикла. В Аде их существует несколько видов, но пока мы рассмотрим только один из них. Общий вид:

    loop
            Здесь_могут_выполняться_какие-то_действия;
            exit when Условие_выхода_из_цикла;
            Здесь_могут_выполняться_какие-то_действия;
    end loop;

    Рассмотрим его на примере. Пусть нам нужно просуммировать числа от 1 до 10. Решение может выглядеть так:

    ...
    N := 1;                   --Счётчик цикла
    SUM := 0;                 --Сумма (сюда будет записан результат)
    loop                      --Начало цикла
    	SUM := SUM + N;       --Суммируем "накопившуюся" сумму с текущим значением счётчика
    	exit when N = 10;     --Выход из цикла, если значение счётчика равно 10
    	N := N + 1;           --Увеличиваем значение счётчика при каждом проходе (на каждой итерации)
    end loop;                 --конец цикла
    ...

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    procedure Main is
    	H, A, B, Pos, Day : Integer;
    begin
    	Put("Длина шеста: "); Get(H);
    	Put("Подъём за день: "); Get(A);
    	Put("Спуск за ночь: "); Get(B);
    	Pos := 0;                   --Позиция, на которой находится улитка
    	Day := 0;                   --Счетчик дней
    	loop                        --Цикл
    		Day := Day + 1;         --С каждым днём счётчик увеличивается на 1
    		Pos := Pos + A;         --Днём улитка ползёт вверх A метров
    		exit when Pos >= H;     --Если улитка доползла до вершина, то выходим из цикла
    		Pos := Pos - B;         --Ночью улитка спускается на B метров
    	end loop;                   --Конец цикла
    	Put("Улитка доползёт до вершины шеста на" & Integer'image(Day) & " день");
    end Main;


  • Процентная ставка по вкладу составляет P процентов годовых, которые прибавляются к сумме вклада через год. Вклад составляет X рублей Y копеек. Определите размер вклада через K лет. Программа получает на вход ЦЕЛЫЕ числа P, X, Y, K. Программа должна вывести два числа: величину вклада через K лет в рублях и копейках. Дробное число копеек по истечение года отбрасывается. Перерасчет суммы вклада (с отбрасыванием дробных частей копеек) происходит ежегодно.

  • Процент по вкладу (годовых): 12
    Внесено рублей: 179
    Внесено копеек: 0
    Срок вклада (лет): 5
    Итог: 315 рублей 43 копейки

  • Для решения этой задачи Вам, возможно, понадобится рассмотренный в задаче 12  оператор цикла loop

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
    procedure main is
    	p, x, y, k : Integer;
    begin
    	Get(p); Get(x); Get(y); Get(k);
     
    	x := x * 100 + y;
    	while k > 0 loop
    		x := x + x * p / 100;
    		k := k - 1;
    	end loop;
     
    	y := x rem 100;
    	x := x / 100;
    	Put(Item => x, Width => 1);	
    	Put(" ");
    	Put(Item => y, Width => 1);	
    end main;


В разделе "Шпаргалка" кратко описаны все функции, рассмотренные в разделе "Целые числа".

2 comments on “Целые числа. Решение тематических задач

  1. В задаче 1 один будет генерироваться ошибка если остаток будет 0.

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *