Форум программистов, компьютерный форум CyberForum.ru

Коллекция алгоритмов от Johna Smith - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Работа с графом (Требуется по заявке клиента предложить способы обмена жилплощади) http://www.cyberforum.ru/cpp-beginners/thread870941.html
В файле записаны предложения по обмену жилплощадью. Имеются варианты размена одной квартиры на две других либо на квартиру и комнату. Требуется по заявке клиента предложить способы обмена. Предусмотреть возможность нахождения обменов, в которых участвуют более двух сторон.
C++ Определить, является ли текст десятичной записью числа, кратного 9 Является ли текст записью десятичного числа,кратного 9 В заданный непустой текст входят только цифры и буквы. Определить. удовлетворяет ли он следующему свойству: 1) текст является десятичной записью числа, кратного 9; http://www.cyberforum.ru/cpp-beginners/thread870934.html
Удаление первых n элементов из vector C++
Почему, к примеру, если k=3 а pop=2, то студия выдаст ошибку(итератор вне допустимого диапазона) при запуске функции erase. По моей логике, необходимо было удалить первый элемент. #include <cstdio> #include <iostream> #include <vector> #define pb push_back #define ull unsigned long long using namespace std; vector<int> t;
Найти сумму квадратов элементов матрицы C++
Помогите пожалуйста!)
C++ Получить целочисленную матрицу http://www.cyberforum.ru/cpp-beginners/thread870928.html
Задание ниже: Nastik23, оформите тему в соответствии с правилами форума: текстовые задания набирайте от руки
C++ Считывание структур из файла #include <stdio.h> #include <string.h> #include <malloc.h> #define Lmax 20 struct student { struct { char name,surname,patronymic; } fio; подробнее

Показать сообщение отдельно
LK
Заблокирован
19.05.2013, 16:26  [ТС]     Коллекция алгоритмов от Johna Smith
Разное

Число размещений из M по N
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//////////////////////////////////////////////////////////////////////////////
//
//  Calculating number of possible allocations
//  (c) Johna Smith, 1996
//
//  Method description:
//   Number of possible allocations from n elements by m-element groups is
//   equal to   m     n!
//             A  = ------
//              n   (n-m)!
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
double factorial (int n)
{
  double factorial=1;
  for (int i=2;i<=n;i++)
  {
    factorial=factorial*i;
  }
  return factorial;
}
double Anm(int n, int m)
{
  return (factorial(n)/factorial(n-m));
}
void main(void)
{
  printf("Number of allocations from 10 elements by 5 is Anm = %f\n",Anm(10,5));
}

Число сочетаний из N по M
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//////////////////////////////////////////////////////////////////////////////
//
//  Calculating number of possible combinations
//  (c) Johna Smith, 1996
//
//  Method description:
//    Number of possible combinations of n elements to m-element groups is
//   equal to   m      n!
//             C  = --------
//              n   m!(n-m)!
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
double factorial (int n)
{
  double factorial=1;
  for (int i=2;i<=n;i++)
  {
    factorial=factorial*i;
  }
  return factorial;
}
double Cnm(int n, int m)
{
  return (factorial(n)/(factorial(m)*factorial(n-m)));
}
void main(void)
{
  printf("Number of combination from 10 elements by 5 is Cnm = %f\n",Cnm(10,5));
}

Найти дробную часть Х
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//////////////////////////////////////////////////////////////////////////////
//
//  Calculating {x}, where {x} is the fractional part of x
//  (c) Johna Smith, 1996
//
//  Method description:
//   Calculate integer part of x ([x]):
//    1) Assume that integer part c is 0
//    2) If the given value x is positive then increase c while it is less than x
//       if the given value x is negative then decrease c while it is greater than x
//   Calculate the fractional part of x:
//    3) {x}=x-[x]
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
float Frac(float x)
{
  int c=0;
  // calculating integer part of x, [x]=c
  if (x>=0)
    while (x>=c+1) c++;
  else
    while (x<c-1) c--;
  // {x}=x-[x]
  return x-c;
}
void main(void)
{
  printf("Pi=%f {Pi}=%f\n",3.1415926536,Frac(3.1415926536));
  printf("{%f}=%f",-1.234567,Frac(-1.234567));
}

Округлить Х к ближайшему целому, меньшему, чем Х
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//////////////////////////////////////////////////////////////////////////////
//
//  Calculating [x], where [x] is the nearest to x integer that is less than x
//  [3.1415]=3 and [-3.1415]=-4 (not -3, because -3 is greater than -3.1415
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) Assume that integer part c is 0
//    2) If the given value x is positive then increase c while it is less than x
//       if the given value x is negative then decrease c while it is greater than x
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
int Integer(float x)
{
  int c=0;
  if (x>=0)
    while (x>=c+1) c++;
  else
    while (x<c) c--;
    
  return c;
}
void main(void)
{
  printf("Pi=3.1415926536 [Pi]=%d\n",Integer(3.1415926536));
  printf("[-1234.5678]=%d",Integer(-1234.5678));
}

Факториал (решение "в лоб")
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//////////////////////////////////////////////////////////////////////////////
//
//  Factorial calculation (exact solution)
//  (c) Johna Smith, 1996
//
//  Method description:
//   We just use definition of factorial n!=1*2*3*...*n
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
double factorial (int n)
{
  double factorial=1;
  for (int i=2;i<=n;i++)
  {
    factorial=factorial*i;
  }
  return factorial;
}
void main(void)
{
  printf("5! = %f\n35! = %f\n100! = %f\n",factorial(5),
                              factorial(35),factorial(100));
}

Факториал (через логарифм)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//////////////////////////////////////////////////////////////////////////////
//
//  Factorial calculation (logarithm solution)
//  (c) Johna Smith, 1996
//
//  Method description:
//   We just use logarithmic method:
//            sum(k=1;n) lg(k)
//     n! = 10
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
long double factorial (int n)
{
  long double factorial;
  double sum=0;
  for (int i=1;i<=n;i++) sum+=(log(i)/log(10));
  factorial=powl(10,sum);
  return factorial;
}
void main(void)
{
  printf("5! = %Lf\n35! = %Lf\n100! = %Lf\n",factorial(5),
                                factorial(35),factorial(100));
}

Квадратный корень (метод Ньютона)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//////////////////////////////////////////////////////////////////////////////
//
//  Square root calculating. Newton method
//  (c) Johna Smith, 1996
//
//  Method description:
//    0) Given: A      Find: A^(1/2)
//    1) Find out first approximation x0 of the sqare root of A
//    2) x(n+1)=(x(n)+A/x(n))/2 while x(n+1)-x(n)<=1
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
// recieving value of A and first approximation of the sqare root
float NewtonSqrt(float A, float x)
{
  float xold;
  do
  {
    xold=x;
    x=(x+A/x)/2.0;
  } while (x!=xold);
  return x;
}
void main(void)
{
  printf("C++ Sqrt(13)=%f,  Newton Sqrt(13)=%f.",sqrt(13),NewtonSqrt(13,3.5));
}

Наибольший общий делитель (алгоритм Евклида)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//////////////////////////////////////////////////////////////////////////////
//
//  Calculating NOD using Evklid algorithm
//  (c) Johna Smith, 1996
//
//  Method description:
//    NOD(a,b) is greatest integer number with the following property:
//     a/NOD=m, b/NOD=n, where m,n - are integer
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
int NOD(int a,int b)
{
  int tmp;
  // on each step we make following modifications
  // a   -> b
  // b%a -> a, where b%a is remainder of b/a
  while (a!=0)
  {
    tmp=a;
    a=b%a;
    b=tmp;
  }
  return b;
}
void main(void)
{
  printf("NOD(1532,24) = %d\n",NOD(1532,24));
}

Нахождение простых чисел
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//////////////////////////////////////////////////////////////////////////////
//
//  Finding prime numbers
//  (c) Johna Smith, 1996
//
//  Method description:
//   We take a number and try to divide it. If we can divide it
//   without remainder - this is not prime number.
//   We can take into account only odd numbers, because we can
//   divide all even number by 2. Also we can store all prime
//   numbers that are already found in an array and try to divide
//   all new numbers only by numbers from this array.
//   If we want to find all prime numbers less than N the size of
//   the array should be sqrt(N)/2
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#define N   160  // so we can find all prime numbers that are less than 100000
#define M   25   // check all numbers less than 250
int Simple[N];
int k=0;
enum {yes,no} simple;
void main(void)
{
  // it's easy: 2 and 3 are prime
  if (M>=2) printf("2\n"); // 2 is simple 'cause we can divide it only by itself and 1
  Simple[k++]=2;
  if (M>=3) printf("3\n");
  Simple[k++]=3;
  // but what we can say about other numbers:
  for(int i=5;i<=M;i+=2)
  {
    simple=yes;
    for(int j=0;j<k;j++)
    {
      if (Simple[j]*Simple[j]>i) break; // other Simple[j] is too big for i
      if ((i%Simple[j])==0) simple=no; // there's no remainder - not prime
    }
    if (simple==yes)
    {
      printf("%d\n",i);
      Simple[k++]=i;
    }
  }
}

Нахождение простых сомножителей числа
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//////////////////////////////////////////////////////////////////////////////
//
//  Searching prime multipliers
//  (c) Johna Smith, 1996
//
//  Method description:
//    Given: number A
//    We should find a1,a2,a3,..an with the following properties:
//    1) ai is prime numbers
//    2) a1*a2*...*an=A
//
//    We can do it by consequitive dividing A by 2 and all prime numbers
//    while sqrt(A)+1<=d, where d is prime number
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
unsigned long int A=1234567890L;
void main(void)
{
  unsigned long int b;
  while (A%2==0 && A!=1)
  {
    // divide by 2 while it is possible
    printf("2 ");
    A/=2;
  }
  b=3;
  while (b<sqrt(A)+1)
  {
    if (A%b==0)
    {
      // dividing by prime number
      printf("%ld ",b);
      A/=b;
    } else b+=2;
  }
  printf("%ld\n",A);
}

Быстрое возведение в степень x^y
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//////////////////////////////////////////////////////////////////////////////
//
//  Quick powering
//  (c) Johna Smith, 1996
//
//  Method description:
//    Calculate A to the power of k, A is real, k is natural, k>0
//    If k is even we can use the following formula:
//                              k/2
//                   k   (   2 )
//              b = A  = ( A   )
//    and assume k=k/2; A=A*A;
//    If k is odd we assume k=k-1, b=b*A and k becomes even
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
void main(void)
{
  long double A = 8.0;
  long int    k = 19;
  long double b=1;
  printf("%Lf^%ld = ",A,k);
  while (k!=0)
  {
    if (k%2!=0) b*=A;
    k/=2;
    A*=A;
  }
  printf("%Lf\n",b);
}

Быстрое вычисление корня n-й степени x^(1/y)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//////////////////////////////////////////////////////////////////////////////
//
//  Quick powering
//  (c) Johna Smith, 1996
//
//  Method description:
//    Calculate A to the power of 1/k, A is real, k is natural, k>0
//    We can use iterations:
//               k-1
//    x    = (a/x   +(k-1)x  )/k
//     n+1       n         n
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
long double Root(long double a, long int k)
{
  long double xn=(a+k-1)/k; // first iteration
  long double x,xk;
  do
  {
    x=xn;
    xk=1; // x^(k-1)
    for (long int i=0;i<k-1;i++) xk*=x;
    xn=(a/xk+(k-1)*x)/k;
  } while (x!=xn); // while there's difference between two consequitive iterations
  return x;
}
void main(void)
{
  long double A=1048576L;
  long int k=20;
  printf("%Lf to the power of %Lf is %Lf",A,(long double)(1.0/k),Root(A,k));
}

Генерация случайных чисел с нормальным распределением
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//////////////////////////////////////////////////////////////////////////////
//
//  Generating random numbers with normal distribution
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) Select the base for randomizer
//    2) Generate two random numbers from 0 to 1
//    3) Calculate two randoms with normal distribution, return one of them
//       and remember other to return next time without generating new randoms
//  This method gives us random numbers with dispersion=1 and average=0  
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
#define Pi  3.14159265358979323846
float nrnd(float _base=0)
{
  static float base;
  static float tact=1;
  static float second_value;
  float factor,argument,tmp;
  // reinitializing randomizer if _base!=0
  if (_base!=0) base=_base;
  if (tact==1)
  {
    tact=2;
    // generating random from 0 to 1
    tmp=11*base+Pi;
    base=tmp-(int)tmp;
    // calculating factor
    factor=sqrt(-2.0*log(base));
    // generating random from 0 to 1
    tmp=11*base+Pi;
    base=tmp-(int)tmp;
    // calculating argumeent
    argument=2.0*Pi*base;
    // generating final random numbers with normal distribution
    second_value=factor*sin(argument);
    return factor*cos(argument);
  }
  else
  {
    tact=1;
    return second_value;
  }
}
void main(void)
{
  // Setting the base for randiomizer (not 0)
  nrnd(987.654321);
  // Generating random numbers
  for (int i=0;i<10;i++) printf("%d. %f\n",i+1,nrnd());
}

Генерация случайных чисел в интервале 0...1
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//////////////////////////////////////////////////////////////////////////////
//
//  Generating random number between 0 and 1
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) Select the base for randomizer
//    2) Get random number using the following formula: x=fract(11*x+Pi)
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#define Pi  3.14159265358979323846
float rnd(float _base=0)
{
  static float base;
  float tmp;
  // reinitializing randomizer if _base!=0
  if (_base!=0) base=_base;
  // generating random number
  tmp=11*base+Pi;
  base=tmp-(int)tmp;
  return base;
}
void main(void)
{
  // Setting the base for randiomizer (not 0)
  rnd(123.456789);
  // Generating random numbers
  for (int i=0;i<10;i++) printf("%d. %f\n",i+1,rnd());
}

Собственые числа и собственные вектора матрицы
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//////////////////////////////////////////////////////////////////////////////
//
//  Searching own number and own vector for matrix A
//  (c) Johna Smith, 1996
//
//  Method description:
//    Given: matrix A
//    We need to find max lambda and vector X: A*X=lambda*X
//    In this algorythm we'll use iterations to find vector X.
//                         n
//    On each step lambda=SUM (A*x(i),x(i)), where (..) means scalar multiplication
//                        i=1
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
#define N   3   // size of matrix
float matrix[N][N]={
   {10,5,6},
   {5,20,4},
   {6,4,30}
  };
float x_current[N]={1,1}; // first iteration
const unsigned m=300;     // number of iterations
void ShowMatrix(void)
{
  for (int i=0;i<N;i++)
  {
    for (int j=0;j<N;j++)
      printf("%+f*x%d",matrix[i][j],i+1);
    printf("\n");
  }
}
void main(void)
{
  // Variables declaration
  int i,j,k;
  float A_x_current[N],lambda,alpha;
  // all iterations
  for(k=0;k<m;k++)
  {
    lambda=0;
    alpha=0;
    // multiplying matrix A by vector x_current
    for (i=0;i<N;i++) A_x_current[i]=0;
    
    for (i=0;i<N;i++)  // A*X(k)
      for (j=0;j<N;j++)
        A_x_current[i]+=matrix[j][i]*x_current[j];
    
    for (i=0;i<N;i++)  // (A*X(k),X(k))
      lambda+=A_x_current[i]*x_current[i];
    // normalizing x_current
    for (i=0;i<N;i++)
      alpha+=A_x_current[i]*A_x_current[i]; // alpha(k)
    alpha=1/sqrt(alpha);
    for (i=0;i<N;i++) x_current[i]=alpha*A_x_current[i]; // X(k+1)
  }
  // Printing given matrix
  printf("Problem:\n");
  ShowMatrix();
  // Printing solution
  printf("\nLambda(max)=%f\n",lambda);
  printf("X=(");
  for (i=0;i<N;i++) printf("%f%s",x_current[i],(i==N-1?")":","));
}

Инвестиции, проценты, прибыли
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//////////////////////////////////////////////////////////////////////////////
//
//  Investments, percents, incomes
//  (c) Johna Smith, 1996
//
//  Method description:
//    s0 - initial investment
//    s  - final sum on account
//    P  - sum on account increased by P % per year
//    N  - number of years
//   If we know three of these values we can calculate fourth value
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
// this function calculates s0
float StartValue(float end_value, float percents_per_period, float periods)
{
  return end_value/pow(1+percents_per_period/100,periods);
}
// this function calculates s
float EndValue(float start_value, float percents_per_period, float periods)
{
  return start_value*pow(1+percents_per_period/100,periods);
}
// this function calculates P
float PercentsPerPeriod(float start_value, float end_value, float periods)
{
  return 100*(pow(end_value/start_value,1/periods)-1);
}
// this function calculates N
float Periods(float start_value, float end_value, float percents_per_period)
{
  return (log10(end_value)-log10(start_value))/log10(1+percents_per_period/100);
}
void main(void)
{
  // If we invest $5000 for 5 years and bank pays 3% per year
  // the final sum on the account will be...
  printf("%f\n",EndValue(5000,3,5));
  // How much should we invest if we want to get $30000 and we
  // can wait 22 years and bank pays 3% per year
  printf("%f\n",StartValue(30000,3,22));
  // How much years we will wait if we invest $20000 and want to
  // get $30000. Bank pays 3% per year
  printf("%f\n",Periods(20000,30000,3));
  // If we want to invest $15000, wait 18 years and get $30000
  // then we need to find bank which pays 'PercentsPerPeriod' % per year
  printf("%f\n",PercentsPerPeriod(15000,30000,18));
}

Регулярные инвестиции, проценты, прибыли
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
//////////////////////////////////////////////////////////////////////////////
//
//  Regular investments, percents, incomes
//  (c) Johna Smith, 1996
//
//  Method description:
//    s1 - investment per year (we invest each year 's1' dollars)
//    s  - final sum on account
//    P  - sum on account increased by P % per year
//    N  - number of years
//   If we know three of these values we can calculate fourth value
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
// this function calculates s1
float InvestmentValue(float end_value, float percents_per_period, float periods)
{
  float I=percents_per_period/100;
  return end_value*I/(pow(1+I,periods)-1);
}
// this function calculates s
float EndValue(float investment_value, float percents_per_period, float periods)
{
  float I=percents_per_period/100;
  return investment_value*(pow(1+I,periods)-1)/I;
}
// this function calculates P
float PercentsPerPeriod(float investment_value, float end_value, float periods)
{
  float i=0, h=0.01;
  while (fabs(h)>2.5e-4)
  {
    do i+=h; while ((end_value*i/(pow(1+i,periods)-1)-investment_value)/h>=0);
    h=-h/4;
  }
  return i*100;
}
// this function calculates N
float Periods(float investment_value, float end_value, float percents_per_period)
{
  float I=percents_per_period/100;
  return log(end_value*I/investment_value+1)/log(1+I);
}
void main(void)
{
  // If we will invest $1000 every year during 10 years and bank pays 3%
  // per year the final sum on the account will be...
  printf("%f\n",EndValue(1000,3,10));
 
  // How much years we will wait if we invest $1000 every year and want to
  // get $30000. Bank pays 3% per year
  printf("%f\n",Periods(1000,30000,3));
 
  // How much should we invest every year if we want to get $30000 and we
  // can wait 20 years and bank pays 3% per year
  printf("%f\n",InvestmentValue(30000,3,20));
 
  // If we want to invest $1000 every year during 20 years and get $30000
  // then we need to find bank which pays 'PercentsPerPeriod' % per year
  printf("%f\n",PercentsPerPeriod(1000,30000,20));
}


Данная "Коллекция алгоритмов" подготовлена и размещена в связи с участившимися попытками обучения азам программирования на форумах.
 
Текущее время: 14:05. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru