На одном из собеседований по приёму на работу попросили за 30 минут написать программу, которая бы решал следующую задачу:
Есть n стандартных игральных костей (6-ти гранных кубиков) со стандартным обозначением всех граней от 1 до 6. Бросаем все n кубики разом. Нужно найти вероятность выпадения числа k, а именно суммы всех значений, выпавших на этих кубиках.
Решение
Не буду томить ожиданием и сразу выложу код алгоритма, который получился и впоследствии был немного обработан напильником.
# -*- coding: utf-8 -*- # import numpy # def main(): c_int_side_dice: int = 6 # сколько граней у кубика c_int_dice_number: int = 6 # кол-во кубиков c_int_number_to_find: int = 18 # число, вероятность выпадения которого хотим найти probability = dice_probability(c_int_dice_number, c_int_number_to_find, c_int_side_dice) print(probability) # собственно поиск вероятности определённого значения def dice_probability(int_dice_number: int, int_number_to_find: int, c_int_side_dice: int) -> float: list_values, list_interm_probability = list_values_and_interm_probabilities(int_dice_number, c_int_side_dice) if int_number_to_find < list_values[0] or int_number_to_find >list_values[-1]: # задаваемое число выходит за рамки реально возможного диапазона значений result_out: float = 0.0 else: for i in range(len(list_values)): if list_values[i] == int_number_to_find: result_out: float = list_interm_probability[i] / (c_int_side_dice ** int_dice_number) break return result_out # возвращает списки/массивы: значения (сумма выпавших всех значений кубиков), сколько раз встречается значение def list_values_and_interm_probabilities(int_dice_number: int, c_int_side_dice: int) -> tuple[list[int], list[int]]: # [кол-во кубиков], [сколько граней у кубика] list_values = [i for i in range(int_dice_number, c_int_side_dice * int_dice_number + 1)] # list_interm_probability = [1] * c_int_side_dice # [1, 1, 1, 1, 1, 1] for i in range(int_dice_number — 1): list_interm_probability = multiply_by_ones(list_interm_probability, c_int_side_dice) # # list_interm_probability = numpy.convolve(list_interm_probability, [1] * c_int_side_dice) # и не использовать multiply_by_ones() return list_values, list_interm_probability # «умножение» на единицы def multiply_by_ones(list_in: list[int], c_int_side_dice: int) -> list[int]: # [1, 1, 1, 1, 1, 1], 6 list_dummy: list[list[int]] = [] for i in range(c_int_side_dice): list_dummy.append([0] * i) # [], [0], [0, 0], [0, 0, 0] . list_for_sum: list[list[int]] = [] for i in range(c_int_side_dice): list_for_sum.append(list_dummy[i] + list_in + list_dummy[c_int_side_dice — i — 1]) «»» [list_in, 0, 0, 0, 0, 0] [0, list_in, 0, 0, 0, 0] [0, 0, list_in, 0, 0, 0] [0, 0, 0, list_in, 0, 0] [0, 0, 0, 0, list_in, 0] [0, 0, 0, 0, 0, list_in] «»» list_out: list[int] = [] for i in range(len(list_for_sum[0])): sum_out: int = 0 for j in range(c_int_side_dice): sum_out += list_for_sum[j][i] list_out.append(sum_out) «»» [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] «»» return list_out if __name__ == «__main__»: main()
JavaScript
function main() < const c_int_side_dice = 6; // сколько граней у кубика const c_int_dice_number = 6; // кол-во кубиков const c_int_number_to_find = 18; // число, вероятность выпадения которого хотим найти let probability = dice_probability(c_int_dice_number, c_int_number_to_find, c_int_side_dice); console.log(probability); >// собственно поиск вероятности определённого значения function dice_probability(int_dice_number, int_number_to_find, c_int_side_dice) < let lists_val_and_prob = list_values_and_interm_probabilities(int_dice_number, c_int_side_dice); let result_out; if (int_number_to_find < lists_val_and_prob[0][0] || int_number_to_find >lists_val_and_prob[0][lists_val_and_prob[0].length — 1]) < // задаваемое число выходит за рамки реально возможного диапазона значений result_out = 0.0; >else < for (let i = 0; i < lists_val_and_prob[0].length; i++)< if (lists_val_and_prob[0][i] == int_number_to_find)< result_out = lists_val_and_prob[1][i] / Math.pow(c_int_side_dice, int_dice_number); break; >> > return result_out; > // возвращает списки/массивы: значения (сумма выпавших всех значений кубиков), сколько раз встречается значение function list_values_and_interm_probabilities(int_dice_number, c_int_side_dice) < // [кол-во кубиков], [сколько граней у кубика] let list_values = new Array(); let i = 0; for (let j = int_dice_number; j console.log(list_values); let list_interm_probability = Array(c_int_side_dice).fill(1); // [1, 1, 1, 1, 1, 1] for (let i = 0; i < int_dice_number — 1; i++)< list_interm_probability = multiply_by_ones(list_interm_probability, c_int_side_dice); >console.log(list_interm_probability); return [list_values, list_interm_probability]; > // «умножение» на единицы function multiply_by_ones(list_in, c_int_side_dice) < let list_dummy = new Array(c_int_side_dice); for (let j = 0; j < c_int_side_dice; j++)< list_dummy[j] = Array(j).fill(0); >let list_for_sum = new Array(c_int_side_dice); for (let j = 0; j < c_int_side_dice; j++)< list_for_sum[j] = list_dummy[j].concat(list_in, list_dummy[c_int_side_dice — j — 1]); >// [list_in, 0, 0, 0, 0, 0] // [0, list_in, 0, 0, 0, 0] // [0, 0, list_in, 0, 0, 0] // [0, 0, 0, list_in, 0, 0] // [0, 0, 0, 0, list_in, 0] // [0, 0, 0, 0, 0, list_in] let list_out = new Array(); for (let i = 0; i < list_for_sum[0].length; i++)< let sum_out = 0; for (let j = 0; j < c_int_side_dice; j++)< sum_out += list_for_sum[j][i]; >list_out[i] = sum_out; > // [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] return list_out; > main();
Option Explicit Sub main() Const c_int_side_dice = 6 ‘сколько граней у кубика Const c_int_dice_number = 3 ‘кол-во кубиков Const c_int_number_to_find = 10 ‘число, вероятность выпадения которого хотим найти Dim probability probability = dice_probability(c_int_dice_number, c_int_number_to_find, c_int_side_dice) MsgBox probability End Sub ‘собственно поиск вероятности определённого значения Function dice_probability(int_dice_number, int_number_to_find, c_int_side_dice) Dim list_values() Dim list_interm_probability() list_values_and_interm_probabilities int_dice_number, c_int_side_dice, list_values, list_interm_probability Dim result_out Dim i If int_number_to_find < list_values(0) Or int_number_to_find >list_values(UBound(list_values)) Then ‘задаваемое число выходит за рамки реально возможного диапазона значений result_out = 0.0 Else For i = 0 To UBound(list_values) If list_values(i) = int_number_to_find Then result_out = list_interm_probability(i) / (c_int_side_dice ^ int_dice_number) End If Next End If dice_probability = result_out End Function ‘возвращает списки/массивы: значения (сумма выпавших всех значений кубиков), сколько раз встречается значение Sub list_values_and_interm_probabilities(int_dice_number, c_int_side_dice, list_values, list_interm_probability) ‘[кол-во кубиков], [сколько граней у кубика] ReDim list_values(int_dice_number * (c_int_side_dice — 1)) Dim i, j i = 0 For j = int_dice_number To c_int_side_dice * int_dice_number list_values(i) = j i = i + 1 Next ReDim list_interm_probability(c_int_side_dice — 1) For j = 0 To c_int_side_dice — 1 list_interm_probability(j) = 1 Next For j = 0 To int_dice_number — 2 multiply_by_ones list_interm_probability, c_int_side_dice Next End Sub ‘»умножение» на единицы Sub multiply_by_ones(list_in, c_int_side_dice) Dim list_in_length list_in_length = UBound(list_in) Dim list_for_sum() ReDim list_for_sum(c_int_side_dice — 1, list_in_length + c_int_side_dice — 1) Dim i, j, k, n For i = 0 To c_int_side_dice — 1 j = 0 For n = 0 To c_int_side_dice — 1 If i = n Then For k = 0 To list_in_length list_for_sum(i, j) = list_in(k) j = j + 1 Next Else list_for_sum(i, j) = 0 j = j + 1 End If Next Next ‘ [list_in, 0, 0, 0, 0, 0] ‘ [0, list_in, 0, 0, 0, 0] ‘ [0, 0, list_in, 0, 0, 0] ‘ [0, 0, 0, list_in, 0, 0] ‘ [0, 0, 0, 0, list_in, 0] ‘ [0, 0, 0, 0, 0, list_in] ‘ ArrOut_2 list_for_sum Erase list_in ReDim list_in(list_in_length + c_int_side_dice — 1) Dim sum_out For j = 0 To list_in_length + c_int_side_dice — 1 sum_out = 0 For i = 0 To c_int_side_dice — 1 sum_out = sum_out + list_for_sum(i, j) Next list_in(j) = sum_out Next ‘ [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] ‘ ArrOut_1 list_in End Sub ‘================================================== ‘ Sub ArrOut_1(arr_in) Dim str_out Dim i For i = 0 To UBound(arr_in) If i = 0 Then str_out = arr_in(i) Else str_out = str_out » vbNewLine » » в лоб»
5 способов поиска элемента в списке python (питон)
Курс Python 3 | Счетчик повторяющихся слов
— заводим значения сторон кубика WITH step_01_insert (dice) AS ( SELECT 1 AS dice UNION ALL SELECT 2 AS dice UNION ALL SELECT 3 AS dice UNION ALL SELECT 4 AS dice UNION ALL SELECT 5 AS dice UNION ALL SELECT 6 AS dice ) — генерируем все возможные ситуации для 3-х кубиков , step_02_spawn (dice_1, dice_2, dice_3, dice_sum) AS ( SELECT T1.dice AS dice_1 , T2.dice AS dice_2 , T3.dice AS dice_3 , T1.dice + T2.dice + T3.dice AS dice_sum — Значения (сумма выпавших костей) FROM step_01_insert AS T1 , step_01_insert AS T2 , step_01_insert AS T3 ) — считаем в лоб, сколько раз встречается значение SELECT dice_sum — Значения (сумма выпавших костей) , COUNT(1) AS num — Сколько раз встречается значение FROM step_02_spawn GROUP BY dice_sum ORDER BY dice_sum;
Источник: habr.com
Сколько раз число встречается в двумерном массиве?
Когда-то я рассказывал про двумерные массивы в Паскаль, сегодня выкладываю исходник программы, задача которого — посчитать, сколько раз встречается число в матрице. Так как структура языка паскаль очень простая, то и написать данную программу не сложно. В программе есть подробные комментарии, что поможет Вам понять код.
Открыть можно с помощью программ Pascal ABC, Pascal ABC.Net, Turbo Pascal, Lazarus и других. Скачать исходник и просмотреть исходный код программы на Pascal, Вы можете далее. А если вам нужен промокод для buy.ru, то перейдите по ссылке (промокод bay.ru 750 рублей).
Исходный код программы:
Const mmax = 100; //Описание констант
nmax = 100;
Type TMatrix=array[1..mmax,1..nmax] of integer; //Описание типа
Var //Описание переменных
a:TMatrix;
ch, m, n, i, j, k: integer;
begin //Начаало программы
writeln (‘Vvedite razmernost: ‘);
readln (m,n); //Считывание размерности
For i:=1 to m do //Инициализация массива
For j:= 1 to n do
a[i,j]:=random(10)-5;
writeln (‘Massiv:’);
for i:=1 to m do begin//Вывод массива
writeln;
for j:=1 to n do
write(a[i,j],’ ‘);
end;
writeln(‘Vvedite chislo: ‘);
readln(ch); //Считывание нужного числа
k := 0; //Зануление переменной k
for i:=1 to m do // Подсчёт
for j:=1 to n do
if a[i,j] = ch then
k := k + 1;
writeln(‘Chislo vstrechaetsya’, k, ‘ raz(a)’); //Вывод результата
//readln; //Для Turbo Pascal
end. //Конец программы
Если вы программируете на Turbo Pascal, то уберите // в предпоследней строке перед readln.
На сегодня всё, заходите на ZedPost.Ru и скачивайте готовые программы на паскале!
Источник: zedpost.ru
Решение модуля 4.3 Инди-курс программирования на Python
Модуль 4.3 (Обход всех цифр числа с помощью while). В данном занятии разберем как при помощи цикла while можно обойти все цифра числа.
Ниже представлены примеры задач с решением на тему Обход всех цифр числа с помощью while.
Сколько раз будет выполняться цикл while в данной программе?
number = 999000112233
while number > 0:
number = number // 10
Какой ответ выведет программа?
number = 1234567890
count = 0
while number > 0:
last_digit = number % 10
if last_digit < 3:
count = count + 1
number = number // 10
print(count)
Какой ответ выведет программа?
number = 73408
m = 0
s = 0
while number > 0:
last_digit = number % 10
s = s + last_digit
if last_digit > m:
m = last_digit
number = number // 10
print(s + m)
Программа принимает на вход одно натуральное число и выводит его цифры в столбик в обратном порядке.
n = int(input()) while n: print(n % 10) n //= 10
Программа принимает на вход одно натуральное число и выводит на экран сумму цифр данного числа
n = int(input()) sum = 0 while n > 0: sum += n % 10 n = n // 10 print (sum)
Программа принимает на вход одно натуральное число и выводит на экран произведение цифр данного числа
n = int(input()) res = 1 while n > 0: res *= n % 10 n = n // 10 print (res)
Программа принимает на вход одно натуральное число и выводит на экран минимальную и максимальную цифры данного числа в отдельных строчках
x = int(input()) minimum, maximum = 9, 0 while x: x, n = divmod(x, 10) minimum = min(minimum, n) maximum = max(maximum, n) print(minimum) print(maximum)
Программа принимает на вход одно натуральное число. Ваша задачи найти сколько раз встречается цифра 7 в этом числе
a = int(input()) i = 0 while a > 0: if a % 10 == 7: i = i + 1 a = a // 10 print(i)
Программа принимает на вход одно натуральное число и выводит его цифры в двоичной системе в столбик в обратном порядке.
n = int(input()) while n != 0: print(n % 2) n //= 2
Источник: zazloo.ru