Как найти сумму случайных чисел в питоне

Sometimes, in making programs for gaming or gambling, we come across the task of creating the list all with random numbers and perform its summation. This task has to performed in general using loop and appending the random numbers one by one and then performing sum. But there is always requirement to perform this in most concise manner. Lets discuss certain ways in which this can be done. 

Method #1 : Using list comprehension + randrange() + sum() The naive method to perform this particular task can be shortened using the list comprehension. randrange function is used to perform the task of generating the random numbers. The task of performing sum is done using sum(). 

Random number summation list is : 187

Time complexity: O(n), where n is the length of the test_list. The list comprehension + randrange() + sum() takes O(n) time
Auxiliary Space: O(n), extra space of size n is required

  Method #2 : Using random.sample() + sum() This single utility function performs the exact required as asked by the problem statement, it generated N no. of random numbers in a list in the specified range and returns the required list. The task of performing sum is done using sum(). 

Random number summation list is : 187

Time Complexity: O(n), where n is the number of elements
Auxiliary Space: O(1), constant extra space is required

 Method #3 : Using random.randint()

In this method, n is the number of random integers you want to generate, a and b define the range of the random integers (inclusive of a and b), and rand_nums is a list that contains the random integers. The random.randint(a, b) function generates a random integer between a and b, inclusive of both a and b. We use a list comprehension to generate a list of n random integers between a and b. The sum function is then used to calculate the sum of the random integers in the list rand_nums. Finally, we print out the list of random integers and the sum of those integers. You can adjust the values of n, a, and b to generate different numbers of random integers and change the range of the random integers.

Random integers: [6, 8, 5, 7, 6, 7, 2, 4, 1, 3]
Sum of random integers: 49

Time complexity: O(n)

Auxiliary Space: O(n)

Method #4 :  Using reduce() from the functools module:

1.Generate n random integers between a and b using the random module and list comprehension. Store the list of random integers in the variable rand_nums.

2.Initialize a variable rand_sum to 0.

3.Loop through each integer in rand_nums. For each integer, add it to the current value of rand_sum.

4.After the loop is complete, rand_sum will hold the sum of all the random integers.

5.Print the list of random integers and the sum of the random integers.

Random integers: [7, 4, 3, 4, 9, 9, 9, 2, 6, 2]
Sum of random integers: 55

The time complexity:O(n), where n is the number of random integers generated. This is because generating a list of n random integers takes O(n) time, and calculating the sum of the integers using the reduce() function also takes O(n) time.

The auxiliary space :O(n), as the list of n random integers and the output variable rand_sum both take up O(n) space.

Last Updated :
09 Apr, 2023

Like Article

Save Article

Here’s the standard solution. It’s similar to Laurence Gonsalves’ answer, but has two advantages over that answer.

1. It’s uniform: each combination of 4 positive integers adding up to 40 is equally likely to come up with this scheme.

and

1. it’s easy to adapt to other totals (7 numbers adding up to 100, etc.)

import random

def constrained_sum_sample_pos(n, total):
    """Return a randomly chosen list of n positive integers summing to total.
    Each such list is equally likely to occur."""

    dividers = sorted(random.sample(range(1, total), n - 1))
    return [a - b for a, b in zip(dividers + [total], [0] + dividers)]

Sample outputs:

>>> constrained_sum_sample_pos(4, 40)
[4, 4, 25, 7]
>>> constrained_sum_sample_pos(4, 40)
[9, 6, 5, 20]
>>> constrained_sum_sample_pos(4, 40)
[11, 2, 15, 12]
>>> constrained_sum_sample_pos(4, 40)
[24, 8, 3, 5]

Explanation: there’s a one-to-one correspondence between (1) 4-tuples (a, b, c, d) of positive integers such that a + b + c + d == 40, and (2) triples of integers (e, f, g) with 0 < e < f < g < 40, and it’s easy to produce the latter using random.sample. The correspondence is given by (e, f, g) = (a, a + b, a + b + c) in one direction, and (a, b, c, d) = (e, f - e, g - f, 40 - g) in the reverse direction.

If you want nonnegative integers (i.e., allowing 0) instead of positive ones, then there’s an easy transformation: if (a, b, c, d) are nonnegative integers summing to 40 then (a+1, b+1, c+1, d+1) are positive integers summing to 44, and vice versa. Using this idea, we have:

def constrained_sum_sample_nonneg(n, total):
    """Return a randomly chosen list of n nonnegative integers summing to total.
    Each such list is equally likely to occur."""

    return [x - 1 for x in constrained_sum_sample_pos(n, total + n)]

Graphical illustration of constrained_sum_sample_pos(4, 10), thanks to @FM. (Edited slightly.)

0 1 2 3 4 5 6 7 8 9 10  # The universe.
|                    |  # Place fixed dividers at 0, 10.
|   |     |       |  |  # Add 4 - 1 randomly chosen dividers in [1, 9]
  a    b      c    d    # Compute the 4 differences: 2 3 4 1

Массивы в Python представлены в виде списков (list). Список в Python — это упорядоченная коллекция элементов, которые могут быть разных типов данных (строки, числа, другие списки и т.д.).

Создание простого массива

Создать список можно с помощью квадратных скобок и запятых, разделяющих элементы списка:

my_list = [1, 2, 3, 4, 5]

Также можно создать пустой список:

Для доступа к элементам списка используется индексация, начинающаяся с нуля:

print(my_list[0]) # выведет 1
print(my_list[2]) # выведет 3

Можно изменять элементы списка:

Копировать

my_list[0] = 10
print(my_list) # выведет [10, 2, 3, 4, 5]

Также можно добавлять элементы в конец списка с помощью метода append():

my_list.append(6)
print(my_list) # выведет [10, 2, 3, 4, 5, 6]

И удалять элементы с помощью метода remove():

my_list.remove(3)
print(my_list) # выведет [10, 2, 4, 5, 6]

Списки в Python поддерживают множество методов для работы с ними, таких как sort(), reverse(), count(), index() и другие.

Как заполнить массив числами с клавиатуры во время работы программы

Для заполнения массива числами, вводимыми с клавиатуры, можно использовать цикл for и функцию input(). Вот пример кода:

n = int(input("Введите размер массива: ")) # запрашиваем у пользователя размер массива
my_array = [] # создаем пустой массив
 
for i in range(n):
    num = int(input("Введите число: ")) # запрашиваем у пользователя число
    my_array.append(num) # добавляем число в массив
 
print("Массив:", my_array) # выводим массив на экран

В этом примере мы сначала запрашиваем у пользователя размер массива с помощью функции input(), преобразуем его в целое число с помощью функции int() и сохраняем в переменную n. Затем создаем пустой массив my_array.

Далее мы используем цикл for для заполнения массива. На каждой итерации цикла мы запрашиваем у пользователя число с помощью функции input(), преобразуем его в целое число с помощью функции int() и добавляем в массив с помощью метода append().

Наконец, мы выводим массив на экран с помощью функции print().

Заполнение случайными числами

Для заполнения массива случайными числами можно воспользоваться модулем random из стандартной библиотеки Python.

Вот пример кода, который заполняет массив случайными целыми числами от 0 до 9:

import random
 
n = 10 # размер массива
my_array = [random.randint(0, 9) for _ in range(n)] # заполняем массив случайными числами
 
print("Массив:", my_array) # выводим массив на экран

В этом примере мы импортируем модуль random и создаем переменную n, которая содержит размер массива. Затем мы используем генератор списков для заполнения массива случайными целыми числами от 0 до 9 с помощью функции random.randint(). Функция принимает два аргумента: нижнюю и верхнюю границы диапазона случайных чисел.

Далее выводим массив на экран с помощью функции print().

Как заполнить массив по заданному правилу (по формуле)

Для заполнения массива по заданному правилу можно использовать цикл for и применять формулу на каждой итерации цикла. Вот пример кода, который заполняет массив числами, вычисленными по формуле x^2 + 2x + 1:

n = 10 # размер массива
my_array = [] # создаем пустой массив
 
for x in range(n):
    num = x**2 + 2*x + 1 # вычисляем число по формуле
    my_array.append(num) # добавляем число в массив
 
print("Массив:", my_array) # выводим массив на экран

В этом примере мы создаем переменную n, которая содержит размер массива, и создаем пустой массив my_array.

Затем мы используем цикл for для заполнения массива. На каждой итерации цикла мы вычисляем число по заданной формуле и добавляем его в массив с помощью метода append().

Выводим массив на экран с помощью функции print().

Сортировка. Как упорядочить массив чисел по возрастанию?

Сортировка «пузырьком»

Рассмотрим алгоритм сортировки пузырьком:

my_array = [5, 2, 8, 1, 9, 3] # исходный массив
n = len(my_array) # определяем размер массива
 
# выполняем сортировку пузырьком
for i in range(n):
    for j in range(n - i - 1):
        if my_array[j] > my_array[j + 1]:
            my_array[j], my_array[j + 1] = my_array[j + 1], my_array[j]
 
print("Отсортированный массив:", my_array) # выводим отсортированный массив на экран

В этом примере мы создаем переменную my_array, которая содержит исходный массив чисел.

Затем мы определяем размер массива с помощью функции len() и сохраняем его в переменную n.

Далее мы выполняем сортировку пузырьком с помощью двух вложенных циклов for. Внешний цикл выполняется n раз, а внутренний цикл — n — i — 1 раз, где i — номер текущей итерации внешнего цикла. Внутренний цикл сравнивает два соседних элемента массива и меняет их местами, если они расположены в неправильном порядке.

Метод sort()

Для упорядочивания массива чисел по возрастанию можно использовать метод sort() или функцию sorted(). Вот пример программы, которая сортирует массив чисел по возрастанию с помощью метода sort():

my_array = [5, 2, 8, 1, 9, 3] # исходный массив
my_array.sort() # сортируем массив по возрастанию
print("Отсортированный массив:", my_array) # выводим отсортированный массив на экран

В этом примере мы создаем переменную my_array, которая содержит исходный массив чисел.

Затем мы вызываем метод sort() для массива my_array, который сортирует его по возрастанию.

Выводим отсортированный массив на экран с помощью функции print().

Функция sorted()

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

my_array = [5, 2, 8, 1, 9, 3] # исходный массив
sorted_array = sorted(my_array) # сортируем массив по возрастанию и сохраняем результат в новый массив
print("Исходный массив:", my_array) # выводим исходный массив на экран
print("Отсортированный массив:", sorted_array) # выводим отсортированный массив на экран

В этом примере мы создаем переменную my_array, которая содержит исходный массив чисел.

Затем мы вызываем функцию sorted() для массива my_array, которая сортирует его по возрастанию и сохраняет результат в новый массив sorted_array.

Примеры задач на обработку линейного массива чисел

Задача 1. Дан одномерный массив из N целых элементов. Написать программу вычисления произведения всех элементов. Используйте ручной способ ввода чисел.

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

n = int(input("Введите размер массива: ")) # вводим размер массива
my_array = [] # создаем пустой массив
 
# заполняем массив вручную
for i in range(n):
    num = int(input("Введите число: "))
    my_array.append(num)
 
# вычисляем произведение всех элементов массива
product = 1
for num in my_array:
    product *= num
 
print("Произведение всех элементов массива:", product) # выводим результат на экран

В этом примере мы сначала запрашиваем у пользователя размер массива с помощью функции input() и преобразуем его в целое число с помощью функции int(). Затем мы создаем пустой массив my_array и заполняем его вручную с помощью цикла for и функции input().

Далее мы используем цикл for для вычисления произведения всех элементов массива. На каждой итерации цикла мы умножаем текущий элемент на переменную product, которая изначально равна 1.

Задача 2. Дан линейный массив из N целых чисел. Написать программу вычисления суммы этих элементов. Используйте для заполнения массива случайные числа.

Вот пример кода, который вычисляет сумму всех элементов линейного массива, заполненного случайными числами:

import random
 
n = 10 # размер массива
my_array = [random.randint(0, 9) for _ in range(n)] # заполняем массив случайными числами
 
# вычисляем сумму всех элементов массива
sum = 0
for num in my_array:
    sum += num
 
print("Массив:", my_array) # выводим массив на экран
print("Сумма всех элементов массива:", sum) # выводим результат на экран

В этом примере мы импортируем модуль random и создаем переменную n, которая содержит размер массива. Затем мы используем генератор списков для заполнения массива случайными целыми числами от 0 до 9 с помощью функции random.randint().

Далее мы используем цикл for для вычисления суммы всех элементов массива. На каждой итерации цикла мы добавляем текущий элемент к переменной sum, которая изначально равна 0.

Задача 3.Дан массив A(n). Заполнить двузначными числами. Найти элементы сумма цифр, которых равна числу элементов массива.

n = 10 # размер массива
my_array = [] # создаем пустой массив
 
# заполняем массив двузначными числами
for i in range(n):
    num = i + 10 # добавляем 10, чтобы получить двузначное число
    my_array.append(num)
 
# выводим элементы массива на экран
print("Массив:", my_array)
 
# находим элементы, сумма цифр которых равна числу элементов массива
for num in my_array:
    digits_sum = sum(int(digit) for digit in str(num)) # вычисляем сумму цифр числа
    if digits_sum == n:
        print("Число", num, "имеет сумму цифр, равную числу элементов массива")

В этом примере мы создаем переменную n, которая содержит размер массива, и создаем пустой массив my_array.

Затем мы используем цикл for для заполнения массива двузначными числами. На каждой итерации цикла мы добавляем 10 к текущему индексу, чтобы получить двузначное число, и добавляем его в массив с помощью метода append().

Далее мы используем цикл for для нахождения элементов, сумма цифр которых равна числу элементов массива. На каждой итерации цикла мы вычисляем сумму цифр текущего числа с помощью функции sum() и генератора списков, который преобразует каждую цифру числа в целое число с помощью функции int() и суммирует их. Затем мы сравниваем сумму цифр с числом элементов массива и выводим число на экран, если они равны.

Задача 4.Составьте программу, которая выполнит перевод натурального числа из десятичной системы счисления в любую с основанием 2-16

decimal_number = int(input("Введите натуральное число в десятичной системе счисления: ")) # вводим десятичное число
base = int(input("Введите основание системы счисления (от 2 до 16): ")) # вводим основание системы счисления
 
# проверяем, что основание системы счисления находится в диапазоне от 2 до 16
if base < 2 or base > 16:
    print("Ошибка: основание системы счисления должно быть от 2 до 16")
else:
    # выполняем перевод числа в заданную систему счисления
    result = ""
    while decimal_number > 0:
        remainder = decimal_number % base
        if remainder < 10:
            result = str(remainder) + result
        else:
            result = chr(remainder + 55) + result
        decimal_number //= base
 
    print("Число в системе счисления с основанием", base, ":", result) # выводим результат на экран

В этом примере мы сначала запрашиваем у пользователя натуральное число в десятичной системе счисления и основание системы счисления, в которую нужно выполнить перевод.

Затем мы проверяем, что основание системы счисления находится в диапазоне от 2 до 16. Если основание не входит в этот диапазон, выводим сообщение об ошибке.

Если основание находится в диапазоне от 2 до 16, то выполняем перевод числа в заданную систему счисления с помощью цикла while. В каждой итерации цикла мы находим остаток от деления десятичного числа на основание системы счисления и добавляем его в начало результата. Если остаток меньше 10, то мы просто добавляем его в виде строки, а если больше или равен 10, то мы добавляем соответствующую букву в верхнем регистре (A, B, C, D, E, F) с помощью функции chr().