Pascal: строковый тип и множества

Задача 1.

Вывести в одну строку ABBCCCDDDD …. ZZ…Z.

Переменные:

i – переменная цикла; определяет, какая буква выводится;
k – количество повторений буквы;
j – переменная цикла.

Алгоритм решения задачи:

  1. цикл for i:=’A’ to ‘z’ do определяет, какую букву выводим на печать;
  2. внутренний цикл for j:=1 to k do определяет, сколько раз будет печататься буква;
  3. выводим заданную букву k раз на экран;
  4. после вывода всех букв закрываем строку оператором writeln.
var   i : char;
     k,j : integer;
begin
         k:=1;
         for i:= 'A' to 'Z' do
         begin
               for j:=1 to k do  write(i);
                k:=k+1;
         end;
         writeln;
end.

Задача 2.

Дана строка символов. Удалить из нее все знаки препинания.

Переменные:

i – переменная цикла;
L – длина строки;
str – строка текста;
str1 – вспомогательная строка;
m – множество знаков препинания.

Алгоритм решения задачи:

  1. задаем значение множества m – множества знаков препинания;
  2. вводим строку str с клавиатуры;
  3. цикл for i:=1 to l do осуществляет построение вспомогательной строки без знаков препинания: берем отдельный символ строки и проверяем, не является ли он знаком препинания. Если да, то присоединяем этот символ к новой вспомогательной строке. Если нет, то переходим к следующему элементу строки;
  4. первоначальную строку заменяем на вспомогательную;
  5. выводим сроку на экран.
var   str, str1 : string;
        L, i : integer;
         m : set of char;
begin
         m:=['.', ',', '!', ':', ';', '?', '-'];
         writeln('Введите текст');
         readln(str);  L:=length(str); str1:='';
         for i:=1 to L do
                if not(str[i] in m) then str1:=str1+str[i];
         str:=str1;
         writeln('Преобразованный текст ', str);
end.

Задача 3.

Дана строка символов. Выделить подстроку между пер-вой и последней точкой.

Переменные:

i – номер позиции, которая соответствует точке;
j – местоположение первой точки;
m – местоположение последней точки;
str – строка текста;
s1 – вспомогательная переменная.

Алгоритм решения задачи:

  1. вводим строку str и присваиваем значение вспомогательной переменной s1:=str;
  2. определяем местоположение первой точки в тексте; если точка есть, то вырезаем из s1 текст до нее;
  3. ищем последнюю точку в цикле while i<>0 do; если она есть, то значение переменной m указывает на ее местоположение;
  4. в зависимости от присутствия точек выделяем подстроку s1:=copy(str,j+1,m–j–1) и выводим результат на экран.
var str, s1 : string;
       i, m, j : integer;
begin
        writeln('Введите текст');
        readln(str);
        s1:=str; i:=pos('.',s1); j:=i; m:=0;
        if (i<>0) then
                       begin
	               while i<>0 do
        	                    begin delete(s1,1,i); m:=m+i; i:=pos('.',s1); end;
                          if m<>j then
	                            begin
                                       s1:=copy(str,j+1,m–j–1);
                                       writeln('Часть текста между 1-й и последней точкой');
                                        writeln(s1);
                                        end
                          else writeln('В тексте только одна точка');
	           end
	           else writeln('В тексте нет ни одной точки');
end.

Задача 4.

Дана строка символов. Определить, является ли она записью десятичного числа, кратного трем.

Необходимо удостовериться, что введенная строка состоит только из цифр, т.е. может быть преобразована в десятичное число. Само преобразование цифры в число сделать очень просто. Поскольку коды символьных переменных – цифр – следуют один за другим, то функция ord в выражении ord(s1[i])–ord(‘0’) поможет нам сделать это.
Переменные:

i – переменная цикла;
s1 – строка цифр;
m – длина строчки;
k – счетчик цифр.

Алгоритм решения задачи:

  1. вводим строку s1;
  2. организуем в строке поиск цифр до тех пор, пока не встретим конец строчки или не обнаружим наличие ошибки в арифметическом выражении;
  3. если встречается цифра, то добавляем ее к общей сумме цифр;
  4. после определения суммы цифр определяем, кратна ли она на трем;
  5. в зависимости от полученного результата выводим ответ на экран.
var  s1 : string;
        k, i, m : integer;
begin
         writeln('Введите строку');
         readln(s1);
         m:=length(s1);
         k:=0; i:=1;
         repeat
                case s1[i] of
                '0'..'9' :  k:=k+(ord(s1[i])–ord('0'));
                '  ' : ;
                else k:=–1;
                end;
                i:=i+1;
         until (i>m) or (k<0);
         if k mod 3 = 0
                       then writeln('Это десятичное число, кратное 3')
                       else writeln('Это не десятичное число, кратное 3')
end.

Задача 5.

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

Переменные:

i – вспомогательная переменная;
s – строка текста;
k – счетчик слов.

Алгоритм решения задачи:

  1. вводим строку s;
  2. на каждом шаге внешнего цикла отыскиваем очередное слово в строке и увеличиваем счетчик слов;
  3. выводим результат на экран.
var s: string;  i,k: integer;
begin
  writeln('Введите строку');
  readln(s);
  k:=0; i:=1;
  while i<=length(s) do
       begin
       {пропускаем пробелы}
       while (s[i]=' ') and (i<=length(s)) do i := i+1;
       if i<=length(s) then k := k+1;
       {ищем новый пробел}
       while (s[i]<>' ') and (i<=length(s)) do i := i+1;
       end;
  writeln('количество слов =',k)
end.

Задача 6.

Дана строка символов. Группы символов в ней между группами пробелов считаются словами. Определить длину самого короткого и самого длинного слова.

Переменные:

i – индекс очередного символа в строке;
s – строка текста;
beginStr и endStr – начало и конец слова;
len – длина слова;
max – длина наибольшего слова;
min – длина наименьшего слова.

Алгоритм решения задачи:

  1. вводим строку s;
  2. устанавливаем начальные значения max и min;
  3. организуем внешний цикл для поиска очередного слова в строке;
  4. найдя слово, определяем его длину и при необходимости корректируем max и min;
  5. выводим результат на экран.
var s:string;
    i,min,max,beginStr,endStr,len:integer;
begin
  writeln('Введите строку');
  readln(s);
  max:=0; min:=255;
  i:=1;
  while i<=length(s) do
       begin
       {пропускаем пробелы}
       while (s[i]=' ') and (i<=length(s)) do i:=i+1;
       if i<=length(s) then begin
                            beginStr:=i;
                            {нашли начало слова, ищем его конец}
                            while (s[i]<>' ') and (i<=length(s)) do                                        i:=i+1;                             endStr:=i–1;                             writeln(beginStr,'–',endStr);                             len:=endStr–beginStr+1;                             if len>max then max:=len;
                            if len<> 0 do delete (s, pos('..', s), 1);
        writeln('Полученная строка : ', s);
end.

Задача 8.

Присвоить литерным переменным с2, с1 и с0 соответственно левую, среднюю и правую цифры трехзначного числа k.

var c0, c1, c2 : char;
          n0, k, d : integer;
begin
        writeln('Введите трехзначное число');
        readln(k);
        n0:=ord('0');
        d:=k div 100;              c2:=chr(n0+d);
        d:=k mod 100 div 10; c1:=chr(n0+d);
        d:=k mod 10;              c0:=chr(n0+d);
        writeln('c2= ', c2);
        writeln('c1= ',c1);
        writeln('c0= ',c0);
end.

Задача 9.

Используя только литерный ввод, т.е. процедуру readln(c), где с – литерная переменная, ввести непустую после-довательность цифр, перед которой может находиться знак » + » или » – » и за которой следует пробел, и, получив соответст-вующее число, присвоить его целой переменной k.

var c : char;
      sign, n0, k : integer;
begin
         {определение знака числа:}
         sign:=1;
         readln(c);
         if c='–' then
                    begin sign:=–1; readln(c) end
                    else    if c='+' then readln(c);
         {чтение цифр (первая – в c) и вычисление абсолютной величины числа k по схеме  Горнера:}
         n0:=ord('0'); k:=0;
         repeat
                  k:=10*k+ord(c)–n0;
                   readln(c)
         until c=' ';
         {учет знака:}
         k:=sign*k;  writeln(k);
end.

Задача 10.

Программа. Напечатать заданную непустую строку:
а) удалив из нее все цифры и удвоив знаки « + » и « – » :

var s : string;
i : integer;
begin
writeln('Введите строку:');
readln(s);
for i:=1 to length(s) do   if (s[i]='+')or(s[i]='–') then write(s[i],s[i])
         else  if (s[i]<'0')or(s[i]>'9') then write(s[i]);
         writeln
end.

б) удалив из нее все знаки « + » , непосредственно за которыми идет цифра:

var a, b : char;    {a – очередная литера строки, b – следующая}
          s : string;
           i : integer;
begin
        writeln('Введите строку:');
        readln(s);
        for i:=1 to length(s) do
        begin
              a:=s[i];
              if a<>'+' then write(a)
                             else   if i<'0') or (b>'9') then write(a)
                                                                     end
                                                            else write(a);
        end;
        writeln
end.

Задача 11.

type str=string[100];

Описать функцию count(s), подсчитывающую общее коли-чество цифр и знаков ‘ + ‘, ‘ – ‘ и ‘ * ‘, входящих в строку s.

Переменные:

а) в функции count:

s – строка (формальный параметр);
i – счетчик цикла (локальная переменная);
k – общее количество цифр и знаков ‘ + ’ , ‘ * ’ , ‘ – ‘ в заданной строке (локальная переменная);

б) в основной программе:

s1 – введенная строка (локальная переменная);
k1 – общее количество цифр и знаков ‘+’, ‘*’, ‘–‘ в заданной строке s1 (фактический параметр).

Алгоритм решения задачи:

  1. создаем функцию count, подсчитывающую общее количество цифр и знаков ‘+’, ‘*’, ‘–‘ в заданной строке;
  2. вводим строку s1;
  3. вызываем функцию count и выводим значение счетчика k1 на экран;
  4. завершаем работу программы.
type str=string[100];
var s1 : str;
       k1 : integer;
function count(var s:str) : integer;
var i, k : integer;
begin
         k:=0;
         for i:=1 to length(s) do if s[i] in ['0'..'9', '+', '–', '*'] then k:=k+1;
         count:=k
end;
 begin
writeln('Введите строку');
 readln(s1);
k1:=count(s1);
writeln('Количество цифр и знаков – ', k1:5);
end.

Задача 12.

type M=set of 0..99;

Описать функцию card(A), подсчитывающую количество элементов множества A типа M (ноль используйте как прекращение ввода). (Например, card([5,8,23])=3.)

Переменные:

а) в функции card:

A – множество (формальный параметр);
p – счетчик цикла от 0 до 99 (локальная переменная);
k – количество элементов множества А (локальная перемен-ная);

б) в основной программе:

x – введенное число (локальная переменная);
b – созданное множество (локальная переменная);
k1 – количество элементов в созданном множестве (факти-ческий параметр).

Алгоритм решения задачи:

  1. создаем функцию card, подсчитывающую количество элементов множества;
  2. организуем пустое множество;
  3. в цикле repeat … until вводим числа до тех пор, пока не ввели 0, и дописываем их во множество;
  4. вызываем функцию card и выводим значение счетчика k1 на экран;
  5. завершаем работу программы.
type M=set of 0..99;
var b : m;
    k1, x : integer;
function card(A:M) : integer;
var p,k : integer;
begin
        k:=0;         for p:=0 to 99 do if p in A then k:=k+1;
        card:=k
end;
 begin      b:=[ ];
repeat  write('Введите число >0<=99 – ');
readln(x); b:=b+[x];
until x=0;
k1:=card(b);
writeln('Количество различных элементов множества', k1);
end.

Задача 13.

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

Переменные:

let – множество малых латинских букв;
c – очередной символ строки;
s – введенная строка;
i – переменная цикла.

Алгоритм решения задачи:

  1. организуем пустое множество let;
  2. вводим строчку s;
  3. организуем цикл, в котором просматриваем символы строки s до тех пор, пока не встретим ‘.’, и проверяем, входит ли этот символ во множество let (т.е. символ – малая латинская бук-ва);
  4. если очередной символ строки не входит во множество let, то этот символ встретился впервые, выводим ее на экран и дописываем во множество;
  5. завершаем работу программы.
var
         let : set of 'a'..'z';
         s : string;  c : char;  i : integer;
begin
         let:=[ ];      {множество букв в рассмотренной части текста}
         readln(s);
         i:=1;
         while s[i]<>'.' do
         begin if not(s[i] in let) then        {1-е вхождение}
                                               begin write(s[i]); c:=s[i]; let:=let+[c] end;                    i:=i+1;
         end;
         writeln
end.

Задача 14.

type series=file of real;

Описать функцию neg(s), подсчитывающую сумму отрицатель-ных элементов в файле s типа series.

Переменные:

а) основная программа:

f – файл вещественных чисел (глобальная переменная);
y – очередное число для записи в файл (глобальная пере-менная);
n – сумма отрицательных элементов файла (глобальная пе-ременная);
k – счетчик цифр.

б) функция neg:

s – файловая переменная (локальная, формальная перемен-ная);
x – очередной элемент файла (локальная переменная);
sum – сумма отрицательных элементов файла (локальная переменная).

Алгоритм решения задачи:

  1. свяжем файл proba.txt с файловой переменной f и откроем его для записи;
  2. организуем цикл, в котором вводим числа и записываем их в файл до тех пор, пока не введем 0;
  3. вызываем функцию neg, в которой открываем файл для чтения, считываем последовательно элементы файла и определяем сумму отрицательных элементов файла;
  4. выводим значение суммы на экран.
type series=file of real;
var f : series;
      n,y : real;
function neg(var s : series) : real;
var sum,x : real;
begin
      reset(s); sum:=0;       while not eof(s) do       begin             read(s,x);              if x<0 then sum:=sum+x
      end;
      neg:=sum ; close(s)
end;
begin
     assign (f,'c:\tp\bin\proba.txt');
     rewrite(f);
     repeat
            write('Введите число (0 – конец ввода)– ');
            readln(y);
            write(f,y);
     until (y=0);
     close (f);
     n:=neg(f);
     writeln('Сумма отрицательных элементов файла n= ',n:10:3);
     close(f);
end.

15.

type row=file of 0..999;

Описать логическую функцию sort(r), проверяющую, упоря-дочены ли по возрастанию элементы непустого файла r типа row.

type row1 = 0..999;
        row = file of row1;

var r : row;
    x,y : row1;
    i,k : integer;
function sort(var r : row) : boolean;
var x,y : row1; ok : boolean;
begin
      reset(r);
      read(r,y); ok:=true;       while not eof(r) and ok do            begin x:=y; read(r,y);  ok:=x

16.

type reals=file of real;

Описать функцию less(f) от непустого файла f типа reals, которая подсчитывает количество элементов файла f, меньших среднего арифметического всех элементов этого файла.

type reals = file of real;
var f1 : reals;
      a : real;l,i : integer;
function less(var f : reals) : integer;
var k : integer; x,s : real;
begin                                    {подсчет среднего арифметического:}
      reset(f); k:=0; s:=0;
      repeat
           read(f,x);
           k:=k+1;            s:=s+x       until eof(f);       s:=s/k;      {новый просмотр f и подсчет элементов

Один комментарий

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

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