e-olymp 1288. n-значные числа

02/02/2020 by Владислав Стасюк

Задача:

Сколько натуральных $n$ -значных чисел начинаются с цифры $a$ или цифры $b$?

Входные данные:

Заданы три целых числа: натуральное $n$ [latex](0 \lt n \leqslant 10^6)[/latex] и целые $a$ и $b$. Все данные, как и само условие задачи, заданы в десятичной системе счисления.

Выходные данные:

Вывести количество натуральных $n$ -значных чисел, которые начинаются с цифры $a$ или цифры $b$.

Тесты:

Ввод	Вывод
3 3 4	200
1 2 2	1
4 0 0	0
10 9 9	1000000000

Код:

#include <iostream>
using namespace std;

int main() {
    int n, a, b;
    cin >> n >> a >> b;
    string s;
    if (a + b == 0) cout << 0 << endl;
    else
    {
        if ((a == b) or !(a * b)) cout << 1;
        else cout << 2;
        for (int i = 0; i < n - 1; i++) s += '0';
        cout << s << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, a, b;

cin >> n >> a >> b;

string s;

if (a + b == 0) cout << 0 << endl;

else

{

if ((a == b) or !(a * b)) cout << 1;

else cout << 2;

for (int i = 0; i < n - 1; i++) s += '0';

cout << s << endl;

}

return 0;

}

Решение:

Среди однозначных чисел с каждой цифры начинается только одно число.
Среди двухзначных чисел с одной цифры начинается уже десять чисел.
Среди трехзначных — сто и так далее. Легко заметить закономерность, что в количестве чисел, начинающихся с определенной цифры, единица всегда остается, а к ней приписывают $n-1$ нулей, где $n$ — количество разрядов.
Если мы ищем количество чисел начинающихся уже с двух разных цифр, то единица меняется на двойку, а количество нулей сохраняется.

Отсюда и решение задачи — последовательная проверка всех вариантов и вывод ответа.

Ссылки:

e-olymp
ideone

Related Images:

e-olymp 1210. Очень просто!!!

04/12/2017 by Вадим Гордийчук

Задача

По заданным числам [latex]n[/latex] и [latex]a[/latex] вычислить значение суммы: [latex]\sum\limits_{i=1}^{n} {i \cdot a^i}[/latex]

Входные данные

Два натуральных числа [latex]n[/latex] и [latex]a[/latex].

Выходные данные

Значение суммы. Известно, что оно не больше [latex]10^{18}[/latex].

Тесты

Входные данные	Выходные данные
3 3	102
4 4	1252
9 3	250959
7 14	785923166
1009 1	509545

Код программы

#include <iostream>
using namespace std;

int main()
{
    unsigned long long int n, a, answer;
    cin >> n >> a;
    if (a > 1)
    {
        answer = n*a;
        for(unsigned long long int i = n-1; i > 0; --i)
            answer = (answer+i)*a;
    }
    else
        answer = n*(n+1)/2;
    cout << answer;
    return 0;
}

#include <iostream>

using namespace std;

int main()

{

unsigned long long int n, a, answer;

cin >> n >> a;

if (a > 1)

{

answer = n*a;

for(unsigned long long int i = n-1; i > 0; --i)

answer = (answer+i)*a;

}

else

answer = n*(n+1)/2;

cout << answer;

return 0;

}

import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner in = new Scanner(System.in);
        long n = in.nextInt(), a = in.nextInt(), ans;
        if (a > 1)
        {
            ans = n*a;
            for(long i = n-1; i > 0; --i)
                ans = (ans+i)*a;
        }
        else
            ans = n*(n+1)/2;
        System.out.println(ans);
    }
}

import java.util.*;

import java.lang.*;

import java.io.*;

public class Main

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

long n = in.nextInt(), a = in.nextInt(), ans;

if (a > 1)

{

ans = n*a;

for(long i = n-1; i > 0; --i)

ans = (ans+i)*a;

}

else

ans = n*(n+1)/2;

System.out.println(ans);

}

Решение задачи

Данную задачу можно решить прямым линейным вычислением значений элементов заданного ряда, то есть получать значение элемента ряда с индексом [latex]i[/latex] умножением [latex]a[/latex] (которое необходимо возвести в степень [latex]i[/latex]) на индекс [latex]i[/latex] и накапливать сумму этих значений в выделенной переменной.
Но безусловно такое решение не является качественным (даже если будет использован алгоритм бинарного возведения в степень).

Для получения качественного решения распишем ряд подробно:
[latex]A[/latex] [latex]=[/latex] [latex]\sum\limits_{i=1}^{n} {i \cdot a^i}[/latex] [latex]=[/latex] [latex]a+2a^2+3a^3+\ldots+\left( n-1 \right) a^{n-1}+na^{n}[/latex] [latex]=[/latex] [latex]na^{n}[/latex] [latex]+[/latex] [latex]\left( n-1 \right)a^{n-1}[/latex] [latex]+[/latex] [latex]\ldots[/latex] [latex]+[/latex] [latex]3a^{3}[/latex] [latex]+[/latex] [latex]2a^2[/latex] [latex]+[/latex] [latex]a[/latex].
Очевидно, что из полученного выражения можно вынести [latex]a[/latex] за скобки. Применим данную операцию:
[latex]A[/latex] [latex]=[/latex] [latex] \left( na^{n-1}+\left( n-1 \right)a^{n-2}+\ldots+3a^{2}+2a+1\right) \cdot a[/latex] Из полученной формулы видно, что аналогичное действие можно применить вновь, для внутреннего выражения [latex]na^{n-1}[/latex] [latex]+[/latex] [latex]\left( n-1 \right)a^{n-2}[/latex] [latex]+[/latex] [latex]\ldots[/latex] [latex]+[/latex] [latex]3a^{2}[/latex] [latex]+[/latex] [latex]2a[/latex]. Получим:
[latex]A[/latex] [latex]=[/latex] [latex] \left( \left( na^{n-2}+\left( n-1 \right)a^{n-3}+\ldots+3a+2 \right) \cdot a +1 \right) \cdot a[/latex].
После конечного количества вынесений за скобки, получим:
[latex]A[/latex] [latex]=[/latex] [latex]\left( \left( \ldots \left( \left(na+\left(n-1\right)\right) \cdot a + \left(n-2\right) \right) \ldots+2\right) \cdot a +1\right) \cdot a[/latex].

Таким образом, решение данной задачи сводится к вычислению суммы «изнутри» скобок.

Но из-за того, что в условии подано ограничение только на сумму, программа с реализованным вычислением суммы изнутри и асимптотикой [latex]O \left( n \right)[/latex] не пройдёт все тесты системы www.e-olymp.com в силу частного случая [latex]a = 1[/latex], так как значение [latex]n[/latex] может быть для него достаточно большим, ибо числа [latex]a[/latex] и [latex]n[/latex] компенсируют друг-друга по отношению к максимальному значению суммы. Но в случае [latex]a = 1[/latex] сумма данного ряда является суммой арифметической прогрессии, а именно — натурального ряда. Для вычисления этой суммы существует формула [latex]\sum\limits_{i=1}^{n} {i} = \frac{n \left( n+1 \right)}{2}[/latex]. Этот частный случай легко отсеять.

Асимптотика программы: [latex]const[/latex] при [latex]a = 1[/latex], и [latex]O \left( n \right)[/latex] иначе.

Ссылки

Related Images:

MLoops 18

27/12/2015 by Александр Димитриев

Условие

1123581321345589144233377
1235813213455891442333776
2358132134558914423337761
3581321345589144233377610
5813213455891442333776109

Входные данные

В одной строке задано два числа [latex]n[/latex] и [latex]m[/latex].

Выходные данные

Вывести таблицу размерностью [latex]n\times m[/latex].

Тесты

Входные данные

Выходные данные

1 1

2 2

11
12

5 5

11235

12358

23581

35813

58132

9 18

112358132

123581321

235813213

358132134

581321345

813213455

132134558

213455891

345589144

558914423

891442333

144233377

233377610

377610987

610987159

987159725

159725844

258441816

418167651

25 5

1123581321345589144233377
1235813213455891442333776
2358132134558914423337761
3581321345589144233377610
5813213455891442333776109

1123581321345589144233377

1235813213455891442333776

2358132134558914423337761

3581321345589144233377610

5813213455891442333776109

Код

#include <iostream>
#include <cmath>
using namespace std;
 

int f(int a) {
	int b=1;
	for (int i=0; i<a; i++) {
		 b*=10;
	}
	return b;
}
 
int g(int a) {
	return (a==0 ? 1 : floor(log10(a))+1);
}
 
void h(int &i, int &j, int &a, int &b, int &a1, int &b1) {
	cout << endl; 
	a=a1;
	b=b1;
	i++;
	j=0; 
}
 
int main() {
	int n, m, a=1, b=0, c, a1=0, b1=1;
	cin >> n >> m;
	int i=1, j=0;
	while (i<=m) {
		if (j==n) {
		   	h(i, j, a, b, a1, b1);
		}
		c=a+b;
		a=b;
		b=c;
		if (j==0) {
		    a1=a;
		   	b1=b;
		}
		if (j+g(c)>n) { // если текущее число Фибоначчи выходит за предел строки
		    cout << c/f(g(c)-n+j); // печатаем ту часть что не выходит за ее предел
		 	h(i, j, a, b, a1, b1);
		} 
		else if (i<=m) {
		 	cout << c;
		 	j+=g(c); 
		} 
	}
	return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int f(int a) {

int b=1;

for (int i=0; i<a; i++) {

b*=10;

}

return b;

}

int g(int a) {

return (a==0 ? 1 : floor(log10(a))+1);

}

void h(int &i, int &j, int &a, int &b, int &a1, int &b1) {

cout << endl;

a=a1;

b=b1;

i++;

j=0;

}

int main() {

int n, m, a=1, b=0, c, a1=0, b1=1;

cin >> n >> m;

int i=1, j=0;

while (i<=m) {

if (j==n) {

h(i, j, a, b, a1, b1);

}

c=a+b;

a=b;

b=c;

if (j==0) {

a1=a;

b1=b;

}

if (j+g(c)>n) { // если текущее число Фибоначчи выходит за предел строки

cout << c/f(g(c)-n+j); // печатаем ту часть что не выходит за ее предел

h(i, j, a, b, a1, b1);

}

else if (i<=m) {

cout << c;

j+=g(c);

}

return 0;

}

Решение

Несложно догадаться что данная последовательность чисел это числа Фибоначчи. Для того чтобы построить таблицу надо сначала найти числа Фибоначчи (у меня это — [latex]a,b,c[/latex]), после печатаем их в строку далее переходим на новую строку и начинаем со 2 элемента относительно предыдущей строки это выполняет функция [latex]h[/latex], и так пока [latex]i \le m[/latex]. Но может возникнуть проблема с выходом за предел строки и для того чтобы этого не произошло нам нужны функции [latex]f[/latex], которая возводит 10 в заданную степень, это нам надо чтобы отрезать то что выходит за предел строки, для этого используем целочисленное деление на 10 в нужной степени, и [latex]g[/latex], которая считает количество цифр в данном числе Фибоначчи, для того чтобы определить в какую степень нам надо возвести 10, чтобы оставить только ту часть что не выходит за предел строки.
Код программы

Related Images:

MLoops12

20/12/2015 by Станислав Коциевский

Задача

Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел $n > 0$ (количество столбцов) и $m > 0$ (количество строк).
Замечание 1. В некоторых задачах появляется дополнительный параметр $k < n$ .
Замечание 2. Многоточие означает продолжение последовательности
Совет. Если закономерность разгадать не получается, попробуйте воспользоваться Онлайн-энциклопедией целочисленных последовательностей.

12
+-------+-------+-------+
|123...k|k...321|123...k|
|23...k1|1k...32|23...k1|
|3...k12|21k...3|3...k12|
|.......|.......|.......|
|k123...|...321k|k123...|
+-------+-------+-------+
|123...k|k...321|123...k|
|23...k1|1k...32|23...k1|

+-------+-------+-------+

|123...k|k...321|123...k|

|23...k1|1k...32|23...k1|

|3...k12|21k...3|3...k12|

|.......|.......|.......|

|k123...|...321k|k123...|

+-------+-------+-------+

|123...k|k...321|123...k|

|23...k1|1k...32|23...k1|

Тесты

Результат

+----+----+----
|1234|4321|1234
|2341|1432|2341
|3412|2143|3412
|4123|3214|4123
+----+----+----
|1234|4321|1234

+----+----+----

|1234|4321|1234

|2341|1432|2341

|3412|2143|3412

|4123|3214|4123

+----+----+----

|1234|4321|1234

+---+---+-
|123|321|1
|231|132|2
|312|213|3
+---+---+-
|123|321|1
|231|132|2

+---+---+-

|123|321|1

|231|132|2

|312|213|3

+---+---+-

|123|321|1

|231|132|2

+--+--+--+--
|12|21|12|21
|21|12|21|12
+--+--+--+--
|12|21|12|21

+--+--+--+--

|12|21|12|21

|21|12|21|12

+--+--+--+--

|12|21|12|21

+-------+-------+-------+
|1234567|7654321|1234567|
|2345671|1765432|2345671|
|3456712|2176543|3456712|
|4567123|3217654|4567123|
|5671234|4321765|5671234|
|6712345|5432176|6712345|
|7123456|6543217|7123456|
+-------+-------+-------+
|1234567|7654321|1234567|
|2345671|1765432|2345671|
|3456712|2176543|3456712|
|4567123|3217654|4567123|
|5671234|4321765|5671234|
|6712345|5432176|6712345|

+-------+-------+-------+

|1234567|7654321|1234567|

|2345671|1765432|2345671|

|3456712|2176543|3456712|

|4567123|3217654|4567123|

|5671234|4321765|5671234|

|6712345|5432176|6712345|

|7123456|6543217|7123456|

+-------+-------+-------+

|1234567|7654321|1234567|

|2345671|1765432|2345671|

|3456712|2176543|3456712|

|4567123|3217654|4567123|

|5671234|4321765|5671234|

|6712345|5432176|6712345|

Код программы

#include <iostream>
using namespace std;

int main()
{
	int n, m, k, j, p, z=0;
	cin>>n; //количество столбцов
	cin>>m; //количество  строк
	cin>>k;
	
	for (int i = 0;z<m; i++,z++) //перебираем строки
	{
		if  (i==k+1)
		 	i=0;
		for (j = 0; j<n;)
		{
			if (i%(k+1) == 0)
			{
				cout<<'+';
				j++;
				for (p = 1; (p<=k)&&(j<n); p++,j++)
				{
					cout<<'-';
				}
			}
			else
			{
				cout<<'|';
				j++;
				for (p = i; (p<=k)&&(j<n); p++,j++)
				{
					cout<<p;
				}
				for (p = 1;(p<i)&&(j<n); p++,j++)
				{
					cout<<p;
				}
				if (j<n)
					cout<<'|';
				j++;
				for (p = i-1;(p>0)&&(j<n); p--,j++)
				{
					cout<<p;
				}
				for (p = k; (p>=i)&&(j<n); p--,j++)
				{
					cout<<p;
				}
			}
		}
		cout<<endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

int n, m, k, j, p, z=0;

cin>>n; //количество столбцов

cin>>m; //количество строк

cin>>k;

for (int i = 0;z<m; i++,z++) //перебираем строки

{

if (i==k+1)

i=0;

for (j = 0; j<n;)

{

if (i%(k+1) == 0)

{

cout<<'+';

j++;

for (p = 1; (p<=k)&&(j<n); p++,j++)

{

cout<<'-';

}

else

{

cout<<'|';

j++;

for (p = i; (p<=k)&&(j<n); p++,j++)

{

cout<<p;

}

for (p = 1;(p<i)&&(j<n); p++,j++)

{

cout<<p;

}

if (j<n)

cout<<'|';

j++;

for (p = i-1;(p>0)&&(j<n); p--,j++)

{

cout<<p;

}

for (p = k; (p>=i)&&(j<n); p--,j++)

{

cout<<p;

}

cout<<endl;

}

return 0;

}

Решение

Закономерности в таблице

Через каждые [latex]k[/latex] строк, начиная с нулевой, встречается строка, в которой нулевой и каждый [latex]k[/latex]-й символы — «+», а остальные — «-«. Такие строки разделяют одинаковые [latex]k[/latex]-местные блоки строк.
Каждая строка блока строк содержит, в свою очередь, [latex]k[/latex]-местные блоки символов (эти блоки уже разные), разделенные символами «|». В каждой строке из блока два вида блоков символов (далее блок 1 и блок 2). Все нечетные блоки имеют вид блока 1, четные — блока 2.
Блок 1 содержит числа по возрастанию, начиная с номера строки в блоке строк, до [latex]k[/latex] включительно, т.е. числа из сегмента [latex][i ; k][/latex], где [latex]i[/latex] — номер строки в блоке строк. После них в блоке записаны числа от [latex]1[/latex] до номера строки в блоке, не включая сам этот номер, т.е. числа из полусегмента [latex][1 ; i)[/latex].
Блок 2 каждой строки содержит те же числа, что и блок 1, но записанные в противоположном порядке.

Реализация

Программа содержит один большой цикл, перебирающий строки. Причем, этот цикл содержит 2 счетчика строк — один считает номер текущей строки в таблице, а второй — в блоке строк. В этот цикл вложен цикл, перебирающий блоки, а в нем, в свою очередь, цикл, записывающий блок. Чтобы цикл вывода блоков символов (строк) не выводил лишние символы (строки), выводящие символы (строки) циклы, которые находятся внутри них, должны содержать проверку не только на окончание блока, но и на окончание таблицы (само собой, циклы, выводящие блоки тоже имеют проверку на конец таблицы).

ссылка на код на ideone

Related Images:

MLoops 11

19/12/2015 by Катя Писова

Задача

Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел $n > 0$ (количество столбцов) и $m > 0$ (количество строк).
Замечание 1. В некоторых задачах появляется дополнительный параметр $k < n$ .
Замечание 2. Многоточие означает продолжение последовательности. Совет. Если закономерность разгадать не получается, попробуйте воспользоваться Онлайн-энциклопедией целочисленных последовательностей.

Входные данные:

Три числа: количество столбцов и строк, параметр [latex]k[/latex].

Выходные данные:

+-------+-------+-------+
|123...k|123...k|123...k|
|23...k1|23...k1|23...k1|
|3...k12|3...k12|3...k12|
|.......|.......|.......|
|k123...|k123...|k123...|
+-------+-------+-------+
|123...k|123...k|123...k|
|23...k1|23...k1|23...k1|

+-------+-------+-------+

|123...k|123...k|123...k|

|23...k1|23...k1|23...k1|

|3...k12|3...k12|3...k12|

|.......|.......|.......|

|k123...|k123...|k123...|

+-------+-------+-------+

|123...k|123...k|123...k|

|23...k1|23...k1|23...k1|

Код программы:

#include <iostream>
using namespace std;
 
int main() 
{
	int m, n, k;
	cin >> m >> n >> k;
	for (int i = 0; i < m; i++)
	{
		if (i % (k + 1) == 0)
		{
			for (int j = 0; j < n; j++)
			{
				cout << (j % (k + 1) == 0 ? "+" : "-");
			}
		}
		else
		{
			for (int j = 0; j < n; j++)
			{
				if (j % (k + 1) == 0)
				{
					cout << "|";
				}
				else
				{
					int a = (j % (k + 1) + i % (k + 1) - 1) % k;
					cout << (a == 0 ? k : a);
				}
			}
		}
		cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

int m, n, k;

cin >> m >> n >> k;

for (int i = 0; i < m; i++)

{

if (i % (k + 1) == 0)

{

for (int j = 0; j < n; j++)

{

cout << (j % (k + 1) == 0 ? "+" : "-");

}

else

{

for (int j = 0; j < n; j++)

{

if (j % (k + 1) == 0)

{

cout << "|";

}

else

{

int a = (j % (k + 1) + i % (k + 1) - 1) % k;

cout << (a == 0 ? k : a);

}

cout << endl;

}

return 0;

}

Решение:

Для построения данной таблицы нужно найти закономерность чередования символов в таблице. Решение данной задачи можно осуществить с помощью двух циклов. Первый отвечает за строки, а второй — за столбцы. Пусть нумерация строк и столбцов начинается с нуля. Тогда, если номер строчки нацело делится на [latex](k+1)[/latex], то рассматриваем столбцы этой строчки. Если номер столбца нацело делится на [latex](k+1)[/latex], то записываем «+», иначе «-«. Если номер строки не делится нацело на [latex](k+1)[/latex], а номер столбца в этой строке — делится, то записываем «|». Если номер строки и столбца не делятся нацело на [latex](k+1)[/latex], то создаем переменную, с помощью которой будем заполнять таблицу цифрами. Так как, каждый столбик и каждая строка имеют свой номер, то с помощью нахождения суммы остатка от деления строки и столбца на [latex](k+1)[/latex] будем находит значение элемента, стоящего на пересечении [latex]i- [/latex]ой строки и [latex]i-[/latex]ого столбца, но этого не достаточно, в таблице есть перестановка, чтобы ее реализовать отнимаем от суммы единицу, делая этим сдвиг вправо. Также от полученного результата нужно найти остаток от деления на параметр [latex]k[/latex] для того, чтобы выполнялась правильная последовательность символов. Если результат вычисления переменной равен нулю, то записываем значение параметра [latex]k[/latex], иначе — результат вычисления переменной.

Тесты:

Выходные данные:

+----
|1234
|2345
|3456
|4567

+----

|1234

|2345

|3456

|4567

+-----+-----+
|12345|12345|
|23451|23451|
|34512|34512|
|45123|45123|
|51234|51234|
+-----+-----+
|12345|12345|
|23451|23451|
|34512|34512|
|45123|45123|
|51234|51234|
+-----+-----+
|12345|12345|

+-----+-----+

|12345|12345|

|23451|23451|

|34512|34512|

|45123|45123|

|51234|51234|

+-----+-----+

|12345|12345|

|23451|23451|

|34512|34512|

|45123|45123|

|51234|51234|

+-----+-----+

|12345|12345|

+-----+
|12345|
|23451|
|34512|
|45123|
|51234|
+-----+
|12345|
|23451|

+-----+

|12345|

|23451|

|34512|

|45123|

|51234|

+-----+

|12345|

|23451|

+-------+-------+-------+-----
|1234567|1234567|1234567|12345
|2345671|2345671|2345671|23456
|3456712|3456712|3456712|34567
|4567123|4567123|4567123|45671
|5671234|5671234|5671234|56712
|6712345|6712345|6712345|67123
|7123456|7123456|7123456|71234
+-------+-------+-------+-----
|1234567|1234567|1234567|12345
|2345671|2345671|2345671|23456
|3456712|3456712|3456712|34567
|4567123|4567123|4567123|45671
|5671234|5671234|5671234|56712
|6712345|6712345|6712345|67123
|7123456|7123456|7123456|71234
+-------+-------+-------+-----

+-------+-------+-------+-----

|1234567|1234567|1234567|12345

|2345671|2345671|2345671|23456

|3456712|3456712|3456712|34567

|4567123|4567123|4567123|45671

|5671234|5671234|5671234|56712

|6712345|6712345|6712345|67123

|7123456|7123456|7123456|71234

+-------+-------+-------+-----

|1234567|1234567|1234567|12345

|2345671|2345671|2345671|23456

|3456712|3456712|3456712|34567

|4567123|4567123|4567123|45671

|5671234|5671234|5671234|56712

|6712345|6712345|6712345|67123

|7123456|7123456|7123456|71234

+-------+-------+-------+-----

Код программы на ideone.com

Related Images:

MLoops 16

01/12/2015 by Кондратюк Настя

Задача

123123123123123123123123123
231231231231231231231231231
132132132132132132132132132
123123123123123123123123123
231231231231231231231231231
132132132132132132132132132
123123123123123123123123123
231231231231231231231231231

Тесты

[latex]m[/latex] [latex]n[/latex]
4 3	123 231 132 123
8 8	12312312 23123123 13213213 12312312 23123123 13213213 12312312 23123123
10 27	123123123123123123123123123 231231231231231231231231231 132132132132132132132132132 123123123123123123123123123 231231231231231231231231231 132132132132132132132132132 123123123123123123123123123 231231231231231231231231231 132132132132132132132132132 123123123123123123123123123

Код программы

#include <iostream>
using namespace std;

int main() {
	int n, m;
	cin >> m >> n;
	for(int i=1; i<=m; i++){
		for(int j=1; j<=n; j++){
			if((i+j)%3==0) cout << 2;
			else{
				if(j%3==0){
					if((i+j+1)%3==0) cout << 1;
					else cout << 3;
				}
				else if((j-1)%3==0) cout << 1;
				     else cout << 3;
			}
		}
		cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, m;

cin >> m >> n;

for(int i=1; i<=m; i++){

for(int j=1; j<=n; j++){

if((i+j)%3==0) cout << 2;

else{

if(j%3==0){

if((i+j+1)%3==0) cout << 1;

else cout << 3;

}

else if((j-1)%3==0) cout << 1;

else cout << 3;

}

cout << endl;

}

return 0;

}

ideone.com

Решение

Пронумеруем строки от [latex]1[/latex] до [latex]m[/latex] , столбцы — от [latex]1[/latex] до [latex]n[/latex].

	1	2	3	4	5	6	7	…	n
1	1	2	3	1	2	3	1	…	…
2	2	3	1	2	3	1	2	…	…
3	1	3	2	1	3	2	1	…	…
4	1	2	3	1	2	3	1	…	…
5	2	3	1	2	3	1	2	…	…
6	1	3	2	1	3	2	1	…	…
7	1	2	3	1	2	3	1	…	…
…	…	…	…	…	…	…	…	…	…
m	…	…	…	…	…	…	…	…	…

Положение символа [latex]2[/latex] определяется однозначно для всей таблицы [latex]\left (n+m \right )\vdots 3[/latex]. В столбцах, где [latex]n\vdots 3[/latex], положение символа [latex]1[/latex] — [latex]\left ( n+m+1 \right )\vdots 3[/latex] , на оставшихся свободных местах — символ [latex]3[/latex] . В столбцах, где [latex]\left ( n-1\right )\vdots 3[/latex], на свободных местах стоит символ [latex]1[/latex]. В оставшихся столбцах на свободных местах стоит символ [latex]3[/latex].

Related Images:

MLoops 17

16/11/2015 by Павел Загинайло

Задача

+++++++++++++++++++++++++++++++
+....^....+....^....+....^....+
+....|....+....|....+....|....+
+<-- k -->+<-- k -->+<-- k -->+
+....|....+....|....+....|....+
+....v....+....v....+....v....+
+++++++++++++++++++++++++++++++
+....^....+....^....+....^....+
+....|....+....|....+....|....+
+<-- k -->+<-- k -->+<-- k -->+
+....|....+....|....+....|....+
+....v....+....v....+....v....+
+++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++

+....^....+....^....+....^....+

+....|....+....|....+....|....+

+<-- k -->+<-- k -->+<-- k -->+

+....|....+....|....+....|....+

+....v....+....v....+....v....+

+++++++++++++++++++++++++++++++

+....^....+....^....+....^....+

+....|....+....|....+....|....+

+<-- k -->+<-- k -->+<-- k -->+

+....|....+....|....+....|....+

+....v....+....v....+....v....+

+++++++++++++++++++++++++++++++

Тесты

Входные данные

Выходные данные

+++++++++++++++++++++++++++++++
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+++++++++++++++++++++++++++++++
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+.........+.........+.........+
+++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++

+.........+.........+.........+

+++++++++++++++++++++++++++++++

+.........+.........+.........+

+++++++++++++++++++++++++++++++

++++++++
+....+..
+....+..
+....+..
+....+..

++++++++

+....+..

++++++++++++++++++++
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
++++++++++++++++++++
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
++++++++++++++++++++
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
+...+...+...+...+...
++++++++++++++++++++
+...+...+...+...+...

++++++++++++++++++++

+...+...+...+...+...

++++++++++++++++++++

+...+...+...+...+...

++++++++++++++++++++

+...+...+...+...+...

++++++++++++++++++++

+...+...+...+...+...

Алгоритм

Программа выполняется с помощью двух циклов. Первый цикл отвечает за строки, второй за столбцы. Метод заключается в том, чтобы узнать, когда мы записываем именно ‘+’, а уже в остальные места записываем ‘.’. Для начала проверяем делится ли номер строки, уменьшенный на 1, нацело на 6. Если да, то записываем +. Далее проверяем, делится ли номер столбца, уменьшенный на 1, на число [latex]k+1[/latex], где [latex]k[/latex] — вводимый параметр. Во всех остальных случаях пишем ‘.’.

Код программы

#include <iostream>
using namespace std;

int main() {
	int m, n, k; //m-строки, n - столбцы
	cin >> m >> n >> k;
	for (int i = 0; i < m; i++){
		for (int j = 0; j < n; j++){
			if (i%6 == 0) cout << '+';
			else if (j%(k+1) == 0) cout << '+';
			else cout << '.';
		}
	cout << endl;	
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int m, n, k; //m-строки, n - столбцы

cin >> m >> n >> k;

for (int i = 0; i < m; i++){

for (int j = 0; j < n; j++){

if (i%6 == 0) cout << '+';

else if (j%(k+1) == 0) cout << '+';

else cout << '.';

}

cout << endl;

}

return 0;

}

Код программы на ideone.com

Related Images:

Mloops 21

11/11/2015 by Женя Максимова

Задача.Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел [latex]n>0[/latex] (количество столбцов) и [latex]m>0[/latex] (количество строк).
Совет. Если закономерность разгадать не получается, попробуйте воспользоваться Онлайн-энциклопедией целочисленных последовательностей.

1+12+33+64+105+156+217+288
12+33+64+105+156+217+288+1
33+64+105+156+217+288+1+12
64+105+156+217+288+1+12+33
105+156+217+288+1+12+33+64
156+217+288+1+12+33+64+105
217+288+1+12+33+64+105+156

Тесты

№	[latex]m[/latex]	[latex]n[/latex]	Результат
1	5	13	1+12+33+64+10 12+33+64+105+ 33+64+105+1+1 64+105+1+12+3 105+1+12+33+6
2	8	11	1+12+33+64+ 12+33+64+1+ 33+64+1+12+ 64+1+12+33+ 1+12+33+64+ 12+33+64+1+ 33+64+1+12+ 64+1+12+33+
3	11	20	1+12+33+64+105+156+2 12+33+64+105+156+217 33+64+105+156+217+1+ 64+105+156+217+1+12+ 105+156+217+1+12+33+ 156+217+1+12+33+64+1 217+1+12+33+64+105+1 1+12+33+64+105+156+2 12+33+64+105+156+217 33+64+105+156+217+1+ 64+105+156+217+1+12+

Код программы

#include <iostream>
#include <stdio.h>
#include<cmath>
using namespace std;
int m, n, max_q; // длина и ширина таблицы, максимальное количество чисел в строке

int element(int i) // формула для i-того элемента последовательности
{
 i++;
 return i*i+4*(i*i-i); 
}
int length_of_element(int el) // длина i-того элемента
{
 if( el==0|| el==1 ) 
   return 1;
 return ceil(log10(el));
}

int max_quantity() // максимальное количество чисел в строке
{
 int max_q=0;
 int length=0;
 for(int j=0; true; j++) 
  {
	 int elem = element(j);
	 int  length_el = length_of_element(elem);
	 if(length + length_el <= n) // проверяем, "поместится" ли в строку очередное число 
    {
      length += length_el;
      max_q++;
      if(length == n)
        return max_q;
    }
	 else // если число не "влезает", добавляем "+"
	{
	  max_q++;
	  return max_q;
	}
   if(length+1 <= n) // если число "поместилось", но осталось место еще для одного символа, тоже добавляем "+"
    {
     length += 1;
     if(length == n)
      return max_q;
    }
  }
 return max_q; // такая ситуация невозможна
}

int line(int i) // печать i-той строки
{
 int length=0;
 for(int jj=i; true; jj++)
    {
     int j = jj % max_q; // формула циклического сдвига чисел в строке
     int  elem = element(j); // число которое мы будем выводить
     int  length_el = length_of_element(elem); // длина числа
     if(length + length_el <= n) // если полученная нами длина все еще меньше заданного количества столбцов, мы выводим число 
        {
         length += length_el;
         cout << elem;
         if(length == n)
            {
             cout << endl;
             return length;
            }
        }
     else // если длина получается больше, мы "отрезаем" от числа нужное количество символов
        {
         int excess = length+length_el-n;
         for(int z = 0; z < excess; ++z) elem /= 10;
         cout << elem << endl;
         return length;
        }

     if(length + 1 <= n) // проверяем, нужно ли выводить "+"
      {
        length += 1; cout << "+";
        if(length == n)
        {
          cout << endl;
          return length;
        }
      }
    }
return 0;
}

int main()
{
 cin >> m >> n; // параметры таблицы
 max_q = max_quantity(); // вычисляем максимально возможное количество чисел в строке
 for(int i=0; i<m; i++) line(i); // вывод таблицы
 return 0;
}

#include <iostream>

#include <stdio.h>

#include<cmath>

using namespace std;

int m, n, max_q; // длина и ширина таблицы, максимальное количество чисел в строке

int element(int i) // формула для i-того элемента последовательности

{

i++;

return i*i+4*(i*i-i);

}

int length_of_element(int el) // длина i-того элемента

{

if( el==0|| el==1 )

return 1;

return ceil(log10(el));

}

int max_quantity() // максимальное количество чисел в строке

{

int max_q=0;

int length=0;

for(int j=0; true; j++)

{

int elem = element(j);

int length_el = length_of_element(elem);

if(length + length_el <= n) // проверяем, "поместится" ли в строку очередное число

{

length += length_el;

max_q++;

if(length == n)

return max_q;

}

else // если число не "влезает", добавляем "+"

{

max_q++;

return max_q;

}

if(length+1 <= n) // если число "поместилось", но осталось место еще для одного символа, тоже добавляем "+"

{

length += 1;

if(length == n)

return max_q;

}

return max_q; // такая ситуация невозможна

}

int line(int i) // печать i-той строки

{

int length=0;

for(int jj=i; true; jj++)

{

int j = jj % max_q; // формула циклического сдвига чисел в строке

int elem = element(j); // число которое мы будем выводить

int length_el = length_of_element(elem); // длина числа

if(length + length_el <= n) // если полученная нами длина все еще меньше заданного количества столбцов, мы выводим число

{

length += length_el;

cout << elem;

if(length == n)

{

cout << endl;

return length;

}

else // если длина получается больше, мы "отрезаем" от числа нужное количество символов

{

int excess = length+length_el-n;

for(int z = 0; z < excess; ++z) elem /= 10;

cout << elem << endl;

return length;

}

if(length + 1 <= n) // проверяем, нужно ли выводить "+"

{

length += 1; cout << "+";

if(length == n)

{

cout << endl;

return length;

}

return 0;

}

int main()

{

cin >> m >> n; // параметры таблицы

max_q = max_quantity(); // вычисляем максимально возможное количество чисел в строке

for(int i=0; i<m; i++) line(i); // вывод таблицы

return 0;

}

Алгоритм

В данной задаче закономерностью является последовательность двенадцатиугольных чисел, общая формула которых имеет вид::

[latex]n^2+4\cdot(n^2-n)[/latex]

Для удобства выполнения циклических операций я изменила формулу последовательности так, чтобы результат был верным при нумерации с нуля.

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

Чтобы число столбцов [latex]n[/latex] соответствовало числу символов в каждой строке, мы выводим числа по одному, каждый раз проверяя, не превысила ли общая длина строки заданное число [latex]n[/latex]. Если длина все-таки получается больше, мы выводим то количество символов, которое помещается в данную строку, а остальные отбрасываем.

Код программы

Related Images:

MLoops 7

10/11/2015 by Настя Панько

Задача

Входные данные

Два целых числа: количество столбцов и строк.

Выходные данные

Таблица [latex]m * n[/latex] со следующей закономерностью:

123+123+123+123+1
+123+123+123+123+
3+123+123+123+123
23+123+123+123+12
123+123+123+123+1
+123+123+123+123+
3+123+123+123+123
23+123+123+123+12
123+123+123+123+1
+123+123+123+123+
3+123+123+123+123
23+123+123+123+12
123+123+123+123+1
+123+123+123+123+
3+123+123+123+123
23+123+123+123+12

123+123+123+123+1

+123+123+123+123+

3+123+123+123+123

23+123+123+123+12

123+123+123+123+1

+123+123+123+123+

3+123+123+123+123

23+123+123+123+12

123+123+123+123+1

+123+123+123+123+

3+123+123+123+123

23+123+123+123+12

123+123+123+123+1

+123+123+123+123+

3+123+123+123+123

23+123+123+123+12

Код

 #include <iostream>
 #include <cmath>
 using namespace std;
 
 int main(){
     int m, n;
     cin >> m >> n;
     for (int i = 1; i <= m; i++){
         for (int j = 1; j <= n; j++){
             cout << (abs(1 + 3*i + j) % 4 == 0 ? '+' : (char)('0' + abs(1 + 3*i + j) % 4));
         }
         cout << endl;
     }
     return 0;
 }

#include <iostream>

#include <cmath>

using namespace std;

int main(){

int m, n;

cin >> m >> n;

for (int i = 1; i <= m; i++){

for (int j = 1; j <= n; j++){

cout << (abs(1 + 3*i + j) % 4 == 0 ? '+' : (char)('0' + abs(1 + 3*i + j) % 4));

}

cout << endl;

}

return 0;

}

Тесты

123+
+123
3+12

123+

+123

3+12

123+123
+123+12
3+123+1
23+123+
123+123
+123+12
3+123+1

123+123

+123+12

3+123+1

23+123+

123+123

+123+12

3+123+1

123+123+123
+123+123+12
3+123+123+1
23+123+123+
123+123+123
+123+123+12
3+123+123+1
23+123+123+
123+123+123
+123+123+12
3+123+123+1

123+123+123

+123+123+12

3+123+123+1

23+123+123+

123+123+123

+123+123+12

3+123+123+1

23+123+123+

123+123+123

+123+123+12

3+123+123+1

Решение

Вводим количество строк [latex]m[/latex] и количество столбцов [latex]n[/latex]. Программа имеет два цикла — один внутри другого. Внешний цикл считывает номер строки, а внутренний — обеспечивает сдвиг. Строки и столбцы чередуются со смещением назад по 4 элемента.

Код

Ideone.com

Related Images:

MLoops8

07/11/2015 by Настя Филипчук

Задача

Входные данные

Два числа:количество столбцов и строк.

Выходные данные

Таблица размером n*m со следующей закономерностью:

+21++21++21++21++21++21++
1++21++21++21++21++21++21
+21++21++21++21++21++21++
1++21++21++21++21++21++21
+21++21++21++21++21++21++
1++21++21++21++21++21++21
+21++21++21++21++21++21++
1++21++21++21++21++21++21

Код

#include <iostream>
using namespace std;
int main(){
	int m,n; 
	cin>>n>>m;
	for(int i=1;i<m+1;i++){ 
		for(int j=1;j<n+1;j++){  
			if(i%2==0){
				if ((j+3)%4==0) 
					cout<< "1"; 
				else 
					cout<<(j%4==0?"2":"+");
			}
			else{
				if ((j+1)%4==0)
					cout<<"1";
				else 
					cout<<((j+2)%4==0?"2":"+");
			}
		}
	cout<<endl;
	}	
	return 0;
}

#include <iostream>

using namespace std;

int main(){

int m,n;

cin>>n>>m;

for(int i=1;i<m+1;i++){

for(int j=1;j<n+1;j++){

if(i%2==0){

if ((j+3)%4==0)

cout<< "1";

else

cout<<(j%4==0?"2":"+");

}

else{

if ((j+1)%4==0)

cout<<"1";

else

cout<<((j+2)%4==0?"2":"+");

}

cout<<endl;

}

return 0;

}

Упрощенный вариант

#include <iostream>
using namespace std;
int main()
{
	int m,n; 
	cin>>n>>m;
	for(int i=1;i<m+1;i++)
	{ 
		for(int j=1;j<n+1;j++)
		{  
			if( ((i%2==0) && ((j+3)%4==0))||((i%2!=0) && ((j+1)%4==0)))
			{
				cout<< "1"; 
			}
			if ((j+3-2*(i%2))%4!=0)
			{
				cout<<((j+2*(i%2))%4==0?"2":"+");
			}
		}
		cout<<endl;
	}	
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

int m,n;

cin>>n>>m;

for(int i=1;i<m+1;i++)

{

for(int j=1;j<n+1;j++)

{

if( ((i%2==0) && ((j+3)%4==0))||((i%2!=0) && ((j+1)%4==0)))

{

cout<< "1";

}

if ((j+3-2*(i%2))%4!=0)

{

cout<<((j+2*(i%2))%4==0?"2":"+");

}

cout<<endl;

}

return 0;

}

Тесты

[latex]n[/latex]	[latex]m[/latex]	Выходные данные
1	1	+
7	7	+21++21 1++21++ +21++21 1++21++ +21++21 1++21++ +21++21
15	6	+21++21++21++21 1++21++21++21++ +21++21++21++21 1++21++21++21++ +21++21++21++21 1++21++21++21++
25	8	+21++21++21++21++21++21++ 1++21++21++21++21++21++21 +21++21++21++21++21++21++ 1++21++21++21++21++21++21 +21++21++21++21++21++21++ 1++21++21++21++21++21++21 +21++21++21++21++21++21++ 1++21++21++21++21++21++21

Решение

Для решения сначала нужно найти закономерность чередования символов в таблице. Пусть нумерация столбцов и строк будет начинаться с единицы, тогда, если строка [latex]i \vdots 2[/latex], то символы в ней чередуются по такому принципу: если результат от прибавления номера столбца к 1 кратен 4 ([latex] (j+1)\vdots 4 [/latex]), то в данной строке и столбце находится «1», если же результат от прибавления номера столбца к 2 кратен 4([latex] (j+2)\vdots 4 [/latex]), то в данной строке и столбце находится «2», если ни одно из этих условий не выполняется, значит на данном месте находится «+».

Если же строка [latex]i\vdots 2[/latex], то символы в ней чередуются по такому принципу: если результат от прибавления номера столбца к 3 кратен 4 ([latex] (j+3)\vdots 4[/latex]), то в данной строке и столбце находится «1», а если номер столбца кратен 4([latex] j\vdots 4 [/latex]), то в данной строке и столбце находится «2», если ни одно из этих условий не выполняется, значит на данном месте находится «+».

Ссылки

Код программы

Упрощенный код

Related Images:

MLoops 14

02/11/2015 by Александр Коломеец

MLoops14.

Постановка задачи

Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел [latex]n > 0[/latex] (количество столбцов) и [latex]m > 0[/latex] (количество строк).
Замечание 1. В некоторых задачах появляется дополнительный параметр [latex]k < n[/latex].
Замечание 2. Многоточие означает продолжение последовательности.

123...k123...k123...k123...k
++++++1++++++1++++++1++++++1
++++++2++++++2++++++2++++++2
++++++3++++++3++++++3++++++3
++++++.++++++.++++++.++++++.
++++++.++++++.++++++.++++++.
++++++.++++++.++++++.++++++.
++++++k++++++k++++++k++++++k
123...k123...k123...k123...k
++++++1++++++1++++++1++++++1
++++++2++++++2++++++2++++++2

123...k123...k123...k123...k

++++++1++++++1++++++1++++++1

++++++2++++++2++++++2++++++2

++++++3++++++3++++++3++++++3

++++++.++++++.++++++.++++++.

++++++k++++++k++++++k++++++k

123...k123...k123...k123...k

++++++1++++++1++++++1++++++1

++++++2++++++2++++++2++++++2

Алгоритм решения

Легко заметить, что строки с номерами [latex]1 + i \left( k + 1 \right), i \in \mathbb{N}_0[/latex] состоят из натуральных чисел от 1 до k. Также в таблице есть столбцы, совпадающие с первой строкой. Все остальные клетки заполнены символом «+».

Тесты

Входные данные

Выходные данные

[latex]n[/latex]

[latex]m[/latex]

[latex]k[/latex]

1
1

11111

121
+1+
+2+
121

121

+1+

+2+

121

1234123412
+++1+++1++
+++2+++2++
+++3+++3++
+++4+++4++
1234123412
+++1+++1++
+++2+++2++
+++3+++3++
+++4+++4++

1234123412

+++1+++1++

+++2+++2++

+++3+++3++

+++4+++4++

1234123412

+++1+++1++

+++2+++2++

+++3+++3++

+++4+++4++

123456789101112345678910111234567
++++++++++++1++++++++++++1+++++++
++++++++++++2++++++++++++2+++++++
++++++++++++3++++++++++++3+++++++
++++++++++++4++++++++++++4+++++++
++++++++++++5++++++++++++5+++++++
++++++++++++6++++++++++++6+++++++
++++++++++++7++++++++++++7+++++++
++++++++++++8++++++++++++8+++++++
++++++++++++9++++++++++++9+++++++
+++++++++++10+++++++++++10+++++++
+++++++++++11+++++++++++11+++++++
123456789101112345678910111234567
++++++++++++1++++++++++++1+++++++
++++++++++++2++++++++++++2+++++++
++++++++++++3++++++++++++3+++++++
++++++++++++4++++++++++++4+++++++
++++++++++++5++++++++++++5+++++++
++++++++++++6++++++++++++6+++++++
++++++++++++7++++++++++++7+++++++
++++++++++++8++++++++++++8+++++++
++++++++++++9++++++++++++9+++++++

123456789101112345678910111234567

++++++++++++1++++++++++++1+++++++

++++++++++++2++++++++++++2+++++++

++++++++++++3++++++++++++3+++++++

++++++++++++4++++++++++++4+++++++

++++++++++++5++++++++++++5+++++++

++++++++++++6++++++++++++6+++++++

++++++++++++7++++++++++++7+++++++

++++++++++++8++++++++++++8+++++++

++++++++++++9++++++++++++9+++++++

+++++++++++10+++++++++++10+++++++

+++++++++++11+++++++++++11+++++++

123456789101112345678910111234567

++++++++++++1++++++++++++1+++++++

++++++++++++2++++++++++++2+++++++

++++++++++++3++++++++++++3+++++++

++++++++++++4++++++++++++4+++++++

++++++++++++5++++++++++++5+++++++

++++++++++++6++++++++++++6+++++++

++++++++++++7++++++++++++7+++++++

++++++++++++8++++++++++++8+++++++

++++++++++++9++++++++++++9+++++++

Реализация

ideone: ссылка

#include <iostream>
using namespace std;

struct point {
	
	int abscissa, ordinate;
	
	point() {
	    abscissa = 0;
	    ordinate = 0;
	}
	
	point(int x, int y) {
		abscissa = x;
		ordinate = y;
	}
	
	void setX(int x) {
	    abscissa = x;
	}
	
	void setY(int y) {
	    ordinate = y;
	}
	
	int getX() {
		return abscissa;
	}
	
	int getY() {
		return ordinate;
	}
	
};

struct size {
	
	int width, height;
	
	size() {
	    width = 0;
	    height = 0;
	}
	
	size(int w, int h) {
		width = w;
		height = h;
	}
	
	int getWidth() {
		return width;
	}
	
	int getHeight() {
		return height;
	}
	
};

struct screen {
	
	size dimension; // dimension of the screen
	point cursor; // position of the cursor
	char **arr; // array that represents characters on the screen
	
	// allocates the memory for the array and sets its dimension
	screen(size d) {
		dimension = d;
		arr = new char*[dimension.getWidth()];
		for(int i = 0; i < dimension.getWidth(); i++) {
			arr[i] = new char[dimension.getHeight()];
		}
	}
	
	// deallocates the memory for the array
	void deallocate() {
		for(int i = 0; i < dimension.getWidth(); i++) {
    		delete[] arr[i];
		}
		delete[] arr;
	}
	
	// fills each cell by character c
	void fill(char c) {
	    for(int i = 0; i < dimension.getWidth(); i++) {
	        for(int j = 0; j < dimension.getHeight(); j++) {
	            arr[i][j] = c;
	        }
	    }
	}
	
	// print integer where cursor is located and returns position of the cursor
	point print(int i) {
	    return print(to_string(i));
	}
	
	// print string where cursor is located and returns position of the cursor
	point print(string s) {
		for(int i = 0; i < s.length(); i++) {
		    arr[cursor.getX()][cursor.getY()] = s.at(i);
		    moveCursor();
		}
		return cursor;
	}
	
	// moves cursor to the right
	void moveCursor() {
		cursor.setX(cursor.getX() + 1 == dimension.getWidth() ? 0 : cursor.getX() + 1);
		cursor.setY(cursor.getX() == 0 ? cursor.getY() + 1 : cursor.getY());
	}
	
	
	// moves cursor to the point p
	void moveCursor(point p) {
		cursor.setX(p.getX());
		cursor.setY(p.getY());
	}
	
	// returns char located at point p
	char getChar(point p) {
	    return arr[p.getX()][p.getY()];
	}
	
	// returns dimension of the screen
	size getSize() {
		return dimension;
	}
	
};

// returns length of integer
int length(int number) {
    int result = 1;
    while((number /= 10) > 0) {
        result++;
    }
    return result;
}

// returns sum of lengths of integers from from to to
int length(int from, int to) {
    int result = 0;
    for(int i = from; i <= to; i++) {
        result += length(i);
    }
    return result;
}

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    screen screen(size(length(1, k), k + 1));
    screen.fill('+');
    for(int i = 1; i <= k; i++) {
        screen.print(i);
    }
    for(int i = 1; i <= k; i++) {
    	screen.moveCursor(point(screen.getSize().getWidth() - length(i), i));
    	screen.print(i);
    }
    for(int row = 0; row < m; row++) {
        for(int col = 0; col < n; col++) {
            cout << screen.getChar(point(col % screen.getSize().getWidth(), row % screen.getSize().getHeight()));
        }
        cout << endl;
    }
    screen.deallocate();
	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

#include <iostream>

using namespace std;

struct point {

int abscissa, ordinate;

point() {

abscissa = 0;

ordinate = 0;

}

point(int x, int y) {

abscissa = x;

ordinate = y;

}

void setX(int x) {

abscissa = x;

}

void setY(int y) {

ordinate = y;

}

int getX() {

return abscissa;

}

int getY() {

return ordinate;

}

};

struct size {

int width, height;

size() {

width = 0;

height = 0;

}

size(int w, int h) {

width = w;

height = h;

}

int getWidth() {

return width;

}

int getHeight() {

return height;

}

};

struct screen {

size dimension; // dimension of the screen

point cursor; // position of the cursor

char **arr; // array that represents characters on the screen

// allocates the memory for the array and sets its dimension

screen(size d) {

dimension = d;

arr = new char*[dimension.getWidth()];

for(int i = 0; i < dimension.getWidth(); i++) {

arr[i] = new char[dimension.getHeight()];

}

// deallocates the memory for the array

void deallocate() {

for(int i = 0; i < dimension.getWidth(); i++) {

delete[] arr[i];

}

delete[] arr;

}

// fills each cell by character c

void fill(char c) {

for(int i = 0; i < dimension.getWidth(); i++) {

for(int j = 0; j < dimension.getHeight(); j++) {

arr[i][j] = c;

}

// print integer where cursor is located and returns position of the cursor

point print(int i) {

return print(to_string(i));

}

// print string where cursor is located and returns position of the cursor

point print(string s) {

for(int i = 0; i < s.length(); i++) {

arr[cursor.getX()][cursor.getY()] = s.at(i);

moveCursor();

}

return cursor;

}

// moves cursor to the right

void moveCursor() {

cursor.setX(cursor.getX() + 1 == dimension.getWidth() ? 0 : cursor.getX() + 1);

cursor.setY(cursor.getX() == 0 ? cursor.getY() + 1 : cursor.getY());

}

// moves cursor to the point p

void moveCursor(point p) {

cursor.setX(p.getX());

cursor.setY(p.getY());

}

// returns char located at point p

char getChar(point p) {

return arr[p.getX()][p.getY()];

}

// returns dimension of the screen

size getSize() {

return dimension;

}

};

// returns length of integer

int length(int number) {

int result = 1;

while((number /= 10) > 0) {

result++;

}

return result;

}

// returns sum of lengths of integers from from to to

int length(int from, int to) {

int result = 0;

for(int i = from; i <= to; i++) {

result += length(i);

}

return result;

}

int main() {

int n, m, k;

cin >> n >> m >> k;

screen screen(size(length(1, k), k + 1));

screen.fill('+');

for(int i = 1; i <= k; i++) {

screen.print(i);

}

for(int i = 1; i <= k; i++) {

screen.moveCursor(point(screen.getSize().getWidth() - length(i), i));

screen.print(i);

}

for(int row = 0; row < m; row++) {

for(int col = 0; col < n; col++) {

cout << screen.getChar(point(col % screen.getSize().getWidth(), row % screen.getSize().getHeight()));

}

cout << endl;

}

screen.deallocate();

return 0;

}

Related Images:

MLoops24

01/11/2015 by Таран Таня

0 10 1110 3110 132110 1113122110
311311222110 13211321322110 1113
122113121113222110 3113112221131
1123113322110 132113213221133112
132123223110 1113122113121113222

0 10 1110 3110 132110 1113122110

311311222110 13211321322110 1113

122113121113222110 3113112221131

1123113322110 132113213221133112

132123223110 1113122113121113222

Входные данные

Количество столбцов ([latex]n > 0[/latex]) и количество строк ([latex] m > 0[/latex]) в таблице.

Выходные данные

Построенная для данной последовательности таблица с соответствующим количеством столбцов и строк.

Тесты

[latex]n[/latex]

[latex]m[/latex]

Результат работы программы

0
10

0 10

1110

3110

1321

0 10

1110

3110

13211

0 111

0 10 1110 3110 132110 1113122110
311311222110 13211321322110 1113
122113121113222110 3113112221131
1123113322110 132113213221133112
132123223110 1113122113121113222

0 10 1110 3110 132110 1113122110

311311222110 13211321322110 1113

122113121113222110 3113112221131

1123113322110 132113213221133112

132123223110 1113122113121113222

0 10 1110 3110 132110 1113122110 311311222110 1321
1321322110 1113122113121113222110 3113112221131112
3113322110 132113213221133112132123222110 11131221
131211132221232112111312111213322110 3113112221131
1123113321112131221123113111231121123222110 132113
21322113311213212312311211131122211213211331121321
12211213322110 11131221131211132221232112111312111
21311121321123113213221121113122123211211131221222
1121123222110 311311222113111231133211121312211231
13111231121113311211131221121321131211132221123113

0 10 1110 3110 132110 1113122110 311311222110 1321

1321322110 1113122113121113222110 3113112221131112

3113322110 132113213221133112132123222110 11131221

131211132221232112111312111213322110 3113112221131

1123113321112131221123113111231121123222110 132113

21322113311213212312311211131122211213211331121321

12211213322110 11131221131211132221232112111312111

21311121321123113213221121113122123211211131221222

1121123222110 311311222113111231133211121312211231

13111231121113311211131221121321131211132221123113

0 10 1110

3110 13211

0 11131221

10 3113112

22110 1321

1321322110

1113122113

1211132221

Алгоритм

Для начала определим алгоритм построения предоставленной последовательности. Перед нами так называемая Look-and-Say sequence, начинающаяся с 0. Чтобы получить последующий член последовательности, нам потребуется обратиться к предыдущему и выполнить следующее:

Посчитать количество одинаковых подряд идущих цифр и записать его.
Записать саму эту цифру.

Разберем на примере:

Первый член последовательности — [latex]0[/latex] («Основание» последовательности);
Второй член последовательности — [latex]10[/latex] («Вижу» один ноль);
Третий член последовательности — [latex]1110[/latex] («Вижу» одну единицу и один ноль);
Четвертый член последовательности — [latex]3110[/latex] («Вижу» три единицы и один ноль).
…

Реализуем данное построение на практике. Создадим два вектора для хранения предыдущего и текущего члена последовательности (previousTerm и currentTerm соответственно), а также переменные для хранения номера элемента с которым ведется сравнение (изначально start [latex] = 0[/latex]) и счетчик количества совпадающих элементов (изначально quantity [latex] = 0[/latex]). Запустим цикл от первого до последнего элемента массива previousTerm и выполним ряд действий, а именно:

Пока последующие элементы совпадают с текущим сравниваемым, инкрементируем счетчик.
Как только находиться элемент не совпадающий с текущим сравниваемым, выполняем вывод количества вхождений и само число, также записываем данные значения в вектор currentTerm. Переходим к следующей цифре для сравнения и присваиваем счетчику значение [latex]1[/latex].
Отдельно выполняем предыдущий пункт для последней последовательности цифр или одной цифры, так как нет возможности сравнения с последующими.
Как только один член последовательности полностью построен, обнуляем значения индекса сравниваемой цифры и счетчика. Также очищаем вектотр previousTerm и передаем ему значения вектора currentTerm, очищаем вектор currentTerm.

Теперь наша задача состоит в том, чтобы выполнить правильный вывод таблицы. Основную работу по построению таблицы будет выполнять метод ToPrint, принимающий как параметры заданное количество столбцов, строк, номер текущего столбца, текущей строки и цифру которую нужно вывести на печать (или пробел).
Рассмотрим детали его работы:

При запуске метода сразу же увеличиваем текущий номер столбца, в который записывается символ, на [latex]1[/latex].
Далее проверяем не превышает ли номер текущего столбца возможный. Если это так, то выполняем перевод курсора на новую строку, присваиваем текущему столбцу значение [latex]1[/latex] и инкрементируем значение номера текущей строки.
Если количество строк превышает заданное, заканчиваем работу программы.
В противном же случае выполняем печать символа, если это не пробел в начале строки (если это все же пробел в начале строки, то ничего не печатаем и уменьшаем значение текущего столбца для печати). Для упрощения вывода пробел передается в метод по его коду в таблице ASCII — [latex]32[/latex]. Мы имеем полное право использовать число [latex]32[/latex] без угрозы ошибки, так как передавать мы будем только цифры [latex]0, 1, 2, 3[/latex].

Таким образом общий алгоритм работы программы можем сформулировать так:

Считываем заданное количество столбцов ([latex]n > 0[/latex]) и количество строк ([latex] m > 0[/latex]).
Для последующей работы объявляем переменные хранящие значения номера текущего столбца и строки (currentNumberColumn и currentNumberRow соответственно), два вектора для хранения предыдущего и текущего члена последовательности (previousTerm и currentTerm соответственно), а также переменные для хранения номера элемента с которым ведется сравнение (start) и счетчик количества совпадающих элементов (quantity) .
Отправляем в вектор previousTerm значение «основания» последовательности — [latex]0[/latex].
Выводим первый член последовательности и пробел после него (если потребуется).
Далее запускаем бесконечный цикл, так как окончание работы программы предусмотрено в методе ToPrint.
И выполняем последовательное построение членов последовательности (описано выше) и тут же вывод, пока количество строк не превышает заданное.

Код программы:

#include <iostream>
#include <vector>
using namespace std;

void ToPrint(int n, int m, int *currentNumberColumn, int *currentNumberRow, int symbolToPrint) {
	(*currentNumberColumn)++; // Инкрементируем значение номера столбца, так как есть символ на печать
	if (*currentNumberColumn > n) {
		cout << endl; // Переходим на новую строку
	  	(*currentNumberRow)++;
	  	*currentNumberColumn = 1; 
	} // Если следует выполнить переход на следующую строку, выполняем этот переход по всем индексам
	if (*currentNumberRow > m)
	    exit(0); // Заканчиваем работу программы, как только количество строк превышает заданное
	else if (symbolToPrint == 32 && *currentNumberColumn == 1) // В таблице ASCII 32 - пробел
	    (*currentNumberColumn)--; // Возвращаем предыдущее значение номера столбца, так как ничего не было напечатано
    else if (symbolToPrint == 32)
        cout << char(symbolToPrint); // Выводим пробел, если это не начало строки
    else
      	cout << symbolToPrint;
}

int main() {
	int n, m; // Количество столбцов и строк соответственно
	cin >> n >> m;
	int start = 0; // Индекс элемента текущей цифры с которой ведется сравнение
    int quantity = 0; // Количество идущих подряд одинаковых элементов в данном члене
    int currentNumberRow = 1; // Номер текущей строки, в которой будет записан символ
    int currentNumberColumn = 0; // Номер текущего столбца, в который будет записан символ
    vector <short> currentTerm; // Вектор, хранящий значение текущего члена последовательности
    vector <short> previousTerm; // Вектор, хранящий значение предыдущего члена последовательности
	previousTerm.push_back(0); // Записываем в вектор предыдущего члена значение первого члена последовательности
    ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 0); // Выводим первый член последовательности
    ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 32); // Выводим пробел после него (если он не понадобится его уберет метод ToPrint)
    while (true) {
           for (int i = 0; i < previousTerm.size(); i++) { 
    	        if (previousTerm[i] == previousTerm[start]) 
    	 	        quantity++; // Считаем количество идущих подряд одинаковых цифр
    	        else {
    		      	currentTerm.push_back(quantity); // Записываем в вектор количество текущих цифр
    	          	currentTerm.push_back(previousTerm[start]); // Записываем саму цифру
    	          	ToPrint(n, m, &currentNumberColumn, &currentNumberRow, quantity);
    	          	ToPrint(n, m, &currentNumberColumn, &currentNumberRow, previousTerm[start]); // Печатаем полученные данные
    	          	start += quantity; // Переходим к следующей цифре для сравнения
    	          	quantity = 1; // Присваиваем количеству одинаковых идущих подряд цифр 1, так как мы перешли к следующей цифре
    	        } // Если значение текущей цифры не совпадает с предыдущим, выполняем вывод и заполнение вектора следующего члена
    	        if (i == (previousTerm.size() - 1)) {
    	            currentTerm.push_back(quantity); 
    	            currentTerm.push_back(previousTerm[start]);
    	            ToPrint(n, m, &currentNumberColumn, &currentNumberRow, quantity);
    	            ToPrint(n, m, &currentNumberColumn, &currentNumberRow, previousTerm[start]);
    	        } // Отдельный вывод для последнего элемента данного члена
           } // Цикл для прохода по всем цифрам предыдущего члена последовательности
           start = 0;      
           quantity = 0; // Обнуляем все параметры для подсчета, так как дальше будем работать со следующим членом последовательности
           ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 32); // Печатаем пробел после текущего члена последовательности
           previousTerm.clear(); 
           previousTerm = currentTerm; // Записываем в вектор предыдущего члена текущий построенный член последовательности
           currentTerm.clear();
    } // Бесконечный цикл, так как условие окончание работы программы задано в методе печати
}

#include <iostream>

#include <vector>

using namespace std;

void ToPrint(int n, int m, int *currentNumberColumn, int *currentNumberRow, int symbolToPrint) {

(*currentNumberColumn)++; // Инкрементируем значение номера столбца, так как есть символ на печать

if (*currentNumberColumn > n) {

cout << endl; // Переходим на новую строку

(*currentNumberRow)++;

*currentNumberColumn = 1;

} // Если следует выполнить переход на следующую строку, выполняем этот переход по всем индексам

if (*currentNumberRow > m)

exit(0); // Заканчиваем работу программы, как только количество строк превышает заданное

else if (symbolToPrint == 32 && *currentNumberColumn == 1) // В таблице ASCII 32 - пробел

(*currentNumberColumn)--; // Возвращаем предыдущее значение номера столбца, так как ничего не было напечатано

else if (symbolToPrint == 32)

cout << char(symbolToPrint); // Выводим пробел, если это не начало строки

else

cout << symbolToPrint;

}

int main() {

int n, m; // Количество столбцов и строк соответственно

cin >> n >> m;

int start = 0; // Индекс элемента текущей цифры с которой ведется сравнение

int quantity = 0; // Количество идущих подряд одинаковых элементов в данном члене

int currentNumberRow = 1; // Номер текущей строки, в которой будет записан символ

int currentNumberColumn = 0; // Номер текущего столбца, в который будет записан символ

vector <short> currentTerm; // Вектор, хранящий значение текущего члена последовательности

vector <short> previousTerm; // Вектор, хранящий значение предыдущего члена последовательности

previousTerm.push_back(0); // Записываем в вектор предыдущего члена значение первого члена последовательности

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 0); // Выводим первый член последовательности

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 32); // Выводим пробел после него (если он не понадобится его уберет метод ToPrint)

while (true) {

for (int i = 0; i < previousTerm.size(); i++) {

if (previousTerm[i] == previousTerm[start])

quantity++; // Считаем количество идущих подряд одинаковых цифр

else {

currentTerm.push_back(quantity); // Записываем в вектор количество текущих цифр

currentTerm.push_back(previousTerm[start]); // Записываем саму цифру

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, quantity);

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, previousTerm[start]); // Печатаем полученные данные

start += quantity; // Переходим к следующей цифре для сравнения

quantity = 1; // Присваиваем количеству одинаковых идущих подряд цифр 1, так как мы перешли к следующей цифре

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

if (i == (previousTerm.size() - 1)) {

currentTerm.push_back(quantity);

currentTerm.push_back(previousTerm[start]);

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, quantity);

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, previousTerm[start]);

} // Отдельный вывод для последнего элемента данного члена

} // Цикл для прохода по всем цифрам предыдущего члена последовательности

start = 0;

quantity = 0; // Обнуляем все параметры для подсчета, так как дальше будем работать со следующим членом последовательности

ToPrint(n, m, &currentNumberColumn, &currentNumberRow, 32); // Печатаем пробел после текущего члена последовательности

previousTerm.clear();

previousTerm = currentTerm; // Записываем в вектор предыдущего члена текущий построенный член последовательности

currentTerm.clear();

} // Бесконечный цикл, так как условие окончание работы программы задано в методе печати

}

Ссылки

Код программы
Дополнительная информация о «Look-and-Say» sequence:
Источник 1; Источник 2; Источник 3; Источник 4;

Related Images:

MLoops2

31/10/2015 by Алина Гончарова

Задача

Найти закономерность и написать программу, которая выводит аналогичную таблицу для любых чисел $n > 0$ (количество столбцов) и $m > 0$ (количество строк).

-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*

Решение

Для того, чтобы решить поставленную задачу, нужно сначала понять закономерность чередования символов — и * в таблице. Каждый символ имеет свой номер строки([latex]m[/latex]) и столбца([latex]n[/latex]), а чтобы определить их номера зададим счетчики [latex]i[/latex] и [latex]j[/latex]. Задача состоит из того, что нужно определить закономерность появления символа [latex]-[/latex], в остальных случаях нужно выводить символ [latex]*[/latex]. Символ [latex]-[/latex] чередуется с символом [latex]*[/latex], и поэтому можно увидеть, что этот символ [latex]-[/latex] ставится на место, при котором сумма номеров столбцов и строк делится нацело на 2. Решить данную задачу можно с помощью тернарной операции.

Код

#include <iostream>
using namespace std;

int main() {
	int m, n;
	cin >> m >> n;
	for (int i=1; i<n; i++){
		for (int j=1; j<m; j++){
			cout << ((i+j)%2==0? "-":"*");
		}
		cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int m, n;

cin >> m >> n;

for (int i=1; i<n; i++){

for (int j=1; j<m; j++){

cout << ((i+j)%2==0? "-":"*");

}

cout << endl;

}

return 0;

}

Тесты

Входные данные	10 10	8 5	25 8
Выходные данные	-----* ----- ----- ----- ----- ----- ----- ----- ----- ----*-	---- ---- ---- ---- ----	------------- ------------* ------------- ------------* ------------- ------------* ------------- ------------*

Задача взята отсюда.

Код программы на ideone.com.

Related Images:

Mloops 5

30/10/2015 by Антон Локтев

Условие задачи

Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел [latex] n>0 [/latex] (количество столбцов) и [latex] m>0 [/latex] (количество строк): +++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*++ .

Задача находится здесь.

Тесты

№	n	m	Таблица
1	25	8	+++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ ++++++++++++++++++++* +++++++++++++++++++++ +++++++++++++++++++++
2	6	6	+++++* +++++ +++++ +++++ +++++ *+++++
3	2	5	++ ++ ++ ++ +*

Алгоритм решения

Таблица, которую необходимо вывести на экран представляет собой определённую последовательность. Каждый символ таблицы имеет номера столбца и строки (нумерация от 0 до n или m не включительно). Для этого задаём счётчики [latex] i [/latex] и [latex] j [/latex] . Наша задача — определить закономерность появления символа [latex] \ast [/latex] в данной таблице, поскольку в иных случаях необходимо вывести символ [latex] + [/latex]. В первой строке «звёздочка» встречается в данной таблице в [latex] 6,12,18,24[/latex] столбцах. Во второй строке «звёздочка» находится в [latex] 5,11,17,23[/latex] столбцах. В последующих строках ситуация аналогичная. Можно заметить, что символ [latex] \ast [/latex] стоит на позициях, при которых сумма номера строки и номера столбца делится нацело на 6. Проверяем это условие с помощью тернарной операции:

cout << ((i+j-5)%6== 0? "*":"+");

1	cout << ((i+j-5)%6== 0? "*":"+");

от суммы номеров столбца и строки отнимаем число [latex] 5 [/latex], поскольку нам необходимо, чтобы первыми пятью символами последовательности были плюсы.

Код программы

#include <iostream>
using namespace std;

int main() {
	int n,m;
	cin >> n >> m;
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			cout << ((i+j-5)%6== 0? "*":"+");
		}
	cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n,m;

cin >> n >> m;

for(int i=0;i<m;i++){

for(int j=0;j<n;j++){

cout << ((i+j-5)%6== 0? "*":"+");

}

cout << endl;

}

return 0;

}

Ссылка на рабочий код программы находится здесь.

	1	2	3	4	5	6	7	…	n
1	1	2	3	1	2	3	1	…	…
2	2	3	1	2	3	1	2	…	…
3	1	3	2	1	3	2	1	…	…
4	1	2	3	1	2	3	1	…	…
5	2	3	1	2	3	1	2	…	…
6	1	3	2	1	3	2	1	…	…
7	1	2	3	1	2	3	1	…	…
…	…	…	…	…	…	…	…	…	…
m	…	…	…	…	…	…	…	…	…

	1	2	3	4	5	6	7	…	n
1	1	2	3	1	2	3	1	…	…
2	2	3	1	2	3	1	2	…	…
3	1	3	2	1	3	2	1	…	…
4	1	2	3	1	2	3	1	…	…
5	2	3	1	2	3	1	2	…	…
6	1	3	2	1	3	2	1	…	…
7	1	2	3	1	2	3	1	…	…
…	…	…	…	…	…	…	…	…	…
m	…	…	…	…	…	…	…	…	…

	1	2	3	4	5	6	7	…	n
1	1	2	3	1	2	3	1	…	…
2	2	3	1	2	3	1	2	…	…
3	1	3	2	1	3	2	1	…	…
4	1	2	3	1	2	3	1	…	…
5	2	3	1	2	3	1	2	…	…
6	1	3	2	1	3	2	1	…	…
7	1	2	3	1	2	3	1	…	…
…	…	…	…	…	…	…	…	…	…
m	…	…	…	…	…	…	…	…	…