Завдання № 43. Перевірити, чи починається кожен з членів послідовності з десяткової цифри, на яку закінчується попередній » Pascal - основи програмування

Основи програмування на мові Pascal

 

Спонсори

Завдання № 43. Перевірити, чи починається кожен з членів послідовності з десяткової цифри, на яку закінчується попередній

Завдання № 43. Перевірити, чи починається кожен з членів послідовності з десяткової цифри, на яку закінчується попередній
Формулювання. Дана послідовність натуральних чисел, обмежена введенням нуля. Перевірити, чи починається кожен з її членів (з другого) з десятковою цифри, на яку закінчується попередній. Наприклад, такий послідовністю буде 14 47 712 2179 9 вересня 93 0 (також збережений обмежує нуль).
Рішення. Завдання вирішується через цикл з передумовою, що характерно для задач на послідовно-вательность з обмежувачем. При її рішенні ми могли б не розглядати «вироджені ва-ріант», в яких на вхід буде подаватися, наприклад, порожня послідовність (тобто со-стоїть з єдиного нуля) або послідовність з одного члена, оскільки на питання про те, задовольняють Чи такі послідовності заданому критерію, відповісти теоретично достатньо важко. Доцільніше було б вважати виконання критерію для таких послідовно-ності невизначеним, що, однак, у форматі даваемого нами відповіді не представляється можливим: під «перевіркою» характеристичного властивості в даному випадку розуміється відповідь на питання: або «так», і послідовність відповідає заданим вимогам, або «ні», і, соот-льної, не відповідає.
      Отже, нам потрібно замість відповіді про «невизначеності» перевіряється властивості дати один з допустимих відповідей. Напевно, розумно було б дати при обробці вироджених слу-чаїв програмою відповідь «ні». Ми візьмемо це на замітку і спробуємо зробити контроль іськлю-чений, коли вже буде готове рішення задачі для загального випадку, щоб заздалегідь не наробити помилок. Це необхідно тому, що ми спробуємо ініціалізувати значення змінних при запуску програми таким чином, щоб обробку вироджених випадків можна було ви-конати з мінімальним вкладенням додаткового коду - ми вже робили це в задачі 32.
Тепер про змінних. Так як нам необхідно перевіряти виконання критерію на двійках (парах) елементів, то і зберігати в пам'яті потрібно відразу два елементи (a і b). Перший елемент не має попередника, тому після введення ми не обробляємо його і можемо вводити слідую-щий елемент в одному операторі з ним:

read (a, b);

      Маючи два елементи, ми вже можемо виконати перевірку нашого властивості. Проте вже на цьому етапі ми можемо здогадатися, що в силу необхідності виконати перевірку для всіх пар елементів послідовності слід відразу помістити її в цикл. Ми будемо зчитувати кожен черговий член послідовності в змінну b, і так як останнім вводиться число за умовою - 0, то передумовою циклу буде b <> 0 (так як при b = 0 цикл повинен припинитися):
while b <> 0 do begin
    ...
    a: = b;
    read (b)
  end;

     На місці трикрапки буде розташовуватися код перевірки кожної пари, повністю охоплюють-щий визначення нашого властивості. Примітка: у «шаблоні» основного циклу ми виділили також оператор a: = b, який забезпечує рух по кожним двом сусіднім елементам по-послідовності. Слід звернути увагу на те, що ми повинні перевіряти виконання нашого властивості для 1-го і 2-го, 2-го і 3-го, 3-го і 4-го і т. Д. Елементів послідовності.
      Коли ми вже виконали перевірку для двох елементів, наприклад, для 1-го (який збе-нітся у змінній a) і 2-го (який зберігається в змінній b), то далі ми присвоюємо пере-менной a значення змінної b (у якій у нас зберігався другого елемент), потім зчитуємо в b 3-й елемент, щоб перевірити властивість для 2-го і 3-го елементів і т. п.
    При цьому потрібно чітко розуміти, що ми не можемо зчитувати в циклі відразу дві змін-ні, тому що при такому підході перевірка буде виконуватися лише для 1-го і 2-го, 3-го і 4-го і т. Д. Елементів , що невірно.
    Розберемо саму перевірку. Так як на кожному кроці циклу програмі потрібно з'ясувати, чи починається наступний член послідовності з десятковою цифри даного, то, маючи дан-ний член у змінній a і наступний член в b, ми повинні порівняти останню цифру a (обо-значимий її як last) з першою цифрою b (позначимо її як first). Зробити це можна так:
last: = a mod 10;
first: = b;
while first> 9 do begin
  first: = first div 10
end;

    Тут ми спочатку добули останню цифру a (рядок 1), потім скопіювали в last значення b (змінну b не можна змінювати, оскільки її значення знадобиться нам на наступному кроці цик-ла) і у вкладеному циклі розділили last на 10 стільки разів, щоб в ній залишилася лише одна циф-ра, яка є його першою цифрою.
     Здобувши потрібні цифри, ми можемо виконати їх порівняння і вийти з циклу в тому випадку, коли вони не рівні, тому що при цьому порушується наше характеристичне властивість, дане в умові, і після цього подальша перевірка безглузда:
if last <> first then break;

    Коли цикл завершиться, нам залишиться лише вивести на екран результат порівняння пере-сних last і first: якщо цикл завершився, то послідовність відповідає заданому властивості (так як не було виходу через break), вони будуть рівні і буде виведений відповідь true; якщо ж був здійснений вихід через break, то змінні нерівні і відповідь, відповідно, false.
    Тепер спробуємо оптимізувати програму для обробки вироджених випадків для пу-стій послідовності (коли вводиться єдиний 0) і для послідовності з одного члена (коли вводиться деяке число і 0): ми домовилися виводити для них відповідь false.
Очевидно, в даний момент наша програма обробляє коректно мінімальний випадок з двох членів: тоді проходить одне повторення тіла циклу, в якому змінні last і first отримують значення, потім може статися вихід за break або завершення циклу по введенню нуля, як і повинно бути.
      Однак якщо ми введемо послідовність з одного члена, то при введенні a і b в перемін-ву a піде цей член, а в b виявиться обмежує нуль, що призведе до невиконання входу в основний цикл і програма перейде до оператора виведення writeln (last = first ), що невер-но, так як значення змінних last і first в даний момент буде не визначено і вираз в операторі виведення може дати будь-який результат. Це означає, що для уникнення подібного результату нам потрібно виконати ініціалізацію змінних last і first свідомо нерівними значеннями, щоб отримати гарантований відповідь false при введенні послідовності з одного члена. Це можна зробити так:
first: = 1;
last: = 0;

    Але що буде, якщо ввести послідовність, що складається з одного нуля? У нашій про-грамі це неможливо, так як оператор введення на початку містить дві змінні, і якщо ми відразу введемо 0, то програма «зависне» в очікуванні введення другого числа. Щоб уникнути цього, ми повинні вводити одне число в змінну a, і якщо воно не дорівнює 0, потрібно ввести b. Разом з цим необхідно заздалегідь присвоїти змінної b число 0, так як вона була визначена в разі послідовності з одного члена, щоб не здійснився вхід в основний цикл:
read (a);
b: = 0;
if a <> 0 then read (b);

Ця конструкція замінить оператор read (a, b), який ми описували в самому початку рішення завдання.

 

Код:


  1. program LastAndFirst;
  2. var
  3. a, b, first, last: word;
  4. begin
  5. first := 1;
  6. last := 0;
  7. read(a);
  8. b := 0;
  9. if a <> 0 then read(b);
  10. while b <> 0 do begin
  11. last := a mod 10;
  12. first := b;
  13. while first > 9 do begin
  14. first := first div 10
  15. end;
  16. if last <> first then break;
  17. a := b;
  18. read(b)
  19. end;
  20. writeln(last = first)
  21. end.

0043.-LastAndFirst.rar [715 b] (cкачувань: 2)

скачать dle 10.4фильмы бесплатно Наступна сторінка » Завдання № 44. Перевірити, чи є послідо... Попередня сторінка » Завдання № 42. Знайти кількість прости...