являеца ли число простым?

C помощью рекурсии определить являеца ли число простым?

#include <iostream>

using namespace std;

bool is_simple_inner(int n, int d)
{
 if (d == 1) return true;
 if (n % d == 0) return false;

 return is_simple_inner(n, d-1);
}

bool is_simple(int n)
{
 if (n == 1)
  return true;

 return is_simple_inner(n, n-1);
}

int main()
{
 int n;
 cout << "input n: ";
 cin >> n;

 cout << "is simple? " << (is_simple(n) ? "yes" : "no") << endl;

 return 0;
}

тут можно скачать исходики

найти номера строк, элементы в каждой из которых одинаковы между собой

дан двумерный квадратный массив. найти номера строк, элементы в каждой из которых одинаковы между собой.

основная заковырка тут в том что такие

1 2 3

3 1 2

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

1 1 2

2 1 1

это тоже одинаковые строки...

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

смотрим и разбираемся....

const
   N = 4;

var
   a: array [1..N, 1..N] of integer;
   b: array [1..N] of boolean; {вспомогательный массив флагов}
   i, j, k, m: integer;
   f1, f2: boolean;

begin
   {инициализация массива случайными числами}
   for i:=1 to N do begin
      for j:=1 to N do begin
         a[i,j]:=random(3);
      end;
   end;
   
   {печать массива на экран}
   for i:=1 to N do begin
      for j:=1 to N do begin
         write(a[i, j]:2);
      end;
      writeln;
   end;
   writeln;
   
   {ищем совпадения по строчно}
   for i:=1 to N do begin
      write('строка ', i, ': ');

      for j:=1 to N do begin
         {саму с собой не проверяем}
         if i = j then continue;
         
         {сбросим вспомогательный массив флагов}
         for k:=1 to N do begin
            b[k]:=false;
         end;

         f1:=true; {предположим i-я строка равна j-й}
         for k:=1 to N do begin
            f2:=false; {предположим k-й элемент i-той строки есть в j-й строке }
            for m:=1 to N do begin
               if (a[i, k] = a[j, m]) and (b[m] = false) then begin
                  b[m]:=true; {таки есть, отметим это флагом}
                  f2:=true; {и переходим к след. символу}
                  break;
               end;
            end;
            
            if not f2 then begin {символ не найден!}
               f1:=false; {строки не равны!}
               break;
            end;
         end;

         if f1 = true then begin {строки равны}
            write(j:2); {отметим этот факт выводом на экран}
         end;
      end;
      writeln;
   end;
   writeln;
end.

исходники скачиваем тут

найти для каждой строки число элементов,кратных 5

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

const
   N = 10;
   M = 20;

var
   a: array [1..N, 1..M] of integer;
   b: array [1..N] of integer;
   
   i: integer;
   j: integer;
   sum: integer;
   max: integer;

begin
   {инициализируем массив случайными числами}
   for i:=1 to N do begin
      for j:=1 to M do begin
         a[i, j]:=random(100);
      end;
   end;
   
   {выведем его на экран}
   for i:=1 to N do begin
      for j:=1 to M do begin
         write(a[i, j]:3);
      end;
      writeln;
   end;
   writeln;
   
   sum:=0; {начальная инициализация суммы}
   write('кол-во элементов кратных пяти: ');
   for i:=1 to N do begin
      {находим кол-во элементов кратных 5}
      b[i]:=0;
      for j:=1 to M do begin
         if a[i, j] mod 5 = 0 then begin
             b[i]:=b[i]+1;
         end;
      end;
      write(b[i]:3); {вывод на экран}
   end;
   writeln;
   
   max:=b[1];
   for i:=2 to N do begin
      if b[i] > max then begin
         max:=b[i];
      end;
   end;
   
   writeln('максимальное из них = ', max);
end.

тут можно скачать оригинал

найдите сумму наибольших значений элементов

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

const
   N = 10;
   M = 20;

var
   a: array [1..N, 1..M] of integer;
   i: integer;
   j: integer;
   sum: integer;
   max: integer;
begin
   {инициализируем массив случайными числами}
   for i:=1 to N do begin
      for j:=1 to M do begin
         a[i, j]:=random(100);
      end;
   end;
   
   {выведем его на экран}
   for i:=1 to N do begin
      for j:=1 to M do begin
         write(a[i, j]:3);
      end;
      writeln;
   end;
   writeln;
   
   sum:=0; {начальная инициализация суммы}
   write('max: ');
   for i:=1 to N do begin
      {находим максимальное значение в строке}
      max:=a[i, 1];
      for j:=2 to M do begin
         if a[i, j] > max then begin
            max:=a[i, j];
         end;
      end;
      write(max:3); {вывод на экран}
      sum:=sum+max; {накапливаем сумму}
   end;
   writeln;
   
   writeln('сумма максимальных элементов строк = ', sum);
end.

тут можно скачать отформатированную версию исходников

задача 13

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

последовательность A из N элементов это

const
    N = 50;

var
    A: array [1..N] of integer;

отмечу лишь некоторые ключевые моменты, как-то замена рядомстоящих нулей на один

   m:=1; {новый размер массива}
   f:=false; {признак повторяющихся нулей}
   for i:=1 to N do begin
      if A[i] = 0 then begin {если это ноль}
         if f then begin {и до этого был ноль}
            {ничего не делаем - идём дальше}
         end else begin {до этого был НЕ ноль}
            f:=true; {выставляем признак начала нулей}
            A[m]:=A[i]; {один из них оставляем}
            m:=m+1;
         end;
      end else begin {это НЕ ноль}
         f:=false; {сбрасываем признак нуля}
         A[m]:=A[i]; {заполняем массив}
         m:=m+1;
      end;
   end;

переворот значений в массиве (эта часть программы почти никогда не будет выполняться, но алгоритм интересный)

      for i:=1 to m do begin
         temp:=A[1];
         for j:=1 to m-i do begin
            A[j]:=A[j+1];
         end;
         A[m-i+1]:=temp;
      end;

полный вариант программы тут

основные операции с файлами

Составить программу для обработки текстового файла:
1)считывание текста из текстового файла,
2)добавление в него текста,
3)переименование файла,
4) копирование файла,
5) удаление файла


вот тело программы

   {прочитаем построчно}
   assign(f, 'file');  { associate it }
   reset(f);         { open it      }
   while not eof(f) do  { read it until it's done }
   begin
     readln(f, s);
     writeln(s);
   end;
   close(f);
   
   {допишем}
   append(f);
   writeln(f, 'new stroka');
   close(f);
   
   {переименуем}
   rename(f, 'new_file');
   
   {удалим}
   erase(f);

тут можно скачать полную версию

поиска двух строк с минимальным/максимальным значением среднего арифметического

Дана числовая таблица С размером N*N. Составить программу поиска двух строк по следующему алгоритму : одной - с минимальным значением среднего арифметического (SR), другой - с максимальным значением SR. Если номер строки с минимальным значением SR больше номера строки с максимальным SR, то обе строки удалить . В противном случае - элементы найденных строк поменять местами. Преобразованную таблицу выдать на экран построчно.


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

int get_sr(int j)
{
 int sr = 0;
 for (int i = 0; i < N; i++)
 {
  sr += C[j][i];
 }

 return sr / N; 
}

найдём заданные минимум и максимумы

 int max_sr;
 int nomer_max_sr;

 int min_sr;
 int nomer_min_sr;
 
 nomer_max_sr = nomer_min_sr = 0;
 max_sr = min_sr = get_sr(0);

 for (int j=1; j < N; j++)
 {
  int sr = get_sr(j);

  if (sr < min_sr)
  {
   min_sr = sr;
   nomer_min_sr = j;
   continue;
  }

  if (sr > max_sr)
  {
   max_sr = sr;
   nomer_max_sr = j;
   continue;
  }
 }

а так меняем местами значения строк

  for (int i=0; i < N; i++)
  {
   int temp = C[nomer_min_sr][i];
   C[nomer_min_sr][i] = C[nomer_max_sr][i];
   C[nomer_max_sr][i] = temp;   
  }

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