Главная страница

Анализ программы с циклами и условными операторами. Анализ программы с циклами и условными операторами Алгоритмы,печатающие числа,наибольшее значение видимого числа


Скачать 52.61 Kb.
НазваниеАнализ программы с циклами и условными операторами Алгоритмы,печатающие числа,наибольшее значение видимого числа
Дата20.06.2022
Размер52.61 Kb.
Формат файлаdocx
Имя файлаАнализ программы с циклами и условными операторами.docx
ТипАнализ
#605120

Анализ программы с циклами и условными операторами 

Алгоритмы,печатающие числа,наибольшее значение видимого числа 

1. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 7.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:= L + 1;

if x mod 2 = 0 then

M:= M + (x mod 10) div 2;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

if x mod 2 = 0 then

M:= M + (x mod 10) div 2;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x.

Усло­вие x mod 2 = 0 озна­ча­ет сле­ду­ю­щее: чтобы M уве­ли­чи­лось, число x долж­но быть чётным.

Пред­по­ло­жим, ис­ход­ное x нечётное, тогда на пер­вом шаге M = 0.

Если на вто­ром шаге x также нечётное (вто­рая цифра ис­ход­но­го числа нечётная), то M = 0, причём каким бы ни было зна­че­ние x на тре­тьем шаге, мы не смо­жем по­лу­чить M = 7, по­сколь­ку оста­ток от де­ле­ния чётного числа на 10 не пре­вос­хо­дит 8, а 8 / 2 = 4, сле­до­ва­тель­но, вто­рая цифра ис­ход­но­го x чётная.

Тогда пер­вая цифра может при­ни­мать зна­че­ния 2, 4, 6, 8, но мы ищем наи­боль­шее x, по­это­му сде­ла­ем первую цифру, рав­ной 9, тогда наше пред­по­ло­же­ние не удо­вле­тво­ря­ет усло­вию за­да­чи, и по­след­няя цифра ис­ход­но­го числа обя­за­на быть чётной, т.е. ис­ход­ное x чётно.

7 = 4 + 3, чему со­от­вет­ству­ют цифры 8 и 6. Те­перь, рас­по­ла­гая цифры по убы­ва­нию, на­хо­дим наи­боль­шее воз­мож­ное xx = 986.

Ответ: 986.

 

2. Ниже на пяти язы­ках про­грам­ми­ро­ва­ния за­пи­сан ал­го­ритм. По­лу­чив на вход число x, этот ал­го­ритм пе­ча­та­ет числа: a и b. Ука­жи­те наи­боль­шее че­ты­рех­знач­ное число x, при вводе ко­то­ро­го ал­го­ритм пе­ча­та­ет сна­ча­ла 5, а потом 7.

 

Бей­сик

Python

DIM X, Y, A, B AS INTEGER

A = 10

B = 0

INPUT X

WHILE X > 0

Y = X MOD 10

X = X \ 10

IF Y < A THEN A = Y

IF Y > B THEN B = Y

WEND

PRINT A

PRINT B

a = 10

b = 0

x = int(input())

while x > 0:

y = x % 10

x = x // 10

if y < a:

a = y

if y > b:

b = y

print(a)

print(b)

Пас­каль

Ал­го­рит­ми­че­ский язык

var x, y, a, b: integer;

begin

a := 10;

b := 0;

readln(x);

while x > 0 do

begin

y := x mod 10;

x := x div 10

if y < a then

a := y;

if y > b then

b := y;

end;

writeln(a);

writeln(b)

end.

алг

нач

цел x, y, a, b

a := 10

b := 0

ввод x

нц пока x > 0

y := mod(x, 10)

x := div(x, 10)

если y < a

то a := y

все

если y > b

то b := y

все

кц

вывод a, нс, b

кон

Си

#include

void main()

{

int x, y, a, b;

a = 10;

b = 0;

scanf("%d", &x);

while (x > 0)

{

y = x % 10;

x = x / 10;

if (y < a)

a = y;

if (y > b)

b = y;

}

printf("%d\n%d\n", a, b);

}

 

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

y := x mod 10;

x:= x div 10;

...

end;

Т. к. опе­ра­тор div воз­вра­ща­ет целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры. Сле­до­ва­тель­но, цикл вы­пол­нит­ся че­ты­ре раза.

В пе­ре­мен­ную a за­пи­сы­ва­ет­ся оста­ток от де­ле­ния числа x на 10 при усло­вии, что этот оста­ток мень­ше числа уже за­пи­сан­но­го в пе­ре­мен­ной a. В пе­ре­мен­ную b за­пи­сы­ва­ет­ся оста­ток от де­ле­ния числа x на 10 при усло­вии, что этот оста­ток боль­ше числа уже за­пи­сан­но­го в пе­ре­мен­ной b. Таким об­ра­зом, в пе­ре­мен­ную a за­пи­сы­ва­ет­ся наи­боль­шая цифра числа x, а в пе­ре­мен­ную b — наи­мень­шая. Зна­чит, наи­боль­шее число, удо­вле­тво­ря­ю­щее усло­вию задчи — 7775.

Ответ: 7775.

 

 

3. Ниже на пяти язы­ках за­пи­сан ал­го­ритм. По­лу­чив на вход число x, этот ал­го­ритм пе­ча­та­ет два числа a и b. Ука­жи­те наи­мень­шее из таких чисел x, при вводе ко­то­ро­го ал­го­ритм пе­ча­та­ет сна­ча­ла 2, а потом 7.

 

Бей­сик

Python

DIM X, A, B AS INTEGER

INPUT X

A = 0: B = 1

WHILE X > 0

A = A+1

B = B * (X MOD 100)

X = X\100

WEND

PRINT A

PRINT B

x = int(input())

a, b = 0, 1

while x > 0:

a = a + 1

b = b * x%100

x = x//100

print(a)

print(b)

Пас­каль

Ал­го­рит­ми­че­ский язык

var x, a, b: integer;

begin

readln(x);

a := 0; b := 1;

while x > 0 do

begin

a := a+1;

b := b*(x mod 100);

x := x div 100;

end;

writeln(a); write(b);

end.

алг

нач

цел x, a, b

ввод x

a:=0; b:=1

нц пока x > 0

a := a+1

b := b*mod(x,100)

x := div(x,100)

кц

вывод a, нс, b

кон

Си

#include

void main()

{

int x, a, b;

scanf("%d", &x);

a = 0; b = 1;

while (x > 0) {

a = a+1;

b = b * (x%100);

x = x/100;

}

printf("%d\n%d", a, b);

}

 

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 100;

end;

Т. к. опе­ра­тор div воз­вра­ща­ет целую часть от де­ле­ния, то при де­ле­нии на 100 это рав­но­силь­но от­се­че­нию по­след­них двух цифр.

На каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся две по­след­них цифры до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0. Для того, чтобы a стало рав­ным 2, x долж­но быть трёхзнач­ным или четырёхзнач­ным.

Те­перь рас­смот­рим из­ме­не­ние b:

while x>0 do begin

b:=b*(x mod 100);

end;

Опе­ра­тор mod воз­вра­ща­ет оста­ток от де­ле­ния, при де­ле­нии на 100 это по­след­ние две цифры x. Сле­до­ва­тель­но, по­след­няя цифра числа долж­на быть 7, а во вто­ром раз­ря­де дол­жен быть либо ноль либо еди­ни­ца, а в пер­вом — еди­ни­ца. Ис­ко­мое число — 107.

Ответ: 107.

 

4. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 10.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:=L+1;

if M < x then begin

M:= (x mod 10) * 2;

end;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

 

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

if M < x then begin

M:= (x mod 10) * 2;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x.

Чтобы M при­ня­ло зна­че­ние M = 10 в числе x долж­но при­сут­ство­вать цифра 5.

Т. к. мы ищем наи­боль­шее x, сде­ла­ем первую цифру ис­ход­но­го числа, рав­ной 9, при этом если вто­рая цифра 5, тогда на тре­тьем шаге усло­вие M < x не вы­пол­ня­ет­ся (10>9), и на экра­не мы по­лу­чим нуж­ное нам число.

Оста­лось опре­де­лить по­след­нюю цифру ис­ход­но­го числа x. После пер­во­го шага x = 95, но мак­си­маль­ный оста­ток от де­ле­ния на 10 равен 9, сле­до­ва­тель­но, M после пер­во­го шага не может пре­вы­сить 9 * 2 = 18, а 18 < 95, зна­чит будет вы­пол­нять­ся нуж­ный нам вто­рой шаг.

Ис­ко­мое число 959.

Ответ: 959.

 

5. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, a и b. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 0.

var x, a, b : integer;

begin

readln(x);

a := 0; b := 1;

while x > 0 do begin

a := a + 1;

b := b * (x mod 10);

x := x div 10;

end;

writeln(a); write(b);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число a столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние a сов­па­да­ет с чис­лом цифр в x. Для того, чтобы a стало a = 3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния b:

while x>0 do begin

b:=b*(x mod 10);

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x; сле­до­ва­тель­но, число b по­лу­ча­ет­ся про­из­ве­де­ни­ем цифр числа x.

Если b = x(1) * x(2) * x(3) = 0, где число в скоб­ках озна­ча­ет номер цифры в числе x, то хотя бы один из мно­жи­те­лей равен нулю, но это озна­ча­ет, что на каком-то шаге x на­це­ло де­лит­ся на 10. Если это про­ис­хо­дит на пер­вом шаге, тоx(1) и x(2) могут быть лю­бы­ми од­но­знач­ны­ми чис­ла­ми. Т. к. мы хотим по­лу­чить наи­боль­шее число, то x = 990.

Ответ: 990.

 

6. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 7.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:=L+1;

if M < x then begin

M:=x mod 10;

end;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L = 3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния М:

if M < x then begin

M:=x mod 10;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра.

 

После пер­во­го шага M может быть любым од­но­знач­ным чис­лом, т. к. на вто­ром шаге число x дву­знач­ное, а од­но­знач­ное число все­гда мень­ше лю­бо­го дву­знач­но­го, а зна­чит, M может при­об­ре­сти ин­те­ре­су­ю­щее нас зна­че­ние 7. По­это­му тре­тья цифра числа x x(3) = 9.

Вто­рая цифра уже не может быть любой, так как при x(2) > x(1) зна­че­ние пе­ре­мен­ной M уже не по­ме­ня­ет­ся на тре­тьем шаге. По­это­му x(2) не пре­вы­ша­ет 7. По­сколь­ку мы хотим по­лу­чить наи­боль­шее число x, мы берём x(1) = 7. Оста­лось верно опре­де­лить x(2).

Число x до­стиг­нет мак­си­му­ма при x(2)=7, при этом на тре­тьем шаге пе­ре­мен­ная M уже не из­ме­нит­ся, по­то­му что на­ру­ше­но усло­вие M < x (7 = 7).

Окон­ча­тель­но по­лу­ча­ем: x = 779.

Ответ: 779.

 

7а числа, a и b. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 7.

var x, a, b : integer;

begin

readln(x);

a := 0; b := 1;

while x > 0 do begin

a := a + 1;

b := b * (x mod 10);

x := x div 10;

end;

writeln(a); write(b);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число a столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние a сов­па­да­ет с чис­лом цифр в x. Для того, чтобы a стало a = 3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния b:

while x>0 do begin

b:=b*(x mod 10);

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x; сле­до­ва­тель­но, число b по­лу­ча­ет­ся про­из­ве­де­ни­ем цифр числа x.

b = x(1) * x(2) * x(3) = 7, где число в скоб­ках озна­ча­ет номер цифры в числе x. Число 7 про­стое, по­это­му 7 = 7 * 1 * 1. Со­став­ля­ем мак­си­маль­ное число: 711

Ответ: 711.

 

8. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 7.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:= L + 1;

if x mod 2 = 0 then

M:= M + (x mod 10) div 2;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

На­пом­ним:

X div a - целая часть от де­ле­ния числа X на a,

X mod a - оста­ток от де­ле­ния числа X на a.

Пока X боль­ше нуля вы­пол­ня­ет­ся уве­ли­че­ние L на еди­ни­цу. Если X чет­ное (оста­ток от де­ле­ния на 2 равен 0), то M уве­ли­чи­ва­ет­ся на по­ло­ви­ну цифры, сто­я­щей в еди­ни­цах числа X, X со­кра­ща­ет­ся на один раз­ряд спра­ва.

L - ко­ли­че­ство цифр в числе X,

M - сумма, ко­то­рая на­хо­дит­ся таким об­ра­зом:

L=3, сле­до­ва­тель­но X = a * 100 + b * 10 + c,

M = (a + b + c) / 2, если все числа четны. Если хоть одно из чисел не­чет­ное, то сумма будет со­сто­ять из 2-х цифр, так как при М = 7, a + b + c = 14, т. е. нужны как ми­ни­мум 2 цифры чтобы на­брать дан­ную сумму.

Чтобы по­до­брать мак­си­маль­ное число при­мем, что a = 9, b + c = 14, и обе цифры чет­ные, так что b = 8 — наи­боль­шая чет­ная цифра, c = 6.

Пра­виль­ный ответ: 986.

 

9. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 7.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:= L + 1;

M:= M + x mod 10;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

M:= M + x mod 10;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x. Таким об­ра­зом М есть сумма цифр числа x.

Пред­ста­вим 7 в виде суммы: 7 = 7 + 0 + 0 = 1 + 6 + 0 = 1 + 5 + 1 = 1 + 4 + 2 = 1 + 3 + 3 и т. д. Видно, что мы не можем ис­поль­зо­вать цифры боль­ше 7, по­это­му для по­лу­че­ния мак­си­маль­но­го числа ис­поль­зу­ем пред­став­ле­ние 7 = 7 + 0 + 0.

Из этих цифр со­ста­вим наи­боль­шее число: 700.

Ответ: 700.

 

10. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­боль­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 10.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:=L+1;

if (M < x) and (x mod 2 = 1) then begin

M:= (x mod 10) * 2;

end;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

if (M < x) and (x mod 2 = 1) then begin

M:= (x mod 10) * 2;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x.

Чтобы по­лу­чить M = 10, в числе x долж­на быть цифра 5. Это можно сде­лать уже на пер­вом шаге. На вто­ром шаге число x уже дву­знач­ное, и по­сколь­ку мы ищем мак­си­маль­ное число, то усло­вие M < x будет вы­пол­нять­ся. Од­на­ко, мы можем на­ру­шить усло­вие нечётно­сти (x mod 2 = 1), если сде­ла­ем вто­рую цифру чётной, тогда M далее не из­ме­нит­ся, по­то­му что на тре­тьем шаге оста­нет­ся толь­ко пер­вая цифра числа x, а любое од­но­знач­ное число мень­ше любго дву­знач­но­го, вклю­чая 10.

По­это­му пер­вая цифра может быть любой, по­ло­жим её рав­ной 9, вто­рая цифра долж­на быть чётной — вы­би­ра­ем наи­боль­шую, т. е. 8. В ре­зуль­та­те по­лу­ча­ем число 985.

Ответ: 985.

Алгоритмы,печатающие числа,наименьшее значение видимого числа 

1. Ниже на пяти язы­ках за­пи­сан ал­го­ритм. По­лу­чив на вход число x, этот ал­го­ритм пе­ча­та­ет два числа a и b. Ука­жи­те наи­мень­шее из таких чисел x, при вводе ко­то­ро­го ал­го­ритм пе­ча­та­ет сна­ча­ла 2, а потом 13.

 

Бей­сик

Python

DIM X, A, B AS INTEGER

INPUT X

A = 0: B = 0

WHILE X > 0

A = A+1

B = B + (X MOD 100)

X = X\100

WEND

PRINT A

PRINT B

x = int(input())

a, b = 0, 0

while x > 0:

a = a + 1

b = b + x%100

x = x//100

print(a)

print(b)

Пас­каль

Ал­го­рит­ми­че­ский язык

var x, a, b: integer;

begin

readln(x);

a := 0; b := 0;

while x > 0 do

begin

a := a+1;

b := b+(x mod 100);

x := x div 100;

end;

writeln(a); write(b);

end.

алг

нач

цел x, a, b

ввод x

a:=0; b:=0

нц пока x > 0

a := a+1

b := b+mod(x,100)

x := div(x,100)

кц

вывод a, нс, b

кон

Си

#include

void main()

{

int x, a, b;

scanf("%d", &x);

a = 0; b = 0;

while (x > 0) {

a = a+1;

b = b + (x%100);

x = x/100;

}

printf("%d\n%d", a, b);

}

 

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 100;

end;

Т. к. опе­ра­тор div воз­вра­ща­ет целую часть от де­ле­ния, то при де­ле­нии на 100 это рав­но­силь­но от­се­че­нию по­след­них двух цифр.

На каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся две по­след­них цифры до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0. Для того, чтобы a стало рав­ным 2, x долж­но быть трёхзнач­ным или четырёхзнач­ным.

Те­перь рас­смот­рим из­ме­не­ние b:

while x>0 do begin

b:=b+(x mod 100);

end;

Опе­ра­тор mod воз­вра­ща­ет оста­ток от де­ле­ния, при де­ле­нии на 100 это по­след­ние две цифры x. Разобьём 13 на два сла­га­е­мых так, чтобы можно было со­ста­вить трёхзнач­ное число: 13 = 1 +12. Ис­ко­мое число — 112.

Ответ: 112.

 

2. Ниже на пяти язы­ках про­грам­ми­ро­ва­ния за­пи­сан ал­го­ритм. По­лу­чив на вход число x, этот ал­го­ритм пе­ча­та­ет числа: a и b. Ука­жи­те наи­мень­шее по­ло­жи­тель­ное пя­ти­знач­ное число x, при вводе ко­то­ро­го ал­го­ритм пе­ча­та­ет сна­ча­ла 6, а потом 3.

 

Бей­сик

Python

DIM X, Y, A, B AS INTEGER

A = 0

B = 10

INPUT X

WHILE X > 0

Y = X MOD 10

X = X \ 10

IF Y > A THEN A = Y

IF Y < B THEN B = Y

WEND

PRINT A

PRINT B

a = 0

b = 10

x = int(input())

while x > 0:

y = x % 10

x = x // 10

if y > a:

a = y

if y < b:

b = y

print(a)

print(b)

Пас­каль

Ал­го­рит­ми­че­ский язык

var x, y, a, b: integer;

begin

a := 0;

b := 10;

readln(x);

while x > 0 do

begin

y := x mod 10;

x := x div 10

if y > a then

a := y;

if y < b then

b := y;

end;

writeln(a);

writeln(b)

end.

алг

нач

цел x, y, a, b

a := 0

b := 10

ввод x

нц пока x > 0

y := mod(x, 10)

x := div(x, 10)

если y > a

то a := y

все

если y < b

то b := y

все

кц

вывод a, нс, b

кон

Си

#include

int main()

{

int x, y, a, b;

a = 0;

b = 10;

scanf("%d", &x);

while (x > 0)

{

y = x % 10;

x = x / 10;

if (y > a)

a = y;

if (y < b)

b = y;

}

printf("%d\n%d\n", a, b);

}

 

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

y := x mod 10;

x:= x div 10;

...

end;

Т. к. опе­ра­тор div воз­вра­ща­ет целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры. Сле­до­ва­тель­но, цикл вы­пол­нить­ся пять раз.

В пе­ре­мен­ную a за­пи­сы­ва­ет­ся оста­ток от де­ле­ния числа x на 10 при усло­вии, что этот оста­ток боль­ше числа уже за­пи­сан­но­го в пе­ре­мен­ной a. В пе­ре­мен­ную b за­пи­сы­ва­ет­ся оста­ток от де­ле­ния числа числа x на 10 при усло­вии, что этот оста­ток мень­ше числа уже за­пи­сан­но­го в пе­ре­мен­ной b. Таким об­ра­зом, в пе­ре­мен­ную a за­пи­сы­ва­ет­ся наи­боль­шая цифра числа x, а в пе­ре­мен­ную b — наи­мень­шая. Зна­чит, наи­мень­шее число, удо­вле­тво­ря­ю­щее усло­вию задчи — 33336.

Ответ: 33336.

 

3. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­мень­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 0.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:= L + 1;

if x mod 2 = 0 then

M:= M + x mod 10;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

if x mod 2 = 0 then

M:= M + x mod 10;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x.

Чтобы зна­че­ние M оста­лось ну­ле­вым, нужно, чтобы усло­вие x mod 2 = 0 не вы­пол­ня­лось, либо чтобы вы­пол­ня­лось x mod 10 = 0. А зна­чит, все цифры этого числа могут быть либо нечётными, либо пер­вая цифра нечётная и остль­ные нули. Но мы ищем ми­ни­маль­ное x, по­это­му ис­ко­мое число 100.

Ответ: 100.

 

4. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, L и M. Ука­жи­те наи­мень­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 3, а потом 8.

var x, L, M: integer;

begin

readln(x);

L:=0; M:=0;

while x > 0 do begin

L:=L+1;

if (M < x) and (x mod 2 = 0) then begin

M:=x mod 10;

end;

x:= x div 10;

end;

writeln(L); write(M);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число L столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние L сов­па­да­ет с чис­лом цифр в x. Для того, чтобы L стало L=3, x долж­но быть трёхзнач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния M:

if (M < x) and (x mod 2 = 0) then begin

M:=x mod 10;

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x.

Уже на пер­вом шаге можно по­лу­чить x mod 10 = 8, если по­след­няя цифра числа x есть 8. Далее можно сде­лать так, чтобы M боль­ше не ме­ня­лось: для этого на­ру­шим усло­вие x mod 2 = 0, т. е. сде­ла­ем пер­вые две цифры ис­ход­но­го числаx нечётными, при этом нам уже не будет важно усло­вие M < x. Тогда наи­мень­шее зна­че­ние вво­ди­мо­го числа x = 118.

Ответ: 118.

 

5. Ниже за­пи­са­на про­грам­ма. По­лу­чив на вход число x , эта про­грам­ма пе­ча­та­ет два числа, a и b. Ука­жи­те наи­мень­шее из таких чисел x, при вводе ко­то­рых ал­го­ритм пе­ча­та­ет сна­ча­ла 2, а потом 72.

var x, a, b: integer;

begin

readln(x);

a:=0; b:=1;

while x>0 do begin

a:=a+1;

b:=b*(x mod 10);

x:= x div 10;

end;

writeln(a); write(b);

end.

По­яс­не­ние.

Рас­смот­рим цикл, число шагов ко­то­ро­го за­ви­сит от из­ме­не­ния пе­ре­мен­ной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. опе­ра­тор div остав­ля­ет толь­ко целую часть от де­ле­ния, то при де­ле­нии на 10 это рав­но­силь­но от­се­че­нию по­след­ней цифры.

Из при­ве­ден­но­го цикла видно, что на каж­дом шаге от де­ся­тич­ной за­пи­си x от­се­ка­ет­ся по­след­няя цифра до тех пор, пока все цифры не будут от­се­че­ны, то есть x не ста­нет равно 0; по­это­му цикл вы­пол­ня­ет­ся столь­ко раз, сколь­ко цифр в де­ся­тич­ной за­пи­си вве­ден­но­го числа, при этом число a столь­ко же раз уве­ли­чи­ва­ет­ся на 1. Сле­до­ва­тель­но, ко­неч­ное зна­че­ние a сов­па­да­ет с чис­лом цифр в x. Для того, чтобы a стало a = 2, x долж­но быть дву­знач­ным.

Те­перь рас­смот­рим опе­ра­тор из­ме­не­ния b:

while x>0 do begin

b:=b*(x mod 10);

end;

Опе­ра­тор mod остав­ля­ет толь­ко оста­ток от де­ле­ния, при де­ле­нии на 10 это по­след­няя цифра x; сле­до­ва­тель­но, число b по­лу­ча­ет­ся про­из­ве­де­ни­ем цифр числа x.

Пред­ста­вим число 72 в виде: 72 = 9 * 8. Дру­го­го пред­став­ле­ния, в ко­то­ром оба мно­жи­те­ля од­но­знач­ные число 72 не имеет. Сле­до­ва­тель­но, ми­ни­маль­ное число x = 89.

Ответ: 89.

M:= M + (x mod 10div 2
sites.google.com›…reseniezadanijinformatikipoege…

endwriteln(L); write(M) ... Т. к. оператор div оставляет только целую часть от деления, то при делении на 10 это равносильно отсечению последней цифры. ... Теперь рассмотрим изменение b: while x>0 do begin. Читать ещё



написать администратору сайта