def create_table(number_of_people, number_of_tables, *table_sits):
a = [0] * number_of_people
tables = []
for i in range(1, number_of_tables + 1):
tables.append(i)
return a, tables
people, tables = create_table(int(input()), int(input()), *map(int, input().split()))
def add_people(a, tables, number_of_people):
for i in range(number_of_people):
if i == 0:
a[i] = tables[i]
else:
a[i] = tables[(i % len(tables))]
return a
def print_result(people, tables, number_of_people, number_of_tables):
for i in range(1, number_of_people + 1):
print(f"День {i}:")
for j in range(1, number_of_t
import os
rootdir = 'C:\\'
for subdir, dirs, files in os.walk(rootdir):
for file in files:
print os.path.join(subdir, file)
a = int(input())
step = 1
step_sum = 0
while True:
if step_sum + step <= a:
step_sum += step
step += 1
else:
break
print(step - 1)
def max_el_matrix(n):
matrix = []
for i in range(n):
matrix.append(list(map(int, input().split())))
max_el = -100
for i in range(n):
for j in range(n):
if i < j:
if matrix[i][j] > max_el:
max_el = matrix[i][j]
return max_el
max_el_matrix(4)
def find_max_exluding_main_diagonal(matrix):
rows, columns = len(matrix), len(matrix[0])
max_num = matrix[0][0]
for i in range(1, rows):
for j in range(i):
if max_num < matrix[i][j]:
max_num = matrix[i][j]
return max_num
# Test
matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
find_max_exluding_main_diagonal(matrix)
def add(a, n):
sum = 0
k = 0
for i in range(n):
sum += a[i]
if sum <= n:
k += 1
return k, sum
a = []
n = int(input())
for i in range(n):
a.append(int(input()))
k, sum = add(a, n)
if sum > n:
print("Enough!")
else:
print(sum)
print(k)
text = input()
t = text.split()
for i in range(len(t)):
if t[i][0].upper() == t[i][-1].upper():
print("YES")
break
if i == len(t) - 1:
print("NO")
def matrix():
n = int(input())
a = []
for i in range(n):
a.append([int(s) for s in input().split()])
res = -100
for i in range(n):
for j in range(n):
if i > j and a[i][j] > res:
res = a[i][j]
print(res)
matrix()
def generate_batches(X, y, batch_size):
"""
param X: np.array[n_objects, n_features] --- матрица объекты-признаки
param y: np.array[n_objects] --- вектор целевых переменных
"""
assert len(X) == len(y)
np.random.seed(42)
X = np.array(X)
y = np.array(y)
perm = np.random.permutation(len(X))
for batch_start in range(0, len(X), batch_size):
batch_inds = perm[batch_start:batch_start + batch_size]
yield X[batch_inds], y[batch_inds]
def city_names(data):
for i in range(0, len(data) - 1):
if data[i][-1] == 'ь' or data[i][-1] == 'ы' or data[i][-1] == 'ъ':
if data[i + 1][0] == data[i][-2]:
print('YES')
else:
print('NO')
else:
if data[i + 1][0] == data[i][-1]:
print('YES')
else:
print('NO')
data = input().split()
city_names(data)
n, m = int(input()), int(input())
matrix = [[str(i*m+j+1).ljust(3) for j in range(m)] for i in range(n)]
for row in matrix: print(' '.join(row))
a = [[1,2,3],[1,2,3],[1,2,3]]
b = [[3,3,3],[3,3,3],[3,3,3]]
# without using numpy
def matmul(a, b):
r = [[0,0,0],
[0,0,0],
[0,0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
for k in range(len(a[0])):
r[i][j] += a[i][k] * b[k][j]
return r
matmul(a, b)
# using numpy
import numpy as np
def matmul_np(a, b):
return np.matmul(a, b)
matmul_np(np.array(a), np.array(b))
def determine_cities_longer_than_5_chars(cities):
for city in cities.split():
if len(city) <= 5:
print('NO')
return
print('YES')
cities = input()
determine_cities_longer_than_5_chars(cities)
def check(number):
number = str(number)
for i in range(len(number)-1):
if number[i] == number [i+1]:
return False
return True
def f(n):
t = ((1, 0, 0, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 1, 0, 0),
(0, 0, 0, 1, 0),
(0, 0, 0, 0, 1))
t2 = []
for i in range(n):
t2.append(t[i][:n])
for i in range(n):
print(*t2[i])
def greedy_algorithm(T):
T = T.sort(reverse=True)
min_sum = sum(T)
for t in T:
min_sum = min(min_sum, t + greedy_algorithm(T[1:]))
return min_sum
def hard_algorithm(T):
n = len(T)
T = sorted(T, reverse=True)
cur_sum = 0
while True:
min_i = 0
min_value = 99999
for i in range(n):
if T[i] < min_value:
min_value = T[i]
min_i = i
cur_sum += min_value
T.remove(min_value)
n = len(T)
if not n:
break
T[min_i] = T[min_i] * 2
return cur_sum
count_people = int(input())
count_days = int(input())
count_tables = int(
a = int(input())
b = int(input())
for i in range(a, b+1):
if i == a:
print(i)
elif i%2 == 0:
print(-i)
else:
print(i)
def which_day(number):
if number == 1:
return "Monday"
elif number == 2:
return "Tuesday"
elif number == 3:
return "Wednesday"
elif number == 4:
return "Thursday"
elif number == 5:
return "Friday"
elif number == 6:
return "Saturday"
elif number == 7:
return "Sunday"
else:
return "Out of range"
#input
which_day(1)
#output
"Monday"
backpack = int(input())
sum = 0
num = 0
while True:
i = int(input())
sum += i
num += 1
if sum > backpack:
break
print('Enough!')
print(sum)
print(num)
n = int(input())
sum_ = 0
i = 0
while sum_ < n:
x = int(input())
sum_ += x
i += 1
if sum_ >= n:
break
print('sum:', sum_)
print('number of numbers:', i)
def print_nums(n):
s = 0
i = 0
while i < 10:
num = random.uniform(0.001, 1)
if s + num <= n:
print(round(num, 12))
s += num
i += 1
else:
num = n - s
print(round(num, 12))
s = n
i += 1
print_nums(0.5)
s = int(input())
v1 = int(input())
v2 = int(input())
t1 = int(input())
t2 = int(input())
time1 = v1 * s + 2 * t1
time2 = v2 * s + 2 * t2
if time1 < time2:
print('First')
elif time1 > time2:
print('Second')
else:
print('Friendship')
def is_prime(N):
if N == 1:
print("No")
return
for k in range(2, N):
if N % k == 0:
print("No")
return
print("Yes")
is_prime(5)
is_prime(4)
def city_match(string):
string = string.split(' ')
for i in range(len(string)-1):
if string[i][-1] == string[i+1][0]:
print('YES')
else:
print('NO')
city_match('London Berlin Madrid Moscow')
def is_prime(n):
if n == 1:
return "No"
i = 2
while i * i <= n:
if n % i == 0:
return "No"
i += 1
return "Yes"
def greedy(n, m, k, a)
...
def get_random_number(n):
result = []
while n > 0:
num = random.random()
if num not in result:
if n - num >= 0 and n - num <= 1:
result.append(num)
n -= num
return result
get_random_number(0.999)
def max_element(matrix, index = 1):
max_element = matrix[0][0]
for i in range(len(matrix)):
for j in range(i + index, len(matrix[i])):
if max_element < matrix[i][j]:
max_element = matrix[i][j]
return max_element
import random
def random_adder(n):
x = 0
i = 0
while x < n:
y = round(random.random(), 12)
x += y
i += 1
if i <= 10:
print(y)
random_adder(10)
def RLE(array):
inds = np.add.reduceat(np.not_equal(array[1:], array[:-1]), np.arange(len(array)))
array = array[inds]
lens = np.diff(np.append(inds, len(array)))
return array, lens
def is_prime(num):
if num < 2:
return False
for i in range(2, num):
if num % i == 0:
return False
return True
is_prime(3)
class Neuron:
def __init__(self, weights, function=lambda x: x):
self.weights = weights
self.function = function
self.inputs = None
def forward(self, inputs):
self.inputs = inputs
if len(inputs) != len(self.weights):
return None
return self.function(sum([x*y for x,y in zip(self.weights, self.inputs)]))
def backlog(self):
return self.inputs
def city_check(cities):
cities = cities.split()
while True:
if all(len(city) > 5 for city in cities):
print("YES")
break
else:
print("NO")
break
city_check("Kyiv Dnipro Kharkiv")
n = int(input())
m = int(input())
numbers = []
for i in range(n):
row = input().split()
numbers.append([int(x) for x in row])
for i in range(n):
row = input().split()
for i in range(len(row)):
numbers[i][i] += int(row[i])
for row in numbers:
print(' '.join([str(x) for x in row]))
#input:
# 3
# 1 2 3
# 4 5 6
# 7 8 9
# output:
# 18
n = int(input())
matrix = [list(map(int, input().split())) for _ in range(n)]
result = 0
for i in range(n):
for j in range(n):
if i + j >= n:
break
result += matrix[i][j]
print(result)
def add_all():
num = int(input('Enter an integer: '))
sum = 0
while num != 0:
sum = sum + num
num = int(input('Enter an integer: '))
return sum
add_all()
def min_divisor(n):
if n == 2:
return 2
else:
for i in range(2, n+1):
if n % i == 0:
return i
break
min_divisor(10)
import numpy as np
def run_length_encoding(array):
repeats = []
current = None
counter = 0
for element in array:
if element == current:
counter += 1
else:
if current is not None:
repeats.append((current, counter))
current = element
counter = 1
repeats.append((current, counter))
values, counts = zip(*repeats)
return np.array(values), np.array(counts)
run_length_encoding([1, 1, 2, 2, 2, 5])
def foo(a, b):
for i in range(a, b + 1):
if (i % 2 or i % 3 or i % 777 == 0):
continue
print(i)
foo(1, 777)
^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$
def func(a, b):
while a <= b:
if a % 2 == 0 or a % 3 == 0:
a += 1
else:
print(a)
a += 1
if a % 777 == 0:
break
print(func(1, 100))
def matrix(n,m):
k = 1
matrix = []
for i in range(n):
r = []
for j in range(m):
r.append(str(k).ljust(3))
k += 1
matrix.append(r)
for i in range(len(matrix)):
for j in range(len(matrix[i])):
print (matrix[i][j], end="")
print('\n', end="")
n = int(input())
m = int(input())
matrix(n,m)
import docx
def create_word_file(path, file_name):
doc = docx.Document()
doc.save(path + file_name + '.docx')
create_word_file('/Users/tatiana/', 'hello')
def has_five(word):
if len(word) >= 5:
return True
else:
return False
has_five("hello")
n = int(input())
i = 0
sum = 0
while True:
sum += int(input())
i += 1
if sum > n:
break
else:
print(i, sum)
def fractional_part(n):
s = 0
for i in range(1, 10):
while (s < n):
s += 1 / i
print(s)
return None
fractional_part(0.5)
def is_match(n):
s = str(n)
for i in range(len(s)-1):
if s[i] == s[i+1]:
return True
return False
is_match(123123)
def func(line1, line2):
return "Good" if (line1[-1] == line2[0] and line1[-2] != "f") or (line1[-1] == "f" and line2[0] == line1[-3]) else "Bad"
# 1 2 3
# 4 5 6
# 7 8 9
def add(a, b):
return a + b
def max_el(a):
if n == 1:
return a[0][0]
if n == 2:
return max(a[0][0], a[1][0], a[1][1])
res = a[0][0]
for i in range(len(a)):
for j in range(len(a[i])):
if i == j:
if a[i][j] > res:
res = a[i][j]
if i > j:
if a[i][j] > res:
res = a[i][j]
return res
n = int(input())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
print(max_el(a))
def matrix_size(matrix_list):
for row in matrix_list:
x = 0
for element in row:
x = x + element
mean = x/len(row)
count = 0
for element in row:
if element > mean:
count = count + 1
print(count)
def calculate(x, y):
if x > y:
return x - y
else:
return y - x
calculate(1.23, 2.34)
^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9_\.\-]+\.[a-zA-Z0-9_\.\-]+$
class Neuron:
def __init__(self, w, activation_function=lambda x: x):
"""
Инициализируем нейрон.
w - вектор весов нейрона размера (m, 1), где m - количество входов
activation_function - активационная функция нейрона, сигмоидальная функция по умолчанию
"""
# Присваиваем значение атрибуту activation_function
self.activation_
letter = input()
sentence = input()
sentence_list = sentence.split()
for word in sentence_list:
for c in word:
if c.upper() == letter.upper():
print(word)
break
n, m = int(input()), int(input())
def create_matrix(n, m):
matrix = [[0] * m for i in range(n)]
return matrix
matrix = create_matrix(n, m)
count = 1
for i in range(n):
for j in range(m):
matrix[i][j] = count
count += 1
for i in matrix:
for j in i:
print(str(j).ljust(3), end = '')
print()
t = ((1, 0, 0, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 1, 0, 0),
(0, 0, 0, 1, 0),
(0, 0, 0, 0, 1))
n = int(input())
t2 = t[:n]
for i in range(n):
t2[i] = t2[i][:n]
for j in range(n):
print(t2[i][j], end=' ')
print()
def comb(n, k):
if k > n:
return 0
elif k == 0:
return 1
else:
return comb(n-1, k) + comb(n-1, k-1)
n, k = map(int, input().split())
result = comb(n, k)
print(result)
def hack_pentagon(network, password):
if network == "pentagon":
if password == "secret":
return True
else:
return False
else:
return False
hack_pentagon("pentagon", "secret")
def city_5(a):
if len(a) > 5:
return "Yes"
else:
return "No"
a = input("Enter cities separated by a space: ").split()
i = 0
while i < len(a):
print(city_5(a[i]))
i += 1
N, M = int(input()), int(input())
matrix_a = []
for i in range(N):
matrix_a.append([int(x) for x in input().split()])
matrix_b = []
for i in range(N):
matrix_b.append([int(x) for x in input().split()])
matrix_c = []
for i in range(N):
matrix_c.append([matrix_a[i][j] + matrix_b[i][j] for j in range(M)])
for x in matrix_c:
print(*x)
def fives():
size = int(input())
matrix = []
for i in range(size):
matrix.append([])
for j in range(size):
if j < size - 1:
matrix[i].append(1)
else:
matrix[i].append(5)
for i in range(size):
print(*matrix[i])
fives()
def digits(n):
a = ''
while len(a) < 12:
b = str(n)[:3]
if int(b) > 999:
b = str(n)[:2]
if int(b) > 99:
b = str(n)[0]
if int(b) > 9:
b = str(b)[:1]
if b not in a:
a += b
else:
b = str(n)[5]
if b not in a:
a += b
n += 0.000000000001
return a
digits(0.001213245678)
def spiral(x, y):
a = [[0] * y for i in range(x)]
dx, dy = [0, 1, 0, -1], [1, 0, -1, 0]
x, y, c = 0, -1, 1
for i in range(max(x, y)**2):
while True:
nx, ny = x + dx[i % 4], y + dy[i % 4]
if 0 <= nx < x and 0 <= ny < y and a[nx][ny] == 0:
x, y = nx, ny
break
else:
i += 1
a[x][y] = c
c += 1
return a
print(spiral(4, 5))
def fives(n):
matrix = []
for i in range(n):
matrix.append([])
for j in range(n):
if j == n-1:
matrix[i].append(5)
else:
matrix[i].append(1)
for i in range(n):
for j in range(n):
print(matrix[i][j], end='')
print()
fives(10)
n = int(input("Please insert n: "))
matrix = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
matrix[i][j] = int(input("Please insert matrix[{}][{}]: ".format(i, j)))
diagonal = 0
for i in range(n):
for j in range(n):
if i == j or i + j == n - 1:
diagonal += matrix[i][j]
print("The sum of the diagonal is: " + str(diagonal))
n, m = int(input()), int(input())
spisok = [i for i in range(1, n*m+1)]
matrix = [spisok[i*m:i*m+m] for i in range(n)]
for i in range(n):
for j in range(m):
print(str(matrix[i][j]).ljust(3), end='')
print()
n = int(input())
input_x = [int(input()) for i in range(n)]
def f(x):
return x*x
for x in input_x:
print(f(x))
def generate_matrix(n, m):
matrix = []
k = 1
while k <= n * m:
i = (k - 1) // m
j = (k - 1) % m
matrix.append([0] * j + [k] + [0] * (m - 1 - j))
k += 1
return matrix
n, m = [int(s) for s in input().split()]
a = generate_matrix(n, m)
for row in a:
print(' '.join([str(elem) for elem in row]))
def func(data):
last_letter = data[0][-1]
for item in data[1:]:
if last_letter == 'ы':
last_letter = data[-2]
elif last_letter == 'ь' or last_letter == 'ъ':
last_letter = data[-3]
elif item.startswith(last_letter):
last_letter = item[-1]
continue
else:
return 'NO'
return 'YES'
def max_under_diagonal(matrix):
res = 0
for i in range(len(matrix) - 1): # no need to check the last row
for j in range(i + 1):
if matrix[i][j] > res:
res = matrix[i][j]
return res
max_under_diagonal([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]]) # 15
n=int(input())
m=int(input())
max_ind = 0
max_row = 0
max_val = -1
for i in range(n):
row = list(map(int, input().split()))
for j in range(m):
if row[j] > max_val:
max_ind = j
max_row = i
max_val = row[j]
print(max_row, max_ind)
def buy_socks(num_socks,num_buy):
return num_socks + num_buy*(num_socks//num_buy)
/\w+@outlook.com/
def get_time(time_mins, start_hours, start_mins):
total_mins = start_hours * 60 + start_mins + time_mins
total_hours = total_mins // 60
total_mins = total_mins % 60
return total_hours, total_mins
import random
def print_rand(n):
return random.random() * n
print_rand(1.8)
import webbrowser
webbrowser.open("https://www.google.com")
class Neuron:
def __init__(self, weights, activation_function = lambda x: x):
weights = []
self.weights = weights
self.activation_function = activation_function
self.x = None
def forward(self, input_data):
self.x = input_data
y = 0
for w_i, x_i in zip(self.weights, input_data):
y += w_i * x_i
return self.activation_function(y)
def backward(self):
return self.x
def diag_func(a):
return [[int(i == j) for i in range(a)] for j in range(a)]
diag_func(4)
N=5
def create_list(a):
list_of_lists = []
for i in range(a):
inner_list = []
for j in range(a):
if j == N-1:
inner_list.append(5)
else:
inner_list.append(1)
list_of_lists.append(inner_list)
return list_of_lists
create_list(N)
class MyQueue:
def __init__(self):
self.data = []
def push(self, val):
self.data.append(val)
def front(self):
if len(self.data) == 0:
return -1
return self.data[0]
def pop(self):
if len(self.data) == 0:
return -1
return self.data.pop(0)
def task_1(X, a):
m = X.shape[1]
n = X.shape[0]
res = np.zeros(n*m*2).reshape(n, m*2)
for i in range(n):
res[i, :m] = X[i]
res[i, m:] = [x if ind(x)%2==0 else x**3 for x in X[i][::-1]]
return res
def decode_morze(code):
words = code.split(' ')
letters = []
for word in words:
letter = ''
for char in word:
letter += char
if letter in morze:
letters.append(morze[letter])
letter = ''
return ''.join(letters)
print(decode_morze('-- -.-- --- ...'))
def unique_words(text):
return " ".join(list(set(text.lower().split())))
unique_words("Строка со строкой в ней.")
def my_func(a):
c = len(a)
while c > 0:
if c < 5:
print('NO')
break
elif c >= 5:
print('YES')
break
c -= 1
my_func('A')
def repeat_letters(s):
res = []
for i in s:
if i.lower() in s.lower() and i.lower() not in res:
res.append(i.lower())
return res
def max_below_main_diagonal(matrix):
maximum = matrix[0][0]
for row in range(1, len(matrix)):
for col in range(row+1):
if matrix[row][col] > maximum:
maximum = matrix[row][col]
return maximum
import random
def make_number(n):
number = []
left = n
right = 0
for i in range(9):
tmp = random.uniform(0.001, left)
number.append(round(tmp, 12))
left -= tmp
right += tmp
number.append(round(left + right, 12))
return number
def main():
n = float(input())
numbers = make_number(n)
for number in numbers:
print(number)
main()
import numpy as np
def transform_array(x, a=1):
x = np.array(x)
for i, el in enumerate(x):
x[i] = el ** 3 if i % 2 == 0 else a
return x[::-1]
def transform_array_all(x, a=1):
x = np.array(x)
y = np.array([])
for i, el in enumerate(x):
if i % 2 == 0:
el = el ** 3
else:
el = a
y = np.append(y, el)
return np.append(x, y[::-1])
x = np.array([100,200,300,400,500])
print(transform_array(x))
print(transform_array_all(x))
def max_below_main_diagonal(n):
max = -100
for k in range(1,n):
for i in range(0,n):
for j in range(0,n):
if (i+j) == k:
if A[i][j] > max:
max = A[i][j]
print(max)
max_below_main_diagonal(2)
def max_min_sum(numbers):
numbers = list(map(int, numbers.split()))
return (max(numbers), min(numbers), sum(numbers))
max_min_sum('1 2 3 4 5')
t = ((1, 0, 0, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 1, 0, 0),
(0, 0, 0, 1, 0),
(0, 0, 0, 0, 1))
def make_list(t, n):
return [t[i][:n] for i in range(n)]
n = int(input())
print(make_list(t, n))
#1
n = int(input())
a = []
for i in range(n):
a.append(i + 1)
for j in range(i):
a.append(i + 1)
for i in range(n - 1):
print(a[i], end=' ')
print(a[n - 1])
#2
n = int(input())
for i in range(1, n + 1):
print((str(i) + ' ') * i, end='')
lst = [int(i) for i in input().split()]
lst.sort(reverse=True)
print(*lst)
print(*[range(1, 6) + range(5, 0, -1) + range(6, 11) + range(10, 5, -1) + range(11, 16)] * 3)
class Neuron:
def __init__(self, weights, activation_function = lambda x: x):
self.weights = weights
self.activation_function = activation_function
self.backlog = None
def forward(self, inputs):
self.backlog = inputs
weighted_input = 0
for i in range(len(inputs)):
weighted_input += inputs[i] * weights[i]
return self.activation_function(weighted_input)
fix invalid codeTue, 28 Feb 2023 123-12-12
def row_sum(matrix):
return matrix.cumsum(axis=1)
def split_number(number):
numbers = [i for i in range(10)]
while number > 0:
digit = number % 10
if digit in numbers:
numbers.remove(digit)
else:
return False
number = int(number / 10)
return True
def calculate(number):
if number < 10 or not split_number(number):
return []
maximum = 10 ** (len(str(number)) - 1)
for i in range(maximum, 10 ** len(str(number))):
if split_number(i) and number - i > 0 and split_number(number - i):
return [i, number - i]
print(calculate(int(input())))
def f(n):
if n == 0:
return []
x = random.random()
return [x] + f(n-x)
a = int(input())
b = int(input())
if a <= b:
for i in range(a, b + 1):
if i % 2 == 0:
i = i * (-1)
print(i)
else:
print(i)
else:
for i in range(a, b - 1, -1):
if i % 2 == 0:
i = i * (-1)
print(i)
else:
print(i)
def knapsack(max_weight):
# write your code here
return 0
if __name__ == '__main__':
max_weight = int(input())
result = knapsack(max_weight)
print(result)
(𝑥𝑖−𝑥𝑗)2+(𝑦𝑖−𝑦𝑗)2
def sym(a):
l = len(a)
for i in range(l):
for j in range(l):
if a[i][j] != a[j][i]:
return False
return True
sym([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
def traffic_light_color(t):
if t % 5 < 3:
return 'green'
else:
return 'red'
traffic_light_color(5)
def padding_with_zeros(number):
return number.zfill(12)
# 12 is a length of the string
padding_with_zeros('1')
a = int(input())
b = int(input())
matrix = []
for i in range(a):
matrix.append(list(map(int, input().split())))
def sum_line(m):
summ = []
for line in m:
summ.append(sum(line))
return(summ)
def sum_column(m):
summ = []
for column in zip(*m):
summ.append(sum(column))
return(summ)
print(' '.join([str(i) for i in sum_line(matrix)]))
print(' '.join([str(i) for i in sum_column(matrix)]))
import numpy as np
def changeX(X, a = 1):
Y = np.array(X)
for i in range(len(Y)):
Y[i] = Y[i][::-1]
for j in range(len(Y[i])):
if j % 2 == 0:
Y[i][j] = a
else:
Y[i][j] = Y[i][j] ** 3
return np.concatenate((X, Y), axis = 0)
changeX(np.array([[1,2,3,4,5,6],[100,200,300,400,500,600]]))
# Define the neuron class with two methods:
class Neuron:
def __init__(self, w, f = lambda x: x):
self.w = w
self.f = f
def forward(self, x):
"""
Calculates neuron output
"""
# Your code here
return self.f(np.dot(self.w,x))
def backlog(self):
return self.x
def arithmetic(expr):
# replace all spaces
expr = expr.replace(" ", "")
# split at operators
expr_arr = re.split('\+|-', expr)
print(expr_arr)
# iterate
for num, op in zip(expr_arr[1:], expr_arr[:-1]):
if op == "-":
expr_arr[0] = str(int(expr_arr[0]) - int(num))
else:
expr_arr[0] = str(int(expr_arr[0]) + int(num))
return expr_arr[0]
arithmetic("10+25-12")
def add_to_dict(dict, key, val):
if key in dict:
dict[key].append(val)
else:
dict[key] = [val]
return dict
def birthdays():
d = {}
while True:
try:
line = input()
except EOFError:
break
if not line:
break
l = line.split()
key = l[0]
val = l[1]
d = add_to_dict(d, key, val)
return d
def print_value(values):
names = []
for i in values:
names.append(i)
return ', '.join(names)
d = birthdays()
for key in sorted(d.keys()):
print(key + ': ' + print_value(d[key]))
((x1-x2)**2 + (y1-y2)**2)**0.5
import numpy as np
def convert(X):
"""
The function converts the given array X into a new array of the form described above.
The array X is not changed.
"""
# Create a copy of the original array
Y = np.copy(X)
# Get the number of rows and columns of the array
m, n = Y.shape
# The transformation of each line of the array Y
for i in range(m):
# Replace all odd indices with the number 1
Y[i, 1::2] = 1
# Replace all even indices with their cubes
Y[i, ::2] = np.power(Y[i, ::2], 3)
# Reverse the elements in each line
Y[i] = Y[i, ::-1]
return Y
def removeEqual(a, b):
for i in a:
if i == b:
a.remove(i)
return a
m = int(input())
n = int(input())
if m == 1:
print('12', n-1)
elif n == 1:
print(m-1, 31)
elif m == 3:
print(2, n-1)
elif m == 8 or m == 5 or m == 10 or m == 12:
print(m, n-1)
else:
print(m, n-1)
if m == 12:
print('1', n+1)
elif n == 31:
if m == 1 or m == 3 or m == 5 or m == 7 or m == 8 or m == 10:
print(m+1, 1)
else:
print(m, n+1)
elif m == 2:
print(m, n+1)
else:
print(m, n+1)
def fun_1(lst_in):
result = {}
for i in lst_in:
if i[0] not in result:
result[i[0]] = [i[1:]]
else:
result[i[0]].append(i[1:])
for i in result:
print(i, ':', ', '.join(result[i]))
def get_list(raw_list):
# на входе список строк
# на выходе словарь {день:[имена]}
get_list(['3 Сергей', '5 Николай', '4 Елена', '7 Владимир', '5 Юлия', '4 Светлана'])
{3: ['Сергей'], 5: ['Николай', 'Юлия'], 4: ['Елена', 'Светлана'], 7: ['Владимир']}
def find_occurrences(s, c):
count = 0
for i in range(len(s)):
if s[i] == c:
count += 1
return count
def get_positive_sum():
total = 0
while True:
user_input = int(input('Enter a number (0 to exit): '))
if user_input == 0:
break
elif user_input < 0:
continue
else:
total += user_input
return total
get_positive_sum()
import numpy as np
def transform(X, A=1):
X = X.copy()
for i, row in enumerate(X):
X[i] = row[::-1]
for j, elem in enumerate(X[i]):
if j % 2 == 0:
X[i][j] = A * elem**3
else:
X[i][j] = A
return X
X = np.arange(1, 9).reshape(2, 4)
print(X)
print(transform(X, A=2))
def magic_square(matrix):
n = len(matrix)
total = n * (n ** 2 + 1) // 2
return all(total == sum(row) for row in matrix) and all(total == sum(col) for col in zip(*matrix)) and total == sum(matrix[i][i] for i in range(n)) and total == sum(matrix[i][n - i - 1] for i in range(n))
class Neuron:
def __init__(self, w, f = lambda x: x):
self.w = w
self.f = f
def forward(self, x):
self.x = x
return self.f(sum(self.x*self.w))
def backlog(self):
return self.x
def __call__(self, x):
return self.forward(x)
def sock(n, m):
return n + n / (m-1)
import numpy as np
def fun(n):
if n<0:
return False
n = n - 10
a = np.random.rand(10)
a = a/sum(a)*10
b = []
for i in range(10):
b.append(round(a[i],12))
return b
def is_prime(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
is_prime(7)
def solution(n, m, ar):
winner = 0
max_sum = 0
max_element = 0
sum_elements = 0
for i in range(n):
max_element = 0
sum_elements = 0
for j in range(m):
sum_elements += ar[i][j]
if ar[i][j] > max_element:
max_element = ar[i][j]
if max_element >= max_sum:
if max_element == max_sum and sum_elements < winner:
winner = i
elif max_element > max_sum:
winner = i
max_sum = max_element
return winner
n = int(input())
m = int(input())
arr = [[] for _ in range(n)]
for i in range(n):
arr[i] = list(map(int, input().split()))
print(solution(n, m, arr))
d = sqrt((x2-x1)^2 + (y2-y1)^2)
def max(n):
max = 0
for i in range(n):
a = [int(i) for i in input().split()]
for j in range(n):
if a[j] > max and i < j:
max = a[j]
return max
def func():
n = int(input())
m = []
for i in range(n):
m.append([int(j) for j in input().split()])
max_num = -float('inf')
for i in range(n):
for j in range(n):
if i > j and m[i][j] > max_num:
max_num = m[i][j]
print(max_num)
def first_digit(n):
while n > 1 and n < 10**9:
n = n * (n // 10)
return n
def fraction(n):
total = 0
for i in range(1, 11):
total += (i / 10)
print(total)
assert total == n
fraction(2)
n = int(input())
a = 0
b = 0
while a + b <= n:
b = int(input())
if a + b <= n:
a += b
else:
break
print("Enough!")
print(a)
n = int(input())
m = int(input())
a = []
for i in range(n):
a.append(list(map(int,input().split())))
maximum = -100
for i in range(n):
for j in range(m):
if a[i][j] > maximum:
maximum = a[i][j]
winner = i
if a[winner].count(maximum) >= 2:
m = 0
for k in range(m):
m += a[winner][k]
for i in range(n):
s = 0
for j in range(m):
s += a[i][j]
if s > m:
m = s
winner = i
print(winner)
def square_list(list):
return [num ** 2 for num in list]
square_list([1, 2, 3, 4, 5])
def convert_to_list(a):
return [str(i) for i in a[0][::-1]]
convert_to_list([[1, 2], [3, 4]])
N, M = map(int, input().split())
m1 = []
for i in range(N):
m1.append(list(input()))
cnt = 0
for i in range(N):
for j in range(M):
flag = True
if m1[i][j] == ".":
if i > 0 and m1[i - 1][j] == "*":
flag = False
if i < N - 1 and m1[i + 1][j] == "*":
flag = False
if j > 0 and m1[i][j - 1] == "*":
flag = False
if j < M - 1 and m1[i][j + 1] == "*":
flag = False
if flag:
cnt += 1
print(cnt)
def matrix():
n = int(input())
a = []
for i in range(n):
a.append([int(s) for s in input().split()])
res = -100
for i in range(n):
for j in range(n):
if i > j and a[i][j] > res:
res = a[i][j]
print(res)
matrix()
def numbers(n):
digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for i in range(10):
for j in range(10):
for k in range(10):
for l in range(10):
for m in range(10):
for o in range(10):
for p in range(10):
for q in range(10):
for r in range(10):
for s in range(10):
if digits[i] + digits[j] + digits[k] + digits[l] + digits[m] + digits[o] + digits[p] + digits[q] + digits[r] + digits[s] == n:
n1 = digits[i]
n2 = digits[j]
n
def func(n):
a = n
while n > 10 and n < 1000000000:
n *= n // 10
return n
def sock_pairs(n, m):
total_days = 0
all_socks = n
# loop till there are socks
print("Here are all the socks: ", all_socks)
while all_socks > 0:
all_socks = all_socks - 1
print("I took 1 sock, so now I have: ", all_socks)
total_days = total_days + 1
if total_days % m == 0:
all_socks = all_socks + 1
print("It's ", total_days, " days, so I have a new sock, so now I have: ", all_socks)
print("total days", total_days)
return total_days
sock_pairs(5, 2)
def sum_array(array):
# проверка на размерность массива
if len(array) < 1 or len(array[0]) < 1:
return 0
# определяем размерность массива
n = len(array)
m = len(array[0])
# рассчитываем суммы в строках и столбцах
sums_line = [sum(array[i]) for i in range(n)]
sums_column = [sum([array[i][j] for i in range(n)]) for j in range(m)]
return sums_line, sums_column
print(*sum_array([[1, 2, 3], [4, 5, 6
n = int(input())
home = []
away = []
for i in range(n):
h, a = map(int, input().split())
home.append(h)
away.append(a)
count = 0
for i in range(n):
for j in range(n):
if i != j and home[i] == away[j]:
count += 1
print(count)
def occurs(s, c):
return s.count(c)
occurs('hello', 'l')
def devide_ten(n):
list = []
for i in range(10):
list.append(round(n/10, 12))
n = n - n/10
return list
devide_ten(50)
def del_dublicate_words(s):
my_list = s.split()
my_list = list(set(my_list))
return ' '.join(my_list)
import random
def rand_num(x):
return random.random() * x
rand_num(5)
a = [1, 2, 3, 4, 4, 5, 5, 6]
b = []
d = {}
for i in a:
if i not in d:
d[i] = True
b.append(i)
print(b)
# напишите функцию, которая возвращает матрицу с образцом
def matrix_pattern(n, m):
return matrix
# напишите функцию, которая выводит матрицу с образцом на экран
def print_matrix_pattern(n, m):
matrix = matrix_pattern(n, m)
for i in range(n):
for j in range(m):
print('{}'.format(matrix[i][j]), end=' ')
print()
n, m = map(int, input().split())
print_matrix_pattern(
s = tuple(map(int, input().split()))
s1 = []
for i in s:
if i not in s1:
s1.append(i)
print(*s1)
n = input()
result = 0
for i in range(10):
num = round(random.random(), 12)
result += num
print(num)
print(result)
n = int(input())
things = {'карандаш': 20, 'зеркальце': 100, 'зонт': 500, 'рубашка': 300,
'брюки': 1000, 'бумага': 200, 'молоток': 600, 'пила': 400, 'удочка': 1200,
'расческа': 40, 'котелок': 820, 'палатка': 5240, 'брезент': 2130, 'спички': 10}
def choose_things(things, n):
res = []
things = {k: v for k, v in sorted(things.items(), key=lambda item: item[1], reverse=True)}
for item, value in things.items():
if value <= n:
def sum_of_ten(n):
total = 0
for i in range(0, 10):
total += n
return total
sum_of_ten(0.7)
def knee(name):
print("The back of the knee is the " + name)
knee("popliteal fossa")
def create_dict(list_of_strings):
lst = []
for i in list_of_strings:
lst.append(i.split())
dic = {}
for j in lst:
dic[j[0]] = dic.get(j[0], '') + j[1] + ', '
for i in dic.keys():
dic[i] = dic[i][0:-2]
return dic
def sum_ten(n):
if n < 0:
return "Negative number"
if n == 0:
return "0"
n = n / 10
return n + n + n + n + n + n + n + n + n + n
sum_ten(100)
n, m = [int(s) for s in input().split()]
matrix = [[0 for x in range(m)] for y in range(n)]
for i in range(n):
for j in range(m):
if i == 0:
matrix[i][j] = j+1
elif i == 1:
matrix[i][j] = matrix[i-1][j] + i
else:
matrix[i][j] = matrix[i-1][j] + i + 1
for row in matrix:
for elem in row:
print(str(elem).ljust(3), end = '')
print()
def cumsum_and_erase(A, erase = 1):
partial = 0
B = []
for num in A:
partial += num
if partial != erase:
B.append(partial)
else:
partial = 0
return B
def Vasya(n, m):
if n >= m:
return m
else:
return n
Vasya(5, 4)
def encode(a):
c = []
index = 0
a_len = len(a)
while index < a_len:
c.append(a[index])
b = 1
while index + 1 < a_len and a[index] == a[index + 1]:
index += 1
b += 1
c.append(b)
index += 1
c = np.array(c)
return c[0::2], c[1::2]
encode(np.array([1,2,2,3,3,1,1,5,5,2,3,3,3,2,2]))
def run(x):
day = 1
run = 10
while run < x:
run += run * 0.1
day += 1
return day
run(int(input()))
n, m = [int(i) for i in input().split()]
a = []
for i in range(n):
b = []
for j in range(m):
b.append(0)
a.append(b)
print(a)
def chess(n, m):
matrix = [['.'] * m for i in range(n)]
x, y = 0, 0
symbol = '*'
value = '.'
while x < n and y < m:
matrix[x][y] = symbol
y += 1
x += 1
if x == n or y == m:
x -= 1
y -= 1
while x > 0 and y > 0:
x -= 1
y -= 1
if y == m - 1 and x >= 0:
x += 2
y -= 1
if x == n - 1 and y <= m - 1:
x -= 1
y += 2
symbol, value = value, symbol
for row in matrix:
print(' '.join(row))
row, col = input().split()
chess(int(row), int(col))
file = open('birth_days.txt', 'r')
dict = {}
for line in file:
month, name = line.split()
if month not in dict:
dict.update({month: [name]})
else:
dict[month].append(name)
for key, value in dict.items():
print(f'{key}: {", ".join(value)}')
def spiral(n):
dx, dy = 1, 0 # Starting increments
x, y = 0, 0 # Starting location
myarray = [[None]* n for j in range(n)]
for i in range(n**2):
myarray[x][y] = i
nx, ny = x+dx, y+dy
if 0 <= nx < n and 0 <= ny < n and myarray[nx][ny] == None:
x, y = nx, ny
else:
dx, dy = -dy, dx
x, y = x+dx, y+dy
return myarray
n = int(input())
for x in spiral(n):
print(*x)
a = [int(i) for i in input().split()]
def f(a):
b = []
if len(a) == 1:
b.append(a[0])
else:
b.append(a[-1] + a[1])
for i in range(1, len(a) - 1):
b.append(a[i - 1] + a[i + 1])
b.append(a[0] + a[-2])
return b
print(' '.join([str(i) for i in f(a)]))
def addMatrix(matrix1, matrix2):
for i in range(len(matrix1)):
for j in range(len(matrix1[0])):
matrix1[i][j] += matrix2[i][j]
return matrix1
n, m = map(int, input().split())
matrix1 = []
matrix2 = []
for i in range(n):
matrix1.append(list(map(int, input().split())))
input()
for i in range(n):
matrix2.append(list(map(int, input().split())))
addMatrix(matrix1, matrix2)
for i in matrix1:
for x in i:
print(x, end=' ')
print()
def matrix(a, b):
matrix = [[0] * b for i in range(a)]
for i in range(a):
matrix[i] = [int(x) for x in input().split()]
for i in range(1, a):
for j in range(1, b):
if matrix[i][0] == 0 and matrix[0][j] == 0:
matrix[i][j] = 0
elif matrix[i][0] == 0:
matrix[i][j] = matrix[i][j - 1]
elif matrix[0][j] == 0:
matrix[i][j] = matrix[i - 1][j]
else:
matrix[i][j] = matrix[i][j - 1] + matrix[i - 1][j]
for j in range(a):
for i in range(b):
print(matrix[j][i], end=' ')
print()
3: Сергей
5: Николай, Юлия
4: Елена, Светлана
7: Владимир
def find_number(n):
i = 1
while i * i <= n:
i += 1
return i
find_number(100)
import numpy as np
def array_transformation(x):
x = np.asarray(x)
a = np.arange(0, x.size, 2)
b = np.arange(1, x.size, 2)
x[a] = x[a] ** 3
x[b] = 1
x[::-1]
return x
# test case
array_transformation([[1, 2, 3], [4, 5, 6]])
word = input()
i = 0
while i < len(word):
if word[i] in 'ae':
print("Aha!")
break
print("Current letter: ", word[i])
i += 1
else:
print("Printed out all the letters")
import numpy as np
def matrix (mat):
mat=np.array(mat)
for i in range(len(mat)):
for j in range(len(mat[1])):
if i+j==len(mat)-1:
print(max(mat[:,j]))
matrix([[1,2,3],[4,5,6],[7,8,9]])
def cities(a, b):
return a[-1] == b[0] or a[-2] == b[0] and a[-1] == 'f'
cities('Moscow', 'Nagoya')
# -*- coding: utf-8 -*-
import itertools
def func(n):
n = round(n,8)
n = str(n).split('.')[1]
n = n[:4]
lst = list(itertools.combinations(range(10), 4))
lst = [i[:2] for i in lst if i[2] == i[3] and i[0] != i[1] and i[0]!=0 and i[1]!=0]
lst = [i[0]*10 + i[1] for i in lst]
lst = [1.0*int(n[i:i+2])/100 for i in range(len(n)) if i % 2 == 0]
s = sum(lst)
lst = [0.01*i for i in lst]
lst.append(n-s)
return lst
from random import randint
from random import uniform
def rand_num(n):
return uniform(0, n)
rand_num(1.5)
def make_seating(input_values_list):
people_count = 0
days_count = 0
seating_map = list()
day_seating = list()
tables_seating_map = list()
if len(input_values_list) >= 4:
people_count = int(input_values_list[0])
days_count = int(input_values_list[1])
tables_count = int(input_values_list[2])
tables_seating_map = list(map(int, input_values_list[3:]))
if sum(tables_seating_map) != people_count:
return None
seating_map = make_seating_list(tables_seating_map, people_count, days_count)
if len(seating_map) == 0:
return None
else:
return None
return seating_map
def make_seating_list(tables_seating_map
def f(x):
return ...
n = int(input())
for i in range(n):
x = int(input())
print(f(x))
max_people = 1
n = int(input("Введите количество людей: "))
m = int(input("Введите количество дней: "))
k = int(input("Введите количество столов: "))
days = list()
for i in range(0, m):
days.append([])
for z in range(0, k):
days[i].append([])
for j in range(0, int(input("Введите количество мест за " + str(z + 1) + "-м столом: "))):
days[i][z].append(j + 1)
for i in range(0, m):
print
def date(m, n):
if n - 1 != 0:
n -= 1
else:
n = 30
if m - 1 != 0:
m -= 1
if n + 1 <= 30:
n += 1
else:
n = 1
if m + 1 <= 12:
m += 1
return m, n
date(12, 31)
def input_number():
sum = 0
while True:
number = int(input())
if number == 0:
return sum
sum += number
input_number()
def cumsum_and_erase(A, erase=1):
#YOUR CODE
B = [0 for _ in range(len(A))]
B[0] = A[0]
for i in range(1,len(A)):
B[i] = B[i-1] + A[i]
while erase in B:
B.remove(erase)
return B
A = [5, 1, 4, 5, 14]
B = cumsum_and_erase(A, erase=10)
assert B == [5, 6, 15, 29], "Something is wrong! Please try again"
def grad_descent_2d(func, low, high, start=None, callback=None):
"""
Gradient Descent Implementation for Functions of Two Variables
with few local minima but known square neighborhood
global minimum. All tests will be of this nature.
Note that the function gradient is not given here.
It must be calculated approximately.
:param func: np.ndarray -> float - function
:param low: the left margin of the interval along each of the axes
:param high: the right limit of the interval along each of the axes
"""
eps=1e-10
df = numerical_derivative_2d(func, eps)
<YOUR CODE>
return <YOUR CODE>
def sum(n):
s = 0
while True:
a = int(input())
s += a
if s > n:
print("Enough!")
print(a)
print(s-a)
break
return s
sum(100)
n = int(input())
m = int(input())
a = [int(input()) for _ in range(n)]
b = [int(input()) for _ in range(m)]
c = a + b
for i in range(len(c)):
m = min(c)
print(m, end=' ')
c.remove(m)
print()
r = (x 1−x 2)2+(y 1−y 2)2
import random
def f(n):
k = 0
while k < 10:
r = random.random()
if r + sum(lst) > 1:
continue
lst.append(r)
k += 1
return lst
print(f(0.9))
def putin_info():
print("Vladimir Putin")
print("Born in 1952")
print("President of Russia")
putin_info()
import random
n = int(input()) # вводим число
lst = [] # инициализирую список для накопления значений
while n != 0 and len(lst) < 10:
a = random.randrange(1, n, 12) # создаем случайное двенадцатизначное число меньше n
lst.append(('0.' + str(a).zfill(12))) # заполнить число нулями слева если нет 12 порядков и д
def random_range(n):
return random.choice(range(n))
random_range(10)
let random_range = n => random.choice(range(n))
random_range(10)
D = sqrt((x2 - x1)**2 + (y2 - y1)**2).
def cities(a, b):
if a[-1].upper() == b[0].upper() and a[-1].upper() != 'F':
return 'Good'
elif a[-2].upper() == b[0].upper():
return 'Good'
else:
return 'Bad'
cities('Moscow', 'London')
cities('London', 'Washington')
cities('Sofia', 'Whashington')
def mult35(n):
if n >= 100:
print("n is too large")
elif n < 100:
i = 1
while i <= n:
if i % 3 == 0 and i % 5 == 0:
print(i, end=" ")
i += 1
def vasya(n, m):
return n + (m - n % m)
vasya(1, 2)
def reverse_pyramid(n):
for i in range(n, 0, -1):
print(' '.join([str(x) for x in range(1, i + 1)]))
reverse_pyramid(int(input()))
def func(n):
a = 0
str_a = ''
i = 1
while a < n:
i += 1
if n - a - i > 1:
a += i
str_a += str(i) + ' + '
else:
str_a += str(n - a)
break
return str_a
print(func(18))
n = int(input("Input a natural number: "))
def squareroot(n):
sqrt=1
while sqrt*sqrt<=n:
sqrt+=1
return sqrt
squareroot(n)
def convert(array, a=1):
new_array = []
for i in array:
new_array.append(i**3)
new_array.append(a)
new_array.reverse()
return array + new_array
convert([1, 2, 3])
def transformation(X, A=1):
'''
X: np.array [num_row, num_column] --- matrix-argument
a: float --- meaning for converting odd elements of lines into x
Returns: np.array [num_row, num_column*2] --- Matrix, where the lines are
flexible lines of the original matrix X with lines, which are their transformations
The function takes on the input matrix X dimensions n x m, the number a and
Returns the matrix with dimensions n x m*2, the i-th line of which is glued
I-th line X with its transformation of its line Transformation (X [I]), written in the reverse order,
where the transformation for the number K is defined as:
Transformation (k) = a if ind (k) % 2 == 0 else k ** 3
In the implementation of this function, it is necessary to use the functionality of the Numpy package
'''
return X
def count_up(n):
n = n + 1
count = 1
while n > count*count:
count += 1
return count
count_up(4)
def backpack(n, *args):
vol = 0
i = 0
for arg in args:
i += 1
vol += arg
if vol > n:
print("Enough!")
print("%d" %(i-1))
print("%d" %(vol-arg))
break
backpack(10, 10, 10, 10)
def func(n):
result = []
for i in range(1, n+1):
result.append(i)
result.append(i)
result.append(i)
return result
n, m = int(input()), int(input())
a = [[0] * m for i in range(n)]
k = 1
for j in range(m):
for i in range(n):
a[i][j] = k
k += 1
for row in a:
print(' '.join([str(elem).ljust(3) for elem in row]))
table = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
def flatten(table):
return [item for subtable in table for item in subtable[::-1]]
print(flatten(table))
def multiply(a, b):
# TODO: your code here
return c
pass
def multiply_numpy(a, b):
# TODO: your code here
return c
pass
def sum(n):
a = 10
q = n/a
r = n%a
for i in range(0,a-1):
x = q*10
y = int(x)
x = x-y
x = x*10
print(x)
n = n-x
print(n)
sum(100.123456789012)
def list_sum(list_):
if len(list_) == 1:
return list_[0]
else:
if len(list_) == 2:
return list_[0] + list_[1]
else:
return list_[0] + list_[-1]
lst = list(map(int, input().split()))
lst_ = [list_sum(lst[:i] + lst[i+1:]) for i in range(len(lst))]
print(' '.join(map(str,lst_)))
def find_record(string):
counter, prev_char, max_count = 1, '', 0
for char in string:
if char == prev_char:
count += 1
else:
prev_char = char
count = 1
if count > max_count:
max_count = count
return max_count
find_record('hahahahahahahahah') # => 13
import sys
# считывание списка из входного потока
lst_in = list(map(str.strip, sys.stdin.readlines()))
# считывание дней для словаря
days = list(map(lambda x: int(x.split()[0]), lst_in))
# считывание имен для словаря
names = list(map(lambda x: x.split()[1], lst_in))
# словарь
b_dict = {}
for i in range(len(days)):
b_dict[days[i]] = b_dict.get(days[i], '') + ', ' + names[i]
# вывод дл
r = (x 1−x 2) 2 +(y 1−y 2) 2
subscribers = '10 4 5 4 12 18'
subscribers = list(map(int, subscribers.split()))
print(max(subscribers), min(subscribers), sum(subscribers))
def random_number(n):
return "{:.12f}".format(random.random() * n)
import requests
from docx import Document
def create_doc(text):
document = Document()
document.add_heading('Pogoda v Moskve', 0)
document.add_paragraph(text)
document.save('pogoda.docx')
url = 'http://wttr.in/Moscow'
response = requests.get(url)
create_doc(response.text)
def pack(N):
things = {'карандаш': 20, 'зеркальце': 100, 'зонт': 500, 'рубашка': 300,
'брюки': 1000, 'бумага': 200, 'молоток': 600, 'пила': 400, 'удочка': 1200,
'расческа': 40, 'котелок': 820, 'палатка': 5240, 'брезент': 2130, 'спички': 10}
items = sorted(things.items(), key=lambda x: x[1], reverse=True)
res = []
for i in range(len(items)):
res.append(items[i][0])
if sum(items[:i+1]) > N:
import os
def print_version():
os.system("python --version")
print_version()
def get_last_value(matrix, n, m, i, j, answer):
if (n - 1) == i and (m - 1) == j:
return answer + matrix[i][j]
if (n - 1) == i:
return get_last_value(matrix, n, m, i, j + 1, answer + matrix[i][j])
if (m - 1) == j:
return get_last_value(matrix, n, m, i + 1, j, answer + matrix[i][j])
return get_last_value(matrix, n, m, i, j + 1, answer + matrix[i][j])
def fill_matrix(matrix, n, m, i, j, answer):
if (n - 1) == i and (m - 1) == j:
return answer + matrix[i][j]
if (n - 1) == i:
return get_last_value(matrix, n, m, i, j + 1, answer + matrix
def repeated_characters(s):
res = []
for i in s:
if s.count(i) > 1:
if i not in res:
res.append(i)
return res
repeated_characters('AaBbCcDd')
n = int(input())
for i in range(n):
for j in range(n):
if i == 0 or j == 0 or i == n - 1 or j == n - 1:
print(1, end=' ')
else:
print(0, end=' ')
print()
def trace(n: int, mat: list) -> int:
sum = 0
for i in range(0, n):
sum += mat[i][i]
return sum
import sys
# считывание списка из входного потока
lst_in = list(map(str.strip, sys.stdin.readlines()))
# ваша основная логика здесь
# пример:
# печать обратного входного списка
for s in lst_in[::-1]:
print(s)
def version():
version = sys.version
print(version)
def max(matrix):
n = len(matrix)
max_element = matrix[0][0]
for i in range(n):
for j in range(n):
if i > j:
if matrix[i][j] > max_element:
max_element = matrix[i][j]
return max_element
matrix = [[1, -2, 3], [4, -5, 6], [7, -8, 9]]
print(max(matrix))
def cities (a, b):
return a[-1] == b[0]
cities('Moscow', 'Piter')
3
n = int(input('Количество людей: '))
m = int(input('Количество дней: '))
k = int(input('Количество столов: '))
tables = [[] for _ in range(k)]
for day in range(1, m + 1):
print(f'\nДень {day}:')
for table in range(1, k + 1):
tables[table - 1].append(table)
print(f'\tНа столе {table} сидят люди с номерами: {tables[table - 1]}')
if len(tables[table - 1]) == n:
tables[table - 1] = []
def my_matmul(X, Y):
result = [[0 for i in range(len(Y[0]))] for j in range(len(X))]
for i in range(len(X)):
for j in range(len(Y[0])):
for k in range(len(Y)):
result[i][j] += X[i][k] * Y[k][j]
return result
my_matmul([[1,2], [3,4]], [[2,0], [1,2]])
def numpy_matmul(X, Y):
return np.matmul(X, Y)
numpy_matmul(np.array([[1,2], [3,4]]), np.array([[2,0], [1,2]]))
n, m = map(int, input().split())
a = [[int(i) for i in input().split()] for j in range(n)]
for i in range(1, n):
for j in range(1, m):
if a[i][0] == 0:
a[i][0] = a[i - 1][0]
if a[0][j] == 0:
a[0][j] = a[0][j - 1]
if a[i][j] == 0 and a[i][0] != 0 and a[0][j] != 0:
a[i][j] = a[i - 1][j] + a[i][j - 1]
print(a[i][j], end=' ')
print()
def myhash(string):
h = 0
for ch in string:
h += ord(ch)
return h
myhash('hello')
def ten_numbers(n):
import random
list_10 = []
n1 = round(n/10 - random.randint(0, 10) / 1000, 12)
print(n1)
n2 = round(n1 - random.randint(0, 10) / 1000, 12)
print(n2)
n3 = round(n2 - random.randint(0, 10) / 1000, 12)
print(n3)
n4 = round(n3 - random.randint(0, 10) / 1000, 12)
print(n4)
n5 = round(n4 - random.randint(0, 10) / 1000, 12)
print(n5)
n6 = round(n5 - random.randint(0, 10) / 1000, 12)
print(n6)
n7 = round(n6 - random.randint(0, 10) / 1000, 12)
print(n7)
n8 = round(n7 - random.
from decimal import Decimal
def func(n):
a = Decimal(str(n))
b = Decimal(str(n)) / 10
c = Decimal(str(n)) / 100
d = Decimal(str(n)) / 1000
e = Decimal(str(n)) / 10000
f = Decimal(str(n)) / 100000
g = Decimal(str(n)) / 1000000
h = Decimal(str(n)) / 10000000
i = Decimal(str(n)) / 100000000
j = Decimal(str(n)) / 1000000000
return [a, b, c, d, e, f, g, h, i, j]
func(4)
import os
def find_picture(path):
if os.path.isfile(path):
return path
elif os.path.isdir(path):
for root, dirs, files in os.walk(path):
for file in files:
if file.endswith('.jpg') or file.endswith('.png'):
return os.path.join(root, file)
return None
else:
return None
find_picture('/home/user/Pictures')
def max_element(n):
matrix = []
for i in range(n):
matrix.append([int(x) for x in input().split()])
max_elem = 0
for i in range(n):
for j in range(n):
if i > j:
if matrix[i][j] > max_elem:
max_elem = matrix[i][j]
return max_elem
print(max_element(int(input())))
n, m = [int(s) for s in input().split()]
MATRIX = [[0] * m for i in range(n)]
dx, dy = [0, 1, 0, -1], [1, 0, -1, 0]
x, y, c = 0, -1, 1
for i in range(n+m-1):
for j in range((n+m-i)//2):
x += dx[i % 4]
y += dy[i % 4]
MATRIX[x][y] = c
c += 1
for row in MATRIX:
print(*row)
a = tuple(map(int, input().split()))
b = []
for i in range(len(a)):
for j in range(i + 1, len(a)):
if a[i] == a[j]:
b.append(i)
b.append(j)
print(*b)
n, m = map(int, input().split())
a = [[0] * m for i in range(n)]
x, y = 0, 0
dx, dy = 0, 1
for i in range(1, n * m + 1):
a[x][y] = i
nx, ny = x + dx, y + dy
if 0 <= nx < n and 0 <= ny < m and not a[nx][ny]:
x, y = nx, ny
else:
dx, dy = -dy, dx
x, y = x + dx, y + dy
for i in range(n):
for j in range(m):
print(str(a[i][j]).ljust(len(str(n*m))), end=' ')
print()
def get_people_at_tables_by_days(people_count, days_count, tables_count):
if people_count <= 0 or days_count <= 0 or tables_count <= 0:
return []
# в первый день каждый люди сидят на своем месте
# количество столов должно быть больше людей
people_at_tables_by_days = [[[x] for x in range(1, people_count+1)]]
if days_count > 1:
# делим количество людей на количество столов
def function(n, m):
matrix = []
for i in range(n):
matrix.append(list((map(int, input().strip().split()))))
m = int(input())
for i in range(m):
matrix = multi_matrix(matrix, matrix)
for el in matrix:
for el2 in el:
print(el2, end=' ')
print()
def multi_matrix(a, b):
res_matrix = [[0] * len(a) for _ in range(len(a[0]))]
for i in range(len(a)):
for j in range(len(b)):
for k in range(len(b[0])):
res_matrix[i][j] += a[i][k] * b[k][j]
return res_matrix
n = int(input())
m = int(input())
function(n, m)
def backpack(n):
volume = []
count = 0
while True:
volume_in = int(input())
if volume_in > n:
print("Enough!")
print(count, volume_in)
break
else:
volume.append(volume_in)
count += 1
def x_to_neg(x):
return 2**x-1
x_to_neg(16)
def encode(arr):
unique, count = np.unique(arr, return_counts=True)
return unique, count
encode(np.array([1, 2, 2, 3, 3, 1, 1, 5, 5, 2, 3, 3, 3]))
import numpy as np
def max_below_diagonal(matrix):
"""Write a program that prints the maximum element in the area below the main diagonal of a square matrix."""
n = len(matrix)
m = np.zeros([n,n])
for i in range(n):
for j in range(n):
m[j][i] = matrix[j][i]
m = m.flatten('F')
m = m[:n*n-n]
return np.max(m)
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
max_below_diagonal(matrix)
def generate_batches(X, y, batch_size):
"""
param X: np.array[n_objects, n_features] --- матрица объекты-признаки
param y: np.array[n_objects] --- вектор целевых переменных
"""
assert len(X) == len(y)
np.random.seed(42)
X = np.array(X)
y = np.array(y)
perm = np.random.permutation(len(X))
for batch_start in range(0, len(X), batch_size):
batch_indices = perm[batch_start:batch_start + batch_size]
yield X[batch_indices], y[batch_indices]
def divisors(n):
a = []
for i in range(1,n):
if n % i == 0:
a.append(i)
print(sum(a))
return a
divisors(120)
def update_pip():
!pip install --upgrade pip
return pip.__version__
update_pip()
def lucky_ticket(ticket_number):
# put your code here
pass
lucky_ticket(123006) == 'Счастливый'
lucky_ticket(12321) == 'Несчастливый'
lucky_ticket(436751) == 'Несчастливый'
def f(n):
if n>=10 and n<=100:
return True
else:
return False
def f1(num):
num = [i for i in range(10, 100) if f(i)]
return num
def f2(m):
m = [i for i in range(10, 100) if f(i)]
return m
def f3(n):
n = [i for i in range(10, 100) if f(i)]
return n
def f4(num):
num = [i for i in range(10, 100) if f(i)]
return num
def f5(num):
num = [i for i in range(10, 100) if f(i)]
return num
def f6(num):
num = [i for i in range(10, 100) if f(i)]
return num
def f7(num):
num = [i for i in range(10, 100) if f(i
def count_number(n):
sum = 0
count = 0
while True:
add_number = int(input())
sum += add_number
count += 1
if sum >= n:
return print('Enough!,', sum - add_number, count - 1)
print(count_number(15))
class Neuron():
def __init__(self, w: 'array of weights', f=lambda x: x):
self.w = w
self.f = f
self.x = None
def forward(self, x: "array of inputs"):
self.x = x
return self.f(sum([a*b for a, b in zip(self.w, x)]))
def last_input(self):
if self.x is not None:
return self.x
else:
return None
n = int(input())
for i in range(n, 0, -1):
print(*[j for j in range(1, i + 1)])
a, b, c, d = (int(input()) for _ in range(4))
for i in range(c, d + 1):
print('\t', i, end='')
print()
for i in range(a, b + 1):
print(i, end='\t')
for j in range(c, d + 1):
print(i * j, end='\t')
print()
def f(n):
if n == 1:
return 1
elif n > 10**9:
return -1
elif n <= 0:
return -1
else:
n = n * int(str(n)[0])
return f(n)
f(555)
n = int(input())
sum = 0
count = 0
while True:
x = int(input())
sum += x
count += 1
if sum >= n:
break
print('Enough!')
print(sum)
print(count)
def is_prime(n):
if n == 2 or n == 3:
return "Yes"
elif n < 2 or n > 3:
for i in range(2, n):
if n % i == 0:
return "No"
return "Yes"
else:
return "No"
def matrix(n):
for i in range(n):
for j in range(n):
if i == 0 or j == 0 or i == n-1 or j == n-1:
print('1', end = ' ')
else:
print('0', end = ' ')
print()
def rotate_matrix(matrix):
m = len(matrix)
n = len(matrix[0])
ret = [[0]*m for _ in range(n)]
for i in range(m):
for j in range(n):
ret[j][m-1-i] = matrix[i][j]
return ret
def vasya(n, m):
count = 0
sock_count = n
while sock_count >= m:
sock_count -= m - 1
count += 1
return count
vasya(2, 3)
import random
import math
import decimal
def get_nums(n):
nums = []
remain = n
for i in range(10):
if remain <= 0:
num = 0
elif i == 9:
num = remain
else:
num = round(remain * random.random(), 12)
nums.append(num)
remain = remain - num
return nums
get_nums(1.23)
def day_of_week(k):
if k < 1 or k > 365:
return None
days_in_year = 365
days_elapsed = k % days_in_year
day = (days_elapsed + 1) % 7
day_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
return day_of_week[day]
day_of_week(10)
def R(X, a):
return np.hstack((X, np.apply_along_axis(lambda x: np.hstack((x, np.where(x % 2 == 0, a, x ** 3))), 1, X).reshape(X.shape[0], 2 * X.shape[1])))
first = input()
second = input()
if first[-1] == second[0] and first[-1] != 'f':
print("Good")
elif first[-1] == second[0] or first[-2] == second[0]:
print("Good")
else:
print("Bad")
def remove_elements_while(char_list, char):
for i in range(0, len(char_list)):
if char_list[i] == char:
del char_list[i]
break
return char_list
remove_elements_while(['a', 'b', 'c', 'd', 'e', 'f'], 'd')
def max_elem(n, m, matrix):
max_num = 0
index = []
for i in range(n):
for j in range(m):
if matrix[i][j] > max_num:
max_num = matrix[i][j]
index = [i, j]
return index
n = int(input())
m = int(input())
matrix = [[int(j) for j in input().split()] for i in range(n)]
print(*max_elem(n, m, matrix))
def add_sequence():
sum = 0
while True:
num = int(input('> '))
if num == 0:
break
else:
sum += num
print(sum)
def sum_to_n(n):
total = 0
for i in range(10):
x = round(n/10, 12)
total += x
return total
sum_to_n(1.123456789)
def power_of_two(n):
i = 0
while 2 ** i <= n:
if 2 ** i == n:
print(i)
break
i += 1
else:
print("no")
power_of_two(16)
def calc(n, m):
days = 0
for i in range(0, n):
if i % m == 0:
days += 1
return days
print(calc(int(input().split()[0]), int(input().split()[1])))
def check_num(x):
return int(x) == int(''.join(sorted(x)))
check_num('123')
def SwapDiagonals(n,matrix):
for i in range(n):
matrix[i][i], matrix[i][n - 1 - i] = matrix[i][n - 1 - i], matrix[i][i]
return matrix
n = int(input())
matrix = []
for i in range(n):
matrix.append(list(map(int, input().split())))
print(SwapDiagonals(n, matrix))
import random
def print_ten(x):
r = random.Random()
r.seed(x * x * x * x * x)
random_nums = []
for i in range(10):
random_nums.append(r.random())
print(random_nums)
print_ten(10)
def max_matrix_element(n):
if n < 2:
return None
matrix = []
for i in range(n):
matrix.append(list(map(int, input().split())))
for i in range(n-1):
for j in range(n-1):
if matrix[i][j] < matrix[j][i] and i > j:
matrix[i][j] = -1
return matrix
max_matrix_element(3)
# ввод данных
m, n = (int(i) for i in input().split())
spiral = [[0] * n for i in range(m)]
# функция для прохода по спирали
def go_spiral(spiral, start, end, i, j, status):
if (end < start): return
if (status == 'right'):
while (j < end):
spiral[i][j] = start
j += 1
start += 1
i += 1
j -= 1
go_spiral(spiral, start, end, i, j, 'down')
if (status == 'down'):
while (i < end):
spiral[i][j] = start
i += 1
start += 1
i -= 1
j -= 1
go_spiral(spiral, start, end, i, j,
# Решение предыдущего задания
def birthday(n, m, k):
seats = []
for i in range(k):
seats.append(int(input(f"Введите количество мест за {i+1}-м столом: ")))
guests = [i+1 for i in range(n)]
for day in range(1, m+1):
print(f"День {day}:")
for table in range(k):
table_guests = guests[:seats[table]]
guests = guests[seats[table]:]
print(f" На столе {table+1} сидят люди с номерами: {table_guests}")
if not guests
def socks(n, m):
return n + (n-1) / m
socks(5, 3)
def build_pyramid(n):
return math.floor((1+8*n)**0.5)//2
build_pyramid(5)
import numpy as np
def encoding(a):
a = np.array(a)
i = 0
b = []
c = []
for j in range(len(a)):
if a[j] == a[i]:
c.append(a[i])
else:
b.append(len(c))
c = []
i = j
b.append(len(c))
return np.array([a[:len(a)-1], b])
n, m = [int(i) for i in input().split()]
a = [[0] * m for i in range(n)]
for i in range(n):
for j in range(m):
a[i][j] = n * j + i + 1
for row in a:
for elem in row:
print(elem, end=" ")
print()
def no_numpy_mult(first, second):
"""
param first: list of "size" lists, each contains "size" floats
param second: list of "size" lists, each contains "size" floats
"""
#YOUR CODE: please do not use numpy
result = #YOUR CODE: create list of lists, not np.array
return result
def numpy_mult(first, second):
"""
param first: np.array[size, size]
param second: np.array[size, size]
"""
#YOUR CODE: please use numpy
result = #YOUR CODE: create np.array
return result
#### 函数多返回值
def foo():
print('hello')
return 1, 2, 3
a, b, c = foo()
print(a, b, c) # 1 2 3
print(foo()) # hello (1, 2, 3)
a, b,
def salary(first, second, third):
return max(first, second, third) - min(first, second, third)
salary(12000, 10000, 5000)
def cities(a, b):
return a[-1] == b[0] or a[-2] == b[0]
cities("Москва", "Ташкент")
row, col = int(input()), int(input())
def create_table(row, col, start):
a = []
for i in range(row):
b = []
for j in range(col):
b.append(start)
start += 1
if start == row + 1:
start = 1
a.append(b)
return a
def print_table(a):
for i in range(len(a)):
b = ''
for j in range(len(a[i])):
b += str(a[i][j]).ljust(3)
print(b)
print_table(create_table(row, col, 1))
def wage_diff(w1, w2, w3):
return max(w1, w2, w3) - min(w1, w2, w3)
wage_diff(1, 2, 3)
def get_winner(a, n, m):
max_sum = 0
winner = 0
max_num = 0
for i in range(n):
curr_max = 0
sum = 0
for j in range(m):
sum += a[i][j]
if a[i][j] > curr_max:
curr_max = a[i][j]
if sum > max_sum:
max_sum = sum
winner = i
max_num = curr_max
elif sum == max_sum and curr_max > max_num:
winner = i
max_num = curr_max
return winner
The function run_length_encoding takes an array, flattens and encodes it using run-length encoding, and returns the encoded values and the counts.
def is_prime(N):
if N == 1:
return 'No'
i = 2
while i * i <= N:
if N % i == 0:
return 'No'
i += 1
return 'Yes'
is_prime(4)
def creat_matrix(n, m):
matrix = [[0] * m for i in range(n)]
for i in range(n):
for j in range(m):
matrix[i][j] = (i + j) % m + 1
return matrix
n, m = [int(i) for i in input().split()]
a = creat_matrix(n, m)
for row in a:
print(' '.join([str(elem) for elem in row]))
def chessboard(m, n):
arr = []
for i in range(n):
arr.append(["." if n % 2 == 0 else "*" for n in range(m)])
if i % 2 == 0:
arr[i] = arr[i][::-1]
return arr
print(chessboard(2, 2))
print(chessboard(3, 3))
print(chessboard(3, 4))
print(chessboard(4, 3))
print(chessboard(4, 4))
print(chessboard(5, 3))
def add_col_num(n):
my_list = []
for i in range(n):
my_list.append([1] * n)
for i in range(n):
for j in range(n):
if j == n-1:
my_list[i][j] = 5
for i in range(n):
print(*my_list[i])
class Neuron:
def __init__(self, weights, activation):
self.xx = None
self.weights = weights
self.activation = activation
def forward(self, inputs):
self.xx = inputs
return self.activation(np.dot(self.weights, self.inputs))
def backward(self):
return self.xx
def max_under_diagonal(matrix):
max_el = None
for i in range(len(matrix)):
for j in range(len(matrix[i])):
if i + j < len(matrix) - 1:
if max_el is None or matrix[i][j] > max_el:
max_el = matrix[i][j]
return max_el
print(max_under_diagonal([[2, 3, 1], [4, 6, 5], [7, 9, 8]]))
n, m = [int(i) for i in input().split()]
matrix = [[0] * m for i in range(n)]
number = 1
for i in range(m):
for j in range(n):
if (i % 2 == 0 and j % 2 != 0) or (i % 2 != 0 and j % 2 == 0):
matrix[j][i] = number
number += 1
else:
matrix[n - j - 1][i] = number
number += 1
for i in range(n):
print(" ".join([str(j).rjust(3) for j in matrix[i]]))
def print_random_number(n):
from random import random
print(random()*n)
def fractional_number(num):
a = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
b = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
c = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
d = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
e = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
f = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
g = ''.join(np.random.choice(np.arange(1, 10), size=11, replace=False))
h = ''.join(np.random.choice(np.arange(1, 10), size
import numpy as np
def encode(a):
a = np.array(a)
b = np.array(np.diff(a))
c = np.zeros(len(a))
c[0] = a[0]
if(len(a)==1):
return [a[0]], [1]
else:
for i in range(len(a)-1):
if b[i] == 0:
c[i+1] = 0
else:
c[i+1] = a[i+1]
d = np.unique(c, return_counts=True)
return d[0], d[1]
print(encode([1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2]))
def password_check(pw, pw_confirm):
if len(pw) < 7:
return 'Short'
elif pw != pw_confirm:
return 'Difference'
else:
return 'OK'
pw = input()
pw_confirm = input()
print(password_check(pw, pw_confirm))
import random
def rand(n):
return random.random() * n
rand(5)
def func(n, m, matrix):
result = []
for i in range(n):
count = 0
sum = 0
for j in range(m):
sum += matrix[i][j]
average = sum / m
for j in range(m):
if matrix[i][j] > average:
count += 1
result.append(count)
return result
n = int(input())
m = int(input())
matrix = []
for i in range(n):
matrix.append([int(elem) for elem in input().split()])
print(*func(n, m, matrix))
Входные данные
Вводятся две строки. Каждая строка состоит не более чем из 100 символов и содержит только латинские буквы.
Выходные данные
Выведите ответ на задачу.
n, m = int(input()), int(input())
matrix = [[0 for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
matrix[i][j] = i + 1 + m * j
print(matrix[i][j], end=' ')
print()
import numpy as np
def diagonal_sum(matrix):
diagonal = np.diagonal(matrix)
return sum([x for x in diagonal if x%2==0])
matrix = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(diagonal_sum(matrix))
def max_level_of_pyramid(n):
level = 0
while True:
if n == 0:
return level
n -= level
level += 1
max_level_of_pyramid(10)
import numpy as np
def multiply_matrices_without_numpy(list_a, list_b):
# Write your code here
n = len(list_a)
c = [[0 for x in range(n)] for y in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
c[i][j] += list_a[i][k] * list_b[k][j]
return c
def multiply_matrices_with_numpy(array_a, array_b):
# Write your code here
return np.dot(array_a, array_b)
def matrix(n):
lst = [[]]
num = 1
for i in range(n):
lst.append([])
for j in range(n):
lst[i].append(0)
j = 0
while j < n * n:
for i in range(n):
lst[i][j // n] = num
num += 1
if num == n * n + 1:
break
j += 1
for i in range(n - 1, 0, -1):
lst[i][(j - 1) // n] = num
num += 1
if num == n * n + 1:
break
j += 1
if num == n * n + 1:
break
for i in range(n):
for j in range(n):
print(lst[i][j], end=" ")
print()
# n, x = (int(i) for i in input().split())
# ans = 0
# for i in range(1, n+1):
# if x % i == 0 and x // i <= n:
# ans += 1
# print(ans)
def multiply():
res = 1
while True:
num = int(input("Enter number: "))
if num == 0:
break
elif num < 0:
continue
res = res * num
return res
multiply()
import numpy as np
class Neuron:
def __init__(self, weights, activation_function):
self.weights = weights
self.activation_function = activation_function
self.input = None
def forward(self, input_array):
self.input = input_array
return self.activation_function(np.dot(self.input, self.weights))
def backlog(self):
return self.input
n = int(input())
def is_prime(n):
if n == 2 or n == 3:
return True
if n%2 == 0 or n%3 == 0 or n<2:
return False
div = 5
while div <= n**.5:
if n%div == 0 or n%(div+2) == 0:
return False
div +=6
return True
if is_prime(n):
print("Yes")
else:
print("No")
def decimal(n):
if (n <= 0):
return None
fraction = 0
print("n=", n)
for i in range(10):
number = ""
if (n > 0.1):
n = n - 0.1
number = f"0.{i}{i}"
fraction += 0.1
elif (n > 0.01):
n = n - 0.01
number = f"0.{i}0"
fraction += 0.01
elif (n > 0.001):
n = n - 0.001
number = f"0.0{i}"
fraction += 0.001
else:
number = f"0.0{i}"
print(number)
# print("fraction=", fraction)
return True if fraction == 1 else False
decimal(0.0001)
class Neuron:
def __init__(self, w, f = lambda x: x):
self.w = w
self.f = f
self.x = None
def forward(self, x):
self.x = x
return self.f(sum([wi * xi for (wi, xi) in zip(self.w, x)]))
def backlog(self):
return self.x
def main_diagonal(n):
a = []
for i in range(n):
a.append([0]*n)
for i in range(n):
a[i] = input().split()
max_el = int(a[0][0])
for i in range(n):
for j in range(n):
if i > j and int(a[i][j]) > max_el:
max_el = int(a[i][j])
return max_el
main_diagonal(4)
def transformation(X):
s = []
m,n = np.shape(X)
for i in range(m):
s.append(np.hstack((X[i], X[i][::-1])))
for k in range(m):
for j in range(n):
if (j % 2 == 0):
s[k][j+n] = a
else:
s[k][j+n] = s[k][j+n] ** 3
s = np.array(s)
return s
def gcd(a, b):
# находим остаток от деления а на b
rem = a % b
# если остаток равен 0, то возвращаем b
if rem == 0:
return b
# иначе вызываем функцию снова
# с аргументами b и остатока от деления
return gcd(b, a % b)
class MyClass:
def __init__(self):
self.x = 0
self.y = 0
def add_x(self, x):
self.x += x
def add_y(self, y):
self.y += y
def add_xy(self, x, y):
self.x += x
self.y += y
def print_xy(self):
print('x = {}, y = {}'.format(self.x, self.y))
def set(self, x, y):
self.x = x
self.y = y
def reset(self):
self.x = 0
self.y = 0
m = MyClass()
m.print_xy()
m.add_xy(1, 2)
m.print_xy()
m.set(3, 4)
m.print_xy()
import sys
# считывание списка из входного потока
lst_in = list(map(str.strip, sys.stdin.readlines()))
class MyNum(object):
def __init__(self, num):
self.num = num
def get_val(self):
return self.num
def __iadd__(self, val):
self.num += val
return self
a = MyNum(2)
a += 3
# a.get_val()
a.get_val()
def natural_number(n):
i = 1
while (i+1)**2 < n:
i += 1
return i
natural_number(4)
def cutnumber(number):
number = str(number)
if(number.find('.') == -1):
return [number]
else:
number = [int(s) for s in number.split('.')]
return number
cutnumber(123.4567)
def find_max(n, matrix):
max_num = matrix[0][0]
for i in range(n):
for j in range(i + 1, n):
if matrix[i][j] > max_num:
max_num = matrix[i][j]
return max_num
n = int(input())
matrix = []
for i in range(n):
matrix.append([int(i) for i in input().split()])
print(find_max(n, matrix))
def lucky_ticket(ticket_number):
return sum([int(n) for n in ticket_number[:3]]) == sum([int(n) for n in ticket_number[3:]])
lucky_ticket("123321")
def arithmeticExpression(expression):
return eval(expression)
arithmeticExpression("1+2")
n, m = (int(i) for i in input().split())
for i in range(n):
for j in range(m):
if (i + j) % 2 == 0:
print('.', end = '')
else:
print('*', end = '')
print()
def max_elem(mat):
i = 0
max_elem = -10000
while i < len(mat):
j = 0
while j < len(mat[i]):
if j > i and mat[i][j] > max_elem:
max_elem = mat[i][j]
j += 1
i += 1
return max_elem
max_elem([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
n = int(input())
a = [[1 if i == n - j - 1 else 2 if i < n - j - 1 else 0 for j in range(n)] for i in range(n)]
for row in a:
print(' '.join([str(elem) for elem in row]))
n = int(input())
a = [[2 for j in range(n)] for i in range(n)]
for row in range(n):
a[row][n - row - 1] = 1
if row != n - row - 1:
a[row][row] = 0
for row in a:
print(' '.join([str(elem) for elem in row]))
def ten_numbers(x):
arr = []
for i in range(0, 10):
arr.append(x/10)
x = x - x/10
print(arr)
ten_numbers(4.32)
def cities_length(cities):
for city in cities:
if len(city) > 5:
return True
else:
return False
cities = ['Kyiv', 'Berlin', 'Munich']
cities_length(cities)
def count_characters(lines):
count = []
for line in lines:
count.append(len(line))
return count
count_characters(['first line', 'second line', 'third line'])
p = [0] * 10
count = 0
while count < 5:
i = int(input())
if p[i] == 1:
continue
p[i] = 1
count += 1
print(*p)
def matrix(n):
for i in range(n):
for j in range(n):
print(max(i, j) + 1, end=" ")
print()
matrix(5)
def max_elem(matrix):
# YOUR CODE HERE
max_el = -1
for i in range(len(matrix)):
for j in range(i):
if matrix[i][j] > max_el:
max_el = matrix[i][j]
return max_el
morze = {'а': '.-', 'б': '-...', 'в': '.--', 'г': '--.', 'д': '-..', 'е': '.', 'ё': '.', 'ж': '...-', 'з': '--..',
'и': '..', 'й': '.---', 'к': '-.-', 'л': '.-..', 'м': '--', 'н': '-.', 'о': '---', 'п': '.--.', 'р': '.-.',
'с': '...', 'т': '-', 'у': '..-', 'ф': '..-.', 'х': '....', 'ц': '-.-.', 'ч': '---.', 'ш': '----', 'щ': '--.-',
'ъ': '--.--', 'ы': '-.--', 'ь': '-..-', 'э': '..-..', 'ю': '..--', 'я': '.-.-',
def matrix_sum(n):
matrix = []
for i in range(n):
matrix_elements = list(map(int, input().split(' ')))
matrix.append(matrix_elements)
max_sum = matrix[0][0]
i = 0
while i < n:
if sum(matrix[i][:i]) > max_sum:
max_sum = sum(matrix[i][:i])
i += 1
return max_sum
def check(a):
m = a
count = 0
while m > 0:
m = m - 1
count = count + 1
return count
def add(a, b):
return a + b
def create_tens(a, b):
return [1 / (a - i) for i in range(b)]
def check_num(a):
if a < 0:
return True
return False
def check_zero(a):
if a == 0:
return True
return False
def check_decimal(a):
return (a - int(a)) != 0
def main():
x = int(input("Enter a number: "))
if check_num(x):
print("The number is incorrect!")
return
if check_zero(x):
print("ERROR!!! The number is zero!")
return
if check_decimal(x):
print("The number is incorrect!")
return
count_
def max_below_diagonal(n):
a = [list(map(int, input().split())) for _ in range(n)]
return max([a[i][j] for i in range(n) for j in range(i+1, n)])
max_below_diagonal(int(input()))
n = int(input())
def build_matrix(n):
t2 = tuple()
for i in range(n):
row = ()
for j in range(n):
if i == j:
row += (1,)
else:
row += (0,)
t2 += (row,)
return t2
t2 = build_matrix(n)
for row in t2:
for column in row:
print(column, end = ' ')
print()
n = int(input())
matrix = [[int(i) for i in input().split()] for _ in range(n)]
def main_diagonal(matrix, n):
return [matrix[i][j] for i in range(n) for j in range(n) if i + j == n - 1]
def main_diagonal_max(matrix, n):
return max(main_diagonal(matrix, n))
print(main_diagonal_max(matrix, n))
def city_game(lst):
for i in range(len(lst)-1):
if(lst[i][-1] == lst[i+1][0]):
print('YES')
elif(lst[i][-1] == 'ь'):
if(lst[i][-2] == lst[i+1][0]):
print('YES')
else:
print('NO')
elif(lst[i][-1] == 'ъ'):
if(lst[i][-2] == lst[i+1][0]):
print('YES')
else:
print('NO')
elif(lst[i][-1] == 'ы'):
if(lst[i][-2] == lst[i+1][0]):
print('YES')
else:
print('NO')
else:
print('NO')
city_game(['Москва', '
def pentagon_hacks(a, b, c):
return a + b + c
def find_day(k):
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
return days[(k-1)%7]
n, m = [int(i) for i in input().split()]
a = [[0] * m for i in range(n)]
dx, dy = [0, 1, 0, -1], [1, 0, -1, 0]
x, y, c = 0, -1, 1
for i in range(max(n, m)):
for j in range(i+1):
x += dx[i % 4]
y += dy[i % 4]
if 0 <= x < n and 0 <= y < m:
a[x][y] = c
c += 1
for i in range(n):
for j in range(m):
print(str(a[i][j]).ljust(len(str(a[n-1][m-1]))), end=' ')
print()
def f(a,b):
for i in range(a,b + 1):
if i%2 == 0 or i%3 == 0 or i%777 == 0:
continue
print(i)
if i%777 == 0:
break
f(1, 10)
def day(k):
d = k % 7
if d == 1:
return "Monday"
elif d == 2:
return "Tuesday"
elif d == 3:
return "Wednesday"
elif d == 4:
return "Thursday"
elif d == 5:
return "Friday"
elif d == 6:
return "Saturday"
elif d == 0:
return "Sunday"
day(3)
li = [1, 2, 3, 4]
li = [i for i in li if i != 4]
print(li)
#Example
# n = int(input())
# a = [[int(j) for j in input().split()] for i in range(n)]
n = int(input())
a = []
for i in range(n):
row = input().split(' ')
for j in range(len(row)):
row[j] = int(row[j])
a.append(row)
def add_to_list(stuffVolume):
n = int(input())
full = False
while full == False:
x = int(input())
if (sum(stuffVolume + [x])) < n:
stuffVolume.append(sum(stuffVolume + [x]))
else:
full = True
return stuffVolume
stuffVolume = []
add_to_list(stuffVolume)
print(sum(stuffVolume))
print(len(stuffVolume))
n, m = [int(i) for i in input().split()]
a = [[abs((j+(i+1)) % (m)) + 1 for j in range(m)] for i in range(n)]
for row in a:
print(*row)
def vasyasocks(n, m):
if (n//m >= 1) and (n % m > 0):
return n // m * (m-1) + (n % m) + 1
elif (n//m >= 1) and (n % m == 0):
return n // m * (m-1) + m
else:
return n
vasyasocks(2, 3)
def trace_matr(list_):
trace = 0
for i in range(len(list_)):
trace += list_[i][i]
return trace
def backpack(n):
sum = 0
qty = 0
while True:
a = int(input())
if a == 0:
break
else:
sum += a
qty += 1
if sum >= n:
break
return sum, qty
def unique_words(text):
words = text.lower().split()
unique_words = []
for word in words:
if word not in unique_words:
unique_words.append(word)
return " ".join(unique_words)
print(unique_words("Hello hello world world world"))
def is_symmetric(n, m):
for i in range(n):
for j in range(m):
if mass[i][j] != mass[n-i-1][m-j-1]:
return 'No'
return 'Yes'
n = int(input())
m = int(input())
mass = []
for i in range(n):
mass.append([int(j) for j in input().split()])
print(is_symmetric(n, m))
def chess(n, m):
res = []
for i in range(n):
tmp = []
for j in range(m):
if (i + j) % 2 == 0:
tmp.append('*')
else:
tmp.append('.')
res.append(tmp)
return res
def get_min_divisor(num):
if num == 2:
return num
for i in range(2,num):
if num % i == 0:
return i
return num
get_min_divisor(4)
def in_cluster(x1, y1, x2, y2, epsilon = 0.1):
if (x1 - x2)**2 + (y1 - y2)**2 > epsilon:
print("Out of cluster")
else:
print("In cluster")
in_cluster(1, 2, 3, 6)
def print_numbers(n):
list = []
for i in range(1, n+1):
list.append(i)
for j in range(0, len(list)):
print(list[j], end=" ")
print()
for k in range(1, n+1):
print(list[-k], end=" ")
print()
print(sum(list))
def distance(x1, y1, x2, y2):
return math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))
distance(1, 5, 3, 6)
def create_matrix(n):
m = [[0 for j in range(n)] for i in range(n)]
for i in range(n):
for j in range(n):
if i == j:
m[i][j] = 1
elif j > i:
m[i][j] = 2
return m
n = int(input())
m = create_matrix(n)
[print(' '.join(str(i) for i in row)) for row in m]
def char_occurences(strng, char):
count = 0
for c in strng:
if c == char:
count += 1
return count
char_occurences('hello', 'l')
n = int(input())
m = int(input())
k = int(input())
d = {}
for i in range(k):
d[i] = int(input())
max_people = 0
for i in range(m):
max_people = 0
for key, value in d.items():
if value > max_people:
max_people = value
best_table = key
d[best_table] = value - 1
if d[best_table] == 0:
del d[best_table]
print(best_table, end=" ")
import requests
def get_weather(city):
url = "http://api.openweathermap.org/data/2.5/weather"
params = {"q": city, "units": "metric", "appid": "e9185b28e9969fb7a300801eb026de9c"}
result = requests.get(url, params=params)
print(result.status_code)
print(result.headers["Content-Type"])
print(result.url)
print(result.json())
return result.json()
city = input("city")
weather = get_weather(city)
def get_temp(weather):
temp = weather["main"]["temp"]
return temp
def get_wind(weather):
wind = weather["wind"]["speed"]
return wind
def get_humidity(weather):
humidity = weather["main"]["humidity"]
return humidity
data
def check_same_letter(names):
first_letter = ''
for n in names:
if n[0] == n[-1]:
first_letter += n[0]
break
return first_letter != ''
check_same_letter(['molly', 'jordan'])
import random
def rand_num(a):
#a = float(input("Enter a number: "))
a_int = int(a)
a_frac = a - a_int
n = 10
nums = []
for i in range(1, n + 1):
num = random.randint(10**(11), 10**12 - 1)
nums.append(num)
a_frac -= (num - int(num))/10**12
#print(a_frac)
if a_int:
nums.append(a_int)
return nums
print(rand_num(0.01))
def answer(n, m, k, c):
t = [0]*m
for i in range(n):
t[i%m] += 1
return t
def test():
a = answer(3, 2, 2, [2, 1])
print (a)
b = answer(6, 2, 2, [3, 3])
print (b)
test()
def add_all():
sum = 0
while True:
num = input()
if(num == "0"):
break
sum = sum + int(num)
return sum
add_all()
def backpack(n, *args):
i = 0
for x in args:
i += x
if i > n:
break
print('Enough!')
print(i)
print(len(args))
backpack(10, 1, 2, 3, 4, 5, 6)
import numpy as np
def max_under_diagonal(a):
n = len(a)
max_elem = a[0][1]
for i in range(n):
for j in range(i+1, n):
max_elem = max(max_elem, a[i][j])
return max_elem
a = np.random.randint(0, 10, size=(3,3))
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(max_under_diagonal(a))
a = [int(i) for i in input().split()]
b = {}
for i in a:
b[i] = True
c = []
for i in b:
c.append(i)
print(*c)
def find_max_num(lst):
max_num = 0
for i in lst:
if i > max_num:
max_num = i
return max_num
N = int(input())
a = []
for i in range(N):
a.append(list(map(int, input().split())))
b = []
for i in range(N):
b.append(a[i][(N-1)-i])
print(find_max_num(b))
def backpack(n, lst):
res = []
s = 0
for i in lst:
if i + s <= n:
res.append(i)
s += i
else:
print("Enough!")
print(sum(res))
print(len(res))
return sum(res), len(res)
backpack(10, [1, 4, 3, 5, 2, 3, 4, 5, 3, 1, 2, 5, 3, 4, 5, 1, 2, 3, 4])
def tables(people_num, days_num, table_num):
persons = [i for i in range(1, people_num + 1)]
tables = [[] for _ in range(days_num)]
people_table_num = int(people_num / table_num)
people_table_num_rest_num = people_num % table_num
for i in range(days_num):
for j in range(table_num):
table = []
for k in range(people_table_num):
table.append(persons[0])
persons.pop(0)
if people_table_num_rest_num == 0:
tables[i].append(table)
else:
tables[i].append(table)
tables[i][j].append(persons[0])
persons.append(persons[0])
persons.pop(0)
people_table_num_rest_num -= 1
res = []
for i in range(days_num):
n = int(input())
m = int(input())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = []
i = 0
j = 0
while i < n or j < m:
if i < n and j < m:
if a[i] < b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
elif i < n:
c.append(a[i])
i += 1
elif j < m:
c.append(b[j])
j += 1
print(*c)
def count_characters(string):
# Write your code here
count = {}
for char in string:
if char.lower() in count:
count[char.lower()] += 1
else:
count[char.lower()] = 1
new_list = []
for key in sorted(count):
new_list.append((count[key], key))
return new_list
def remove_dublicate(some_string):
#your code here
return some_string
n = int(input("Enter the value of n: "))
def max_of_matrix(n):
matrix = []
sum = 0
for i in range(n):
a = []
for j in range(n):
a.append(int(input()))
matrix.append(a)
for i in range(n):
for j in range(n):
if i < j:
sum += matrix[i][j]
return sum
print(max_of_matrix(n)
def add(a):
while a > 1000000000:
return a
if a < 1000000000:
return a * (a // 10)
add(998)
def main_diag(a):
return [[1 if i == j else 0 for i in range(a)] for j in range(a)]
main_diag(5)
import math
def display_10_numbers(n):
number = 0
while number < 10:
num = round(n - math.pow(10, -12), 12)
print(num)
number += 1
n = n - num
n = float(input())
display_10_numbers(n)
def grad_descent(df, x0, step_size=0.5, thresh=1e-10, max_iter=1e4):
step = 0
x = x0
while step < max_iter and np.linalg.norm(df(x)) > thresh:
x = x - step_size*df(x)
step = step + 1
return x
def sum(n):
if n < 0:
return 0
elif n <= 1:
return n
else:
return n + sum(n - 1)
sum(10)
n = int(input("Введите количество людей: "))
m = int(input("Введите количество дней: "))
k = int(input("Введите количество столов: "))
places = [int(s) for s in input().split()]
for day in range(m):
print("День {}".format(day + 1))
for table in range(k):
print("На столе {} сидят люди с номерами: {}".format(table + 1, table + 1))
def days(n, m):
if n == 1:
return 1
elif n % 2 == 1:
return 1 + days(n - 1, m)
else:
return 1 + days(n // 2, m)
days(1, 2)
def diagonal(n):
list = []
for i in range(n):
list.append(input().split(" "))
for i in range(n):
for j in range(n):
list[i][j] = int(list[i][j])
max = 0
for i in range(n):
for j in range(n):
if i > j and max < list[i][j]:
max = list[i][j]
return max
def get_decimals(n):
return str(n).split('.')[1]
def get_parts(n):
parts = []
decimal_part = get_decimals(n)
if decimal_part:
parts = [decimal_part]
while n > 1:
parts.append(1)
n -= 1
while len(parts) < 10:
parts.append(0)
return parts
def get_last_num(parts):
return ''.join(map(str, parts))
def get_first_num(parts):
return '1' * (12 - len(parts[0])) + parts[0]
def get_nums(parts):
nums = []
last_num = get_last_num(parts)
nums.append(last_num)
for i in range(9):
num = last_num[-i:] + '0' * i
nums.append(num)
return nums
def game(str1,str2):
if str1[-1] != str2[0] and str1[-1]=='f':
return 'Bad'
else:
return 'Good'
game('car', 'fog')
def transform(X, a=1):
Y = np.zeros_like(X)
for i in range(X.shape[0]):
row = X[i]
new_row = np.zeros_like(row)
for j in range(row.shape[0]):
if j % 2 == 0:
new_row[j] = row[j] ** 3
else:
new_row[j] = a
Y[i] = new_row[::-1]
return np.hstack((X, Y))
def remove_elements(my_list, char):
new_list = []
for i in my_list:
if i != char:
new_list.append(i)
return new_list
my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
remove_elements(my_list, 'e')
def check_sequence(city_names):
for i in range(1, len(city_names)):
if city_names[i][0] != city_names[i-1][-1]:
return False
return True
check_sequence(['Poltava', 'Kyiv', 'Odesa', 'Vinnytsia'])
def number_repeat_n_times(n):
i = 1
while n > 0:
print((str(i) + ' ') * i, end='')
n -= i
i += 1
print(number_repeat_n_times(7))
def total(total, n):
n = 12
if n == 0:
return 0
return total(total - (total / n), n - 1)
total(10, 12)
def is_consecutive(n):
s = str(n)
for i in range(len(s)-1):
if s[i] == s[i+1]:
return False
return True
is_consecutive(1234)
def exp_matrix(matrix, m):
matrix_exp = np.matrix(matrix)
for i in range(m-1):
matrix_exp = matrix_exp * np.matrix(matrix)
return matrix_exp
def get_matrix():
n = int(input())
matrix = [list(map(int, input().split())) for i in range(n)]
m = int(input())
return exp_matrix(matrix, m)
if __name__ == "__main__":
print(*get_matrix())
import re
match = re.search(r'\d\d\D\d\d', r'Телефон 123-12-12')
print(match[0] if match else 'Not found')
def city(a):
i = 0
while i < len(a) - 1:
if a[i][-1] == a[i + 1][0]:
print("YES")
else:
print("NO")
i += 1
city(["Moscow", "London", "Paris", "Berlin"])
n, m = [int(i) for i in input().split()]
matrix = [[0] * m for i in range(n)]
a = 1
b = 0
c = n
d = m
while a <= n * m:
for i in range(b, d):
matrix[b][i] = a
a += 1
for j in range(b + 1, c):
matrix[j][d-1] = a
a += 1
for k in range(d-2, b-1, -1):
matrix[c-1][k] = a
a += 1
for l in range(c-2, b, -1):
matrix[l][b] = a
a += 1
b += 1
c -= 1
d -= 1
for i in range(n):
for j in range(m):
print(str(matrix[i][j]).ljust(3), end='')
print()
def mat_mult(A, B):
# write your code here
return None
def numpy_mat_mult(A, B):
# write your code here
return None
def pack(n, things):
result = []
for key, value in sorted(things.items(), key=lambda item: item[1], reverse=True):
if n >= value:
result.append(key)
n -= value
return result
pack(10, {'карандаш': 20, 'зеркальце': 100, 'зонт': 500, 'рубашка': 300,
'брюки': 1000, 'бумага': 200, 'молоток': 600, 'пила': 400, 'удочка': 1200,
'расческа': 40, 'котелок': 820, 'палатка': 5240, 'брезент': 2130, 'спички': 10})
a = int(input())
s = 0
s2 = 0
while a != 0:
s += a
s2 += a ** 2
a = int(input())
print(s2)
n, m = map(int, input().split())
a = []
for i in range(n):
a.append([int(j) for j in input().split()])
for i in range(1, n):
for j in range(1, m):
if a[i][j] == 0:
a[i][j] = a[i - 1][j] + a[i][j - 1]
for i in range(n):
for j in range(m):
print(a[i][j], end=' ')
print()
n, m = int(input()), int(input())
lst = [[0] * m for _ in range(n)]
for i in range(n):
for j in range(m):
lst[i][j] = i * m + j + 1
for i in range(n):
for j in range(m):
print(lst[i][j], end = ' ')
print()
def first_digit(n):
if n < 0:
n = abs(n)
elif n == 0:
return 0
else:
return int(str(n)[0])
def multiply_first_digit(n):
if n < 0:
n = abs(n)
elif n == 0:
return 0
else:
while n // 10 >= 1:
n = first_digit(n) * n
if n >= 1000000000:
return f'{n} exceeds a billion'
return n
multiply_first_digit(1234)
def square_greater(n):
i = 1
while i * i <= n:
i += 1
print (i)
square_greater(20)
import random
def twelve_digit_number(n):
return random.randrange(1, n, 12)
twelve_digit_number(1000)
def looking4letters(letter, sentence):
return [word for word in sentence if letter.lower() in word.lower()]
looking4letters('h', 'Hello world')
looking4letters('h', 'Hello world')
looking4letters('s', 'She sells sea shells on the sea shore')
looking4letters('a', 'An apple a day keeps the doctor away')
a = tuple(map(int, input().split()))
print(*(i for i, x in enumerate(a) if a.count(x) > 1))
def date(m, n):
if m == 12 and n == 31:
return '01.01'
if n == 1:
return str(m - 1).zfill(2) + '.31'
return str(m).zfill(2) + '.' + str(n - 1).zfill(2) + ' ' + str(m).zfill(2) + '.' + str(n + 1).zfill(2)
print(date(*map(int, input().split())))
def prime(n):
if n == 1:
return False
elif n == 2:
return True
for i in range(2, n):
if n % i == 0:
return False
return True
prime(2)
sentences = ['1 thousand devils', 'My name is 9Pasha', 'Room #125 costs $100']
def process(sentences):
#YOUR CODE
res = []
for sentence in sentences:
res.append(' '.join(list(filter(lambda word: word.isalpha(), sentence.split()))))
return res
assert process(sentences) == ['thousand devils', 'My name is', 'Room costs'], \
"Something is wrong! Please try again"
process(sentences)
def example(n):
if type(n) is not int and type(n) is not float:
return "This is not a number"
if n <= 0 or n > 1:
return "The range of number is incorrect"
sum = 0
for i in range(1, 11):
num = round(random.uniform(0.001, 1), 12)
sum += num
print(num, end = " ")
if sum == n:
return
else:
return "The sum of numbers is not correct"
example(0.1)
def max_min(a, b, c):
if a > b and a > c:
if b > c:
print(a - c)
else:
print(a - b)
elif b > a and b > c:
if a > c:
print(b - c)
else:
print(b - a)
elif c > a and c > b:
if a > b:
print(c - b)
else:
print(c - a)
max_min(1, 2, 3)
import os
os.system('start cmd')
mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
r = 0
for c in range(len(mat)):
r += mat[c][c]
print(r)
def pr(a, b):
for i in range(a, b+1):
if i % 777 == 0:
break
elif i % 2 == 0 or i % 3 == 0:
continue
print(i)
pr(1, 10)
import random
n = float(input("Enter number: "))
def random_numbers(n, random_sum=0.0):
if random_sum >= n:
return
random_sum += random.uniform(0, n)
print(random_sum)
return random_numbers(n, random_sum)
random_numbers(n)
