Типичные задачи и примеры. Теория.

[Stilet]

Число прописью

С\С++

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <locale.h>

 char	v[3][9][50]={
	  {"один", "два", "три", "четыре", "пять", "шесть", "семь", "восемь", "девять"}
	 ,{"десять", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят",
	    "семьдесят", "восемьдесят", "девяносто"}
	 ,{"сто", "двести", "триста", "четыреста", "пятьсот", "шестьсот", "семьсот",
	    "восемьсот", "девятьсот"}
	};
 char tsv[9][50] = {"тысяча", "тысячи", "тысячи", "тысячи", "тысяч", "тысяч",
    "тысяч", "тысяч", "тысяч"};
 char *nct="надцать";

char* TellMoney(double d){
 char ares[20][50]={0}; int iares=0;
 char *res=malloc(255); //Резервируем строку для прописи
 memset(res,0,255); 
 char s[13]={0}; //Резервируем строку для получения входящего числа
 //В виде строки с дробными для анализа копеек
 sprintf(s,"%10.2f",d);
 int k=trunc(d); //Получаем целую часть
 if(k>10 && k<20) { //Если она от 10 до 20 то вывод для нее в особых условиях
   if(k==14){ //Если четырнадцать то так и пишем - это хитрое число
    strcat(res,"четырнадцать");
   } else {
       //Иначе приписуем к ответу прописью от 1 до 9 и слово "надцать"
       //Из первого массива десятков
    strcat(res,v[0][k%10]);
    strcat(res,nct);
   }
 } else { // Иначе это число нужно продолжать раскладывать дальше
  int it=1,i=1,imln=1,imlrd=1,m;
  while(k){
    m=k%10;
    if(m){
        if(imlrd==10){
            i=1;
            strcat(ares[iares++],v[i-1][m-1]);
            if(m==1) strcat(ares[iares++],"миллиард"); else
            if(m>1 && m<5) strcat(ares[iares++],"миллиарда"); else
            if(m>4 && m<10) strcat(ares[iares++],"миллиардов");
        } else
        if(imln==7){
            i=1;
            strcat(ares[iares++],v[i-1][m-1]);
            if(m==1) strcat(ares[iares++],"миллион"); else
            if(m>1 && m<4) strcat(ares[iares++],"миллиона"); else
            if(m>3 && m<10) strcat(ares[iares++],"миллионов");
        } else
        if(it==4){
            i=1;
            if(m!=1) { strcat(ares[iares++],tsv[m]);
                       strcat(ares[iares++],v[i-1][m-1]);}
            else     strcat(ares[iares++],"одна тысяча");

        } else {
            strcat(ares[iares++],v[i-1][m-1]);
        }
    }
    k/=10;
    i++;it++;imln++;imlrd++;
  }
  for(iares--;iares;iares--){
    strcat(res,ares[iares]);
    strcat(res," ");
  }
  strcat(res,ares[0]);
 }
 return res;
}

int main()
{
    setlocale(LC_CTYPE, "rus");
    char *s=TellMoney(17843);
    printf("%s\n",s);
    free(s);
    getchar();
    return 0;
}

С#

Эспешал для Blondy

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Число_прописью
{
    class Program
    {
        
        static void Main(string[] args)
        {
            //Обьявляем массивы разрядов
            string[] a = new string[3];
            //Наполним значениями до десятка
            a[0] = "один два три четыре пять шесть семь восемь девять";
            //До соток
            a[1] = "десять двадцать тридцать сорок пятьдесят шестьдесят семьдесят восемьдесят девяносто";
            //До тысяч
            a[2] = "сто двести триста четыреста пятьсот шестьсот семьсот восемьсот девятьсот";
            //дальце фтопку. Лень короче
            // Это наше число, которое нужно прописью вывести
            int n = 125;
            // А это результирующая строка
            string s = "";
            // Если это число попадает в первый десяток то нужно просто 
            //к его имени присоединить окончание НАДЦАТЬ
            if (n > 10 && n < 20) { 
                // Делим строку, которая вмещает прописи значений до десятка
                //получаем массив (делим по пробелу - это официальный разделитель будет)
                //после вычисляем порядковый номер цифры - она будет указывать на ее имя в массиве
                //прописей, и допишем к ней окончание
               s = a[0].Split(' ')[n%10-1]+"надцать"; 
            }
            // Если же число больше то:
            else
            {
                //Придется в цикле его препарировать. Каждая препарация выдаст порядковый номер очередного
                //числа, которое является индексом, указывающим на элемент массива имен разрядов а[]
                for (int i = 0, k = 0; n > 0; n /= 10, i++)
                {
                    // получили число
                    k = n % 10;
                    //Если оно не 0 - т.е. это не десяток то возьмем очередной массив имен разрядов
                    //и получим его элемент, указываемый порядковым номером полученной нами цифры
                    //доплюсуем к строке не забыв пробел
                    if (k != 0) s = a[i].Split(' ')[k - 1] + ' ' + s;
                }
            }
            Console.Write(s);
            Console.ReadKey();
        }
    }
}

[Stilet]

Часто спрашивают "как сделать замену символа в строке на что-то"
Допустим не разрешено использовать string в программе (хотя и стоит). Тогда можно обратиться к первоистокам, и применить схему подобную этой:

// 65.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <stdlib.h>

// Функция проверки условия. Используется чтоб определить
// подходит ли символ для замены
bool condition(char c){
 // Например если символ латиницы
 //return c>='a' && c<='z' || c>='A' && c<='Z';
 // Или если нужно заменить все буквы о маленькие
   return c=='o';
}

// Функция замены
char *repl(char *s, char *forr){
	int c=0,l=0,p=0;
	// Выясняем сколько символов нужно заменять и сколько оставить как есть
	for(int i=0;s[i];i++) if(condition(s[i])) c++; else l++;
	// Выясняем длину подстроки, на которую будем менять символы
	for(;forr[p];p++);
	// Формируем новый массив. Новую строку. Старую переделать не получится, она может быть константной
	// как в этом примере
	// поэтому нужно формировать новую.
	// Размер его будет суммой количества символов
	// которые нужно оставить и количества символов, которые нужно заменить
	// умноженное на размер заменяемой подстроки
	char *a=new char[c*p+1+l];

	// Начинаем проход по исходной строке для замены
	for(int i=0,k=0;s[i];i++){
		// Если символ попадает под условие
		if(condition(s[i])){
			// в цикле вместо него впишем строку-замену
			for(int j=0;j<p;j++) a[k++]=forr[j];
			// Иначе просто подставим этот символ
		} else a[k++]=s[i];
	}
 // По хорошему окаймим новую строку нулем для сишных функций
 a[c*p+l]=0;
 // И вернем новую строку.
 return a;
}

int _tmain(int argc, _TCHAR* argv[])
{
 // Например заменим все символы о на тег <b>
 char *s2=repl("hello 1 world","<b>");
 // Посмотрим что получилось
 printf("%s",s2);
 // И уберем мусор
 delete s2;
getchar();
return 0;
}

Это Си++ Правда от плюсов тут только new и delete. которые успешно заменяются на

char *a=(char *)malloc(c*p+1+l);

и free() для уборки мусора, так что думаю как идея для начинания подойдет.

[Stilet]

Вращение массива.
По факту это перенос некой начальной части массива в хвост:

// Кольцевое вращение.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"

void rotor(int *a,int k,int len){
	// Создаем и инициализиуем временный массив
	int *m=new int[len]; for(int i=0;i<10;i++) m[i]=0;
	//Копируем в него заднюю часть вращаемого
	memcpy(m,&a[k],sizeof(int)*(len-k));
	//Потом переднюю часть
	memcpy(&m[len-k],&a[0],sizeof(int)*(k));
	//И возвращаем модифицированное назад
	memcpy(a,m,sizeof(int)*(len));
	// убирая мусор
	delete[] m;
}

int a[10];

int _tmain(int argc, _TCHAR* argv[])
{
	//Создаем массив
	for(int i=0;i<10;i++) a[i]=i;
	for(int i=0;i<10;i++) printf("%3d",a[i]);printf("\n");
	// Вращаем его сдвигая первые три элемента
	rotor(&a[0],3,10);
	//Выводим массив
	for(int i=0;i<10;i++) printf("%3d",a[i]);
	getchar();
	return 0;
}

И пример результата:

0 1 2 3 4 5 6 7 8 9
3 4 5 6 7 8 9 0 1 2

[Stilet]

Сумма ряда / разложить ряд

Поскольку неугомонные новички не пытаясь пройтись поиском часто задают один и тот же вопрос про ряды, опишу с комментариями функции разложения:
ioyopgyb28wc.jpg
Решение на Си

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
    //Опишем переменные
    double
     // Переменная Х
     x=0.5,
     //Переменная, содержащая предпоследний вычисленный У
     yLast=0.0,
     //Переменная очередного вычисленногоУ
     y=1.0,
     //Точность, до которой вычисляется ряд
     eps=0.0001;

    int
    //Переменная факториала
    fac=1,
    //Переменная знака
    sign=-1,
    //Переменная для цикла, чтоб показать кол-во итерраций
    i;
    //Начинаем цикл fabs - функция возвращающая число по модулю
    // В нашем случае У последняя минус У предидущая, берутся по модулю
    // для сравнения с точностью
    for(i=1;i==1 || fabs(y-yLast)>eps;i++){
        //Запоминаем предпоследний У
        yLast=y;
        //Вычисляем очередной факториал
        fac*=i;
        //Возводим Х в следующую степень
        x*=x;
        //Вычисляем У
        y+=sign*x/fac;
        //Этот оператор меняет знак перед следующим вычислением
        // Если по условию знак не меняется с - на + то этот оператор нужно убрать
        sign=-sign;
        // Выводим текущий элемент ряда
        printf("%d\t%5.10f\n",i,y);
    }
    //Выводим окончательный результат
    printf("Result = \t%5.10f\n",y);
    return 0;
}

Решение на Паскаль/Делфи-консоль

program project1;

//uses секцию не пишу, так как для этой задачи она не нужна 
var x,yLast,y,eps:double;
    fac,sign,i:integer;
begin
  x:=0.5; eps:=0.0001; y:=1;i:=1; sign:=-1; fac:=1;
  while (i=1)or(abs(y-yLast)>eps) do begin
    yLast:=y;
    fac:=fac*i;
    x:=x*x;
    y:=y+sign*x/fac;
    sign:=-sign;
    writeln('Step=',i:5,' x=',x:5:5,' y= ',y:10:10);
    inc(i);
  end;
  writeln('Result= ');
  writeln('Step=',i:5,' x=',x:5:5,' y= ',y:10:10);
  readln;
end.

Решение на C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Сумма_ряда
{
    class Program
    {
        static void Main(string[] args)
        {
            //Опишем переменные
            double
                // Переменная Х
             x = 0.5,
                //Переменная, содержащая предпоследний вычисленный У
             yLast = 0.0,
                //Переменная очередного вычисленногоУ
             y = 1.0,
                //Точность, до которой вычисляется ряд
             eps = 0.0001;

            int
                //Переменная факториала
            fac = 1,
                //Переменная знака
            sign = -1,
                //Переменная для цикла, чтоб показать кол-во итерраций
            i;
            //Начинаем цикл fabs - функция возвращающая число по модулю
            // В нашем случае У последняя минус У предидущая, берутся по модулю
            // для сравнения с точностью
            for (i = 1; i == 1 || Math.Abs(y - yLast) > eps; i++)
            {
                //Запоминаем предпоследний У
                yLast = y;
                //Вычисляем очередной факториал
                fac *= i;
                //Возводим Х в следующую степень
                x *= x;
                //Вычисляем У
                y += sign * x / fac;
                //Этот оператор меняет знак перед следующим вычислением
                // Если по условию знак не меняется с - на + то этот оператор нужно убрать
                sign = -sign;
                // Выводим текущий элемент ряда
                Console.WriteLine("{0}\t{1}", i, y);
            }
            //Выводим окончательный результат
            Console.WriteLine("Result = {0}", y); Console.ReadKey();
        }
    }
}

[Stilet]

Перевод из любой системы счисления в любую

С\С++

#include <iostream>

using namespace std;

//Функция возвращающая переведенное число
char* ConvertCC(char* x,int fromCC,int toCC){
    //Таблица символов исходного числа для
    //определения их порядкового номера
    char *abc="0123456789ABCDEFGHIJKLMNOPQESTUVWXYZ";
    //Промежуточная строка
    char buf[255]={0};
    //Результирующая строка
    char *result;

    int i //Это количество символов в начальном числе
       ,k //Это будет порядковым номером очередного символа в входном числе
       ,ten=0 //Это будет его аналог в 10-чной системе
       ,stp=1; //А это просто степень для перевода в 10-чную
    //Узнаем сколько символов во входящем числе
    for(i=0;x[i];i++);
    //А потом с последнего символа начинаем переводить
    for(;i;i--){
        //Выясняем его порядковый номер
        for(k=0;abc[k]!=x[i-1] && k<36;k++);
        //Умножаем его на степень, прибавляя к результирующему числу
        // в 10-тиричной системе
        ten+=k*stp;
        //И повышаем степень для следующего символа
        stp*=fromCC;
    }
    //После обратной формулой
    k=0;
    while(ten){
     //Получаем цифры числа в нужной системе
     i=ten % toCC;
     //И пишем их в буфер
     buf[k++]=abc[i];
     //Деля число на основание результирующей системы
     ten/=toCC;
    }
    //Поскольку число у нас в буффере верх ногами
    //Создаем результирующую переменку
    result=new char[k+1];
    //В которую пишем результат в его естесственном виде
    for(i=0;k;i++) result[i]=buf[--k];
    //Маркеруем конец строки нулем
    result[i]=0;
    //И возвращаем
    return result;

}

int main()
{
    char* s=ConvertCC("B12",20,16);
    cout<<s;
    delete s;
    cin.get();
    return 0;
}

Паскаль классический

program CC;

//Опишем функцию, получающую число, и две системы счисления

function ConvertCC(
         x:string;// Это само число в строковом виде
         fromCC, //Это система числа
         toCC:Integer //А это - куда нужно перевод сделать
):String;
//Тот же принцип - таблица символов для их порядковых номеров
const
  abc='0123456789ABCDEFGHIJKLMNOPQESTUVWXYZ';
var
 i,k,ten,stp:integer;
begin
 ten:=0; //Это будет его аналог в 10-чной системе
 stp:=1; //А это просто степень для перевода в 10-чную
 Result:=''; //Результат - системная строковая переменка

 //А потом с последнего символа начинаем переводить
 for i:=Length(x) downto 1 do begin
   //Выясняем его порядковый номер
   k:=Pos(x[i],abc)-1;
   //Умножаем его на степень, прибавляя к результирующему числу
   // в 10-тиричной системе
   ten:=ten+k*stp;
   //И повышаем степень для следующего символа
   stp:=stp*fromCC;
 end;

 //После обратной формулой
 while ten<>0 do begin
   //Получаем цифры числа в нужной системе
   i:=ten mod toCC;
   //И пишем их порядковые номера в результат
   Result:=abc[i+1]+Result;
   //Деля число на основание результирующей системы
   ten:=ten div toCC;
 end;
end;

begin
 write(ConvertCC('B12',20,16));
 readln;
end.

Бейсик (VBA) Автор IgorGO

' из 10-ричной системы в какую-то n-ричную
Function D2xz(d As Long, n As Long) As String
  Dim r As Integer, s As String
  r = Int(Log(d + 0.001) / Log(n))  'Для 64, 128 перевод в 2-ичную систему дало неожиданный результат: Log(128)/Log(2) = 7 - это
  'правильно, а Int(Log(128)/Log(2)) уже равно 6 и в старшем разряде получается "2"!!!, пришлось добавить нелогичный 0.001
  Do
    s = s & D2C(Int(d / n ^ r))
    d = d - Int(d / n ^ r) * n ^ r
    r = r - 1
  Loop Until r = -1
  D2xz = s
End Function


' и обратно в 20-чную систему из любой
Function xz2D(s As String, n As Long) As Long
  Dim r As Integer, d As Long
  For r = 0 To Len(s) - 1
    d = d + C2D(Mid(s, Len(s) - r, 1)) * n ^ r
  Next
  xz2D = d
End Function

Function D2C(i As Integer) As String
  D2C = Split("0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z", ",")(i)
End Function

Function C2D(c As String) As Long
  C2D = InStr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", c) - 1
End Function

[Stilet]

Вычислить сколько разных букв в строке и их количество

Паскаль

program Project1;
var
  //Вводимая строка
  s:string;
  //Массив, хранящий количество символа в строке
  Chars:Array['а'..'я'] of integer;
  // Просто счетчик для цикла прохода по строке
  i:integer;
  // Счетчик для цикла прохода по массиву
  c:char;
  //Количество согласных и "несогласных" символов :)
     Ons //Тут будут гласные
    ,Kuns //Тут Согласные
       :Integer;
begin
  // Вводим строку
  //write('Введите строку: ');readln(s);
  s:='привет мир';
  //Проходим по ней
  for i:=1 to Length(s) do
   //Если символ в русском алфавите
   if s[i] in ['а'..'я'] then
    //Увеличиваем в массиве значение в ячейке, соответствующей этому символу
    inc(Chars[s[i]]);

  writeln('Количество букв:');
  //После проходим и делаем вывод найденных символов и их количество в строке
  for c:='а' to 'я' do begin
   if Chars[c]>0 then begin
    writeln(c,' встречается ',Chars[c],' раз');
      //Можно вычислить сколько РАЗНЫХ гласных  прямо в этом же условии
       if (c in ['у','е','ы','а','о','я','и','ю']) then
        inc(Ons)
       //И сколько РАЗНЫХ согласных
       else inc(Kuns);
   end;
  end;
  writeln('Количество Гласных букв: ',Ons);
  writeln('Количество Согласных букв: ', Kuns);

  readln;
end.

C Классический

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
int main()
{
    //Чтоб в Виндовсе все выводилось по русски
    SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	//Опишем переменную для строки
    char
         *s="привет мир"
         //И переменную - список гласных
        ,*Onses="уеыаояию";
    ;
    //А так же массив количеств букв
    int Chars[33]={0};
    //Вместе с переменными кол-ва гласных и согласных
    int Ons=0,Kuns=0;
    //И счетчик для цикла
    int i;
    //Наполним массив количеств значениями - сколько встречается какая буква
    for(i=0;i<strlen(s);i++){
         Chars[s[i]-'а']++;
    }
    //После пройдемся по нему и проверим какая из букв встретилась
    //Хотя бы один раз
    for(i=0;i<33;i++){
        if(Chars[i]>0) {
         //Выведем эту букву и ее количество   
         printf("Количество буквы '%c' = %d\n",i+'а',Chars[i]);
         //Тут же выясним гласная это или нет, и приплюсуем
         //К переменным, считающим количество гласных
         //Тут используется функция поиска символа в списке *Onses="уеыаояию"
         //Этот список специально заведен для поиска согласных
         //Если нужно искать еще какие-то символы - просто добавить их в список:
         // *Onses="уеыаояию-+=" - Будет искать и арифметические символы
         //И считать их за гласные
         if(strchr(Onses,i+'а')) Ons++;
         //Или согласных
         else Kuns++;
        }
    }
    //После выведем количества
    printf("Гласных = %d\nСогласных = %d",Ons,Kuns);
    getchar();
    return 0;
}

C#

using System;
using System.Linq;

namespace ваы
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			// наша строка
			string s = "привет мир";
			//Вычисляем сколько раз какая буква в ней появляется
			foreach (var c in s.Where(v=>v>='а'&&v<='я').GroupBy(v=>v))
				Console.WriteLine ("Буква {0} появляется {1} раз", c.Key,c.Count());
			Console.WriteLine ();

			//Если нужно вычислить только гласные то можно писать так:
			foreach (var c in s.Where(v=>"уеыаояию".IndexOf(v)>-1).GroupBy(v=>v))
				Console.WriteLine ("Гласная {0} появляется {1} раз", c.Key,c.Count());
			Console.WriteLine ();

			//Просто кол-во гласных и согласных можно посчитать так:
			Console.WriteLine ("Гласных {0} \nСогласных {1}", 
				s.Count(v=>"уеыаояию".IndexOf(v)>-1),
				//s.Where(v=>"уеыаояию".IndexOf(v)>-1).Count(),
				s.Count(v=>v>='а'&&v<='я')

			);
			Console.WriteLine ();

			Console.ReadKey();
		}
	}
}

[Stilet]

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

Классический паскaль\Делфи

program Project1;

{
 Описываем функцию проверки числа на простоту
 Х - то самое число которое нужно проверить
 Функция возвращает True если число Х простое
 или False если не совсем.
}
function isPrime(X: LongInt): boolean;
// Для этого нам понадобится переменная, участвующая в цикле
// Цикл будет крутиться пока она не достигнет значения квадратного корня X, т.е. квадрата
var i : integer;
Begin
     // Изначально будет считаться что число не простое, поэтому в особую переменную
     // Имеющую имя функции, которая и будет результатом положим False
     isPrime:=false;
     // Если х меньше 2 то число не простое. И можно из цункции выходить
     if x<2 then Exit;
     //Иначе проверим, не делится ли оно на 2
     if not odd(x) and (x<>2) { проверяем на чётность  }
          then exit; // Если делится то оно тоже не простое. Можем выходить из функции
     //Иначе начнем цикл с числа 3 до квадратного корня нашего Х
     i:=3;
     while i <= sqrt(x) do { проверяем только нечётные }
     begin
       //Если выяснится что наш Х делется нацело на i - значит он не простой
       //И можно дальше цикл не продолжать
          if x mod i = 0 then Exit;
       //Если же нет - значит цикл перескочит на следующее проверяемое НЕЧЕТНОЕ число
          inc(i,2);
     end;
     //Если в цикле не были обнаружены числа меньше чем Х-квадрат, с котороыми
     //наш Х нацело не делится - значит он действительно простое число.
     //Вернем True в подтверждение этого
     isPrime:=true;
End;

var i:integer;
begin
  // И простой цикл показывающий как это все работает
  for i:=0 to 20 do begin
    write(i:5,' is ');
    //Если число i простое так и напишем по аглицик. Иначе напишем другую фразу
    if isPrime(i) then writeln(' simple ') else writeln(' not simple ');
  end;
  readln;
end.

Классический С\С++

#include <stdio.h>
#include <stdlib.h>
// Этот хедер необходим для типа bool
//которого, если говорить проще, в классическом Си нет
#include <stdbool.h>
//И модуль для функции квадратного корня
#include <math.h>

//Такая же функция, принимающая целое число
int IsSimple(int x){
 //Если это число меньше 2 или оно четное, но не равно двум
 //Значит оно не простое
 if(x<2 || (!(x%2) && x!=2)) return false;
 int i;//Иначе придется крутить цикл для проверки
 //Прирост цикла - 2, чтоб скакать только по нечетным
 for(i=3;i<=sqrt(x);i+=2)
  //Если очередное нечетное при делении на Х дает в остатке 0
  //Значит Х - сложное число
  if(x%i == 0) return false;
 //Иначе цикл не нашел сложных - значит это число простое
 return true;
}

int main()
{
    //И пример использования
    // В С++ можно вместо printf использовать cout
    int i;
    for(i=0;i<20;i++){
     printf("%d is ",i);
     if(IsSimple(i)) printf(" simple\n");
     else printf(" not simple\n");
    }
    getchar();
    return 0;
}

C#

Тут те же яйца что и в Си только в профиль. Я даже не стал утруждаться выдумкой чего-то шарпейного, просто тупо скопипастил код из Си

using System;

namespace Application
{
	class MainClass
	{
		public static bool IsSimple(int x){
			//Если это число меньше 2 или оно четное, но не равно двум
			//Значит оно не простое
			if(x<2 || ((x%2 == 0) && x!=2)) return false;
			int i;//Иначе придется крутить цикл для проверки
			//Прирост цикла - 2, чтоб скакать только по нечетным
			for(i=3;i<=Math.Sqrt(x);i+=2)
				//Если очередное нечетное при делении на Х дает в остатке 0
				//Значит Х - сложное число
				if(x%i == 0) return false;
			//Иначе цикл не нашел сложных - значит это число простое
			return true;
		}
		public static void Main (string[] args)
		{
			int i;
			for(i=0;i<20;i++){
				Console.Write ("{0} is ",i);
				if(IsSimple(i)) Console.WriteLine (" simple");
				else Console.WriteLine (" not simple");
			}
			Console.ReadKey ();
		}
	}
}

Дамы и господа, проверяйте. Надеюсь нигде не ошибся.

[Stilet]

Фибоначчи

Паскаль/Делфи-консоль

program project1;

var n:integer;z,k:integer;

procedure FibList(n:integer);
begin
  z:=1;k:=0;
  while n>0 do begin //В цикле получаем n чисел Фибоначчи
   z:=z+k; //По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
   k:=z-k; //Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
   write(z,' ');  //И выводим сие число
   dec(n); //Переходя на следующую итерацию цикла
  end; writeln;
end;

procedure FibFindClose(n:integer);
begin
  z:=1;k:=0;
  while z<=n do begin //В цикле получаем числа Фибоначчи пока очередное число меньше заданного
   z:=z+k; //По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
   k:=z-k; //Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
  end;
  writeln(z); //Выводим найденное число
end;


begin
FibList(20); //Ряд Фибоначчи
FibFindClose(88); //Найти ближайшее число справа к указанному в ряду
readln;
end.

С/С++

#include <stdio.h>
#include <stdlib.h>

int z,k;

void FibList(int n){
 z=1;k=0;
 for(;n>0;n--){ //В цикле получаем n чисел Фибоначчи
     z+=k;//По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
     k=z-k;//Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
     printf("%d\t",z); //И выводим сие число
     //Если С++ то писать cout<<z<<'\t';
 } printf("\n");//Если С++ то писать cout<<endl;
}

void FibFindClose(int n){
 z=1;k=0;
 for(;z<=n;){ //В цикле получаем числа Фибоначчи пока очередное число меньше заданного
     z+=k;//По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
     k=z-k;//Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
 } printf("%d\t",z);//Если С++ то писать cout<<endl;
}


int main()
{
    FibList(10);//Ряд Фибоначчи
    FibFindClose(12); //Найти ближайшее число справа к указанному в ряду
    getchar(); //Если С++ то писать cin.get();
    return 0;
}

С#

using System;

namespace fib
{
	class MainClass
	{
		static int z,k;
		public static void FibList(int n){
			z=1;k=0;
			for(;n>0;n--){ //В цикле получаем n чисел Фибоначчи
				z+=k;//По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
				k=z-k;//Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
				Console.WriteLine ("{0}",z); //И выводим сие число
			} Console.WriteLine();
		}

		public static void FibFindClose(int n){
			z=1;k=0;
			for(;z<=n;){ //В цикле получаем n чисел Фибоначчи
				z+=k;//По уравнению где в которой каждое последующее число равно сумме двух предыдущих чисел
				k=z-k;//Вычисляем сумму двух предидущих, просто отнимая их от общей суммы
			} Console.WriteLine ("{0}",z);
		}

		public static void Main (string[] args)
		{
			FibList (10);//Ряд Фибоначчи
			FibFindClose (10);//Найти ближайшее число справа к указанному в ряду
			Console.ReadKey ();
		}
	}
}

[Аватар]

Сумма ряда
Решение с использованием рекуррентного соотношения между членами ряда

Безымянный.JPG

Решение на Паскаль/Делфи-консоль

program project1;

var x,eps,a,y: double;
    i:integer;
begin
  x:=0.5; eps:=0.0001; a:=1; y:=a; i:=1;
  repeat
    a:=-a*x/i;
    y:=y+a;
    Inc(i);
  until Abs(a)<eps;
  writeln('Result=',y:10:10);
  readln;
end.

[Stilet]

Передача данных (экспорт) из базы данных (DBGrid) в MS Word и MS Excell
Delphi

Частенько вижу вопросы о том, как наполнять Экзель или Ворд из DBGrid или Table или Query или в принципе из Базы Данных. Привожу простой пример наполнения из DBGrid

Пример делю на три поста:

1. Описание формы
2. Методы работы с Экзелем
3. Методы работы с Вордом

Описание формы

unit Unit1;

interface

uses    comobj,//Этот модуль обязателен для работы с MS Office
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Data.DB, Data.Win.ADODB,
  Vcl.Grids, Vcl.DBGrids;

type
  TForm1 = class(TForm)
    DBGrid1: TDBGrid;                     //Наш Грид, откуда будем переносить данные
    ADOQuery1: TADOQuery;           //Его набор данных, с которым он связан
    DataSource1: TDataSource;
    ButtonExcell: TButton;              //Кнопка работа с Экзелем
    ButtonMSWord: TButton;           //Кнопка работы с Вордом
    procedure ButtonExcellClick(Sender: TObject);
    procedure ButtonMSWordClick(Sender: TObject);
//Переменные для Ворда и Экзеля
  private  MSWord,WordDoc,WordTable,Excell,Book,Sheet:OleVariant;
    Error:String;
    { Private declarations }
    Function OpenExcell:Boolean;          //Открытие Экзеля
    Function OpenBook:Boolean;           //Открытие в Экзеле книги
    Function OpenSheet:Boolean;         //Получение в книге листа
    Procedure FillExcell;                      //Наполнение листа книги

    Function OpenWord:Boolean;           //Открытие Ворда
    Function OpenWordDoc:Boolean;      //Создание документа
    Function CreateWordTable:Boolean;  //Создание таблицы
    Procedure FillWord;                       //Наполнение таблицы
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}