Решение модуля 5.7 Инди-курс программирования на Python

Модуль 5.7 (Вложенные списки). Вложенный список – это список, элементами которого являются также списки. 

Ниже представлены примеры задач с решением на тему Вложенные списки.

Вам нужно посчитать сумму элементов двумерного квадратного (NxN) списка, которые расположены на главной диагонали.

Под главной диагональю матрицы подразумевается диагональ, проведённая из левого верхнего угла в правый нижний.

Программа сперва принимает на вход число N (N<=15) — количество строк и столбцов в списке, а затем в N строках записаны элементы списка.

n = int(input())    		# Кол-во строк и столбцов матрицы

a = []				# Переменная для хранения списка
s = 0				# Переменная для суммы			

for i in range(n):
    b = []    				# Создание пустого списка
    b = list(map(int, input().split()))    # Заполнение списка
    a.append(b)    			# Добавление списка в строку матрицы
for i in range(n):    		# Обход строк матрицы
    for j in range(n):    	# Обход столбцов матрицы
        if i == j:    		# Если текущий элемент находится на главной диагонале 
            s += a[i][j]    # Суммирование элемента
print(s)

Задана целочисленная квадратная матрица размером N x N. Необходимо обойти элементы этой матрицы сверху вниз слева направо и вывести элементы именно в таком порядке в виде таблицы. 

Программа принимает на вход натуральное число N – количество строк и столбцов матрицы. В каждой из последующих N строк записаны N целых чисел – элементы матрицы. Все числа во входных данных не превышают 100 по абсолютной величине.

n = int(input())		# Получаем размер матрицы	
a = []				# Переменная для хранения матрицы
for i in range(n):		# Каждый цикл это 1 строка
    a.append(list(map(int,input().split()))) # В строку добавляем массив
	
for i in range(n):  			# Цикл для вывода, строка		 
    for j in range(n):  		# Столбик
        print(a[j][i],end=' ')		# Меняем индексы местами, столбец через пробел
    print()				# Переход на новую строку

Задана целочисленная квадратная матрица размером N x N. Необходимо обойти элементы этой матрицы снизу вверх справо налево и вывести элементы именно в таком порядке в виде таблицы. 

Программа принимает на вход натуральное число N – количество строк и столбцов матрицы. В каждой из последующих N строк записаны N целых чисел – элементы матрицы. 

n =int(input())                       # получили размер матрицы
a = []                                # переменная для матрицы
for j in range(n):                    # заполняем матрицу
    a.append(list(input().split()))
    
for i in range(n):                    # пробежали по циклу i
    for j in range(n):                # пробежали по циклу j
        print(a[n-1-j][n-1-i], end=" ") # меняем индексы местами, вычитая их из длины матрицы и -1
    print()     

Задана целочисленная матрица, состоящая из N строк и M столбцов. Необходимо обойти элементы этой матрицы cправо налево сверху вниз и вывести элементы именно в таком порядке в виде таблицы. 

Программа принимает на вход два натуральных числа N и M – количество строк и столбцов матрицы. В каждой из последующих N строк записаны M целых чисел – элементы матрицы.

n, m = map(int, input().split())     # вводим строки и столбцы
a = []                               # создал новый список
for i in range(n):
    a.append(list(input().split()))  # добавляем элементы в список a
for i in range(n):                   # обход по строкам 
    for j in range(m - 1, -1, -1):   # обход по строкам 
        print(a[i][j], end=' ')      # печать символа через пробел
    print()                          # перенос строки

Задана целочисленная матрица, состоящая из N строк и M столбцов. Необходимо обойти элементы этой матрицы слева направо снизу вверх и вывести элементы именно в таком порядке в виде таблицы. 

Программа принимает на вход два натуральных числа N и M – количество строк и столбцов матрицы. В каждой из последующих N строк записаны M целых чисел – элементы матрицы. 

n, m = map(int, input().split())     # вводим строки и столбцы
a = []                               # создал новый список
for i in range(n):
    a.append(list(input().split()))  # добавляем элементы в список a
for i in range(n - 1, -1, -1):       # обход по строкам 
    for j in range(m):               # обход по строкам 
        print(a[i][j], end=' ')      # печатаем символ
    print()                          # переход на новую строку

Перед Вами матрица размера 5 × 5, состоящая из 24-x нулей и единственной единицы. Строки матрицы пронумеруем числами от 1 до 5 сверху вниз, столбцы матрицы пронумеруем числами от 1 до 5 слева направо. За один ход разрешается применить к матрице одно из двух следующих преобразований:
— Поменять местами две соседние строки матрицы, то есть строки с номерами i и i + 1 для некоторого целого i (1 ≤ i < 5).
— Поменять местами два соседних столбца матрицы, то есть столбцы с номерами j и j + 1 для некоторого целого j (1 ≤ j < 5).

Вы считаете, что матрица будет выглядеть красиво, если единственная единица этой матрицы будет находиться в ее центре (в клетке, которая находится на пересечении третьей строки и третьего столбца). Посчитайте, какое минимальное количество ходов потребуется, чтобы сделать матрицу красивой.

c = []                    # обьявление переменной
for i in range(5):        # в цикле получаем матрицу    
    c.append(list(map(int, input().split())))

for i in range(5):        # цикл по строкам
    for j in range(5):    # цикл по столбцам
        if c[i][j] == 1:  # проверяем равен символ 1 или нет
            a = i         # номер строки 
            b = j         # номер столбца 

с = abs(a-2) + abs(b-2)   # считаем кол-во действий 
print(с)

Задан целочисленный двумерный массив, состоящий из N строк и M столбцов. Требуется вычислить сумму элементов в каждой строке и в каждом столбце.

Программа получает на вход два натуральных числа N и M – количество строк и столбцов двумерного массива. В каждой из последующих N строк записаны M целых чисел – элементы массива. Все числа во входных данных не превышают 1000 по абсолютной величине.

В первой строке вам необходимо вывести N чисел – суммы элементов массива для каждой строки в отдельности.

Во второй строке в аналогичном формате выведите M чисел – суммы элементов для каждого столбца.

n,m = map(int, input().split())    # n-кол-во строк, m-кол-во столбцов
a = []

for _ in range(n):
    b = list(map(int, input().split()))  #  Заполнение списка цифрами через пробел
    a.append(b)                          #  Добавление вложенного списка во внешний список
    
for i in range(n):          # цикл по строкам
    sumr = 0                # сумма строки
    for z in range(m):      # в строке перебираем столбцы  
        sumr+=a[i][z]       # складываем значения
    print(sumr,end= ' ')    # вывод суммы строк через пробел
print()

for i in range(m):          # цикл по стобцам
    sumc = 0                # сумма столбца
    for z in range(n):      # в столбце перебираем строки  
        sumc+=a[z][i]       # складываем значения
    print(sumc,end= ' ')    # вывод суммы столбцов через пробел

Проверьте, является ли двумерный массив симметричным относительно главной диагонали. Главная диагональ — та, которая идёт из левого верхнего угла двумерного массива в правый нижний.

n = int(input())                   # полчаем кол-во строк  столбцов
m = []                             # переменная для матрицы
for i in range(n):          
    l = list(input().split())      # Заполнение списка цифрами через пробел
    m.append(l)                    # Добавление вложенного списка во внешний список
flag = True                        # по умолчанию  флаг true
for i in range(n):                 # цикл по строкам
    if not flag:                   # если флаг не истина выходимм из  цикла
        break
    for j in range(n):             # цикл по толбцам
        if i != j:                 # этим условием убираем диагональ
            if m[i][j] != m[j][i]: # проверяем одинаковое ли значение в симметричных яцейках
                flag = False       # если нашли не одинаковые то флаг ставим ложь
                break    
                
print('Yes' if flag else 'No')

В метании молота состязается n спортcменов. Каждый из них сделал m бросков. Победителем считается тот спортсмен, у которого сумма результатов по всем броскам максимальна.
Если перенумеровать спортсменов числами от 0 до n-1, а попытки каждого из них – от 0 до m-1, то на вход программа получает массив A[n][m], состоящий из неотрицательных целых чисел. Программа должна определить максимальную сумму чисел в одной строке и вывести на экран эту сумму и номер строки, для которой достигается эта сумма.

n, m = map(int, input().split())      # n-кол-во строк, m-столбцов
a = []                                # пустой список для ввода
c = []                                # пустой список для сумм

for i in range(n):
    l = list(map(int, input().split()))  # Заполнение списка цифрами через пробел
    a.append(l)                      # Добавление вложенного списка во внешний список
for i in range(n):                   # цикл по строкам
    s = 0                            # переменная для суммы строки
    for j in range(m):               # цикл по толбцам
        s += a[i][j]                 # складываем все столбцы в строке
    c.append(s)                      # Добавление сумму строки в список
    
print(max(c))                        # вывод максимального значения в списке с 
print(c.index(max(c)))               # и вывод его индекса

В метании молота состязается n спортcменов. Каждый из них сделал m бросков. Победителем соревнований объявляется тот спортсмен, у которого максимален наилучший результат по всем броскам. Таким образом, программа должна найти значение максимального элемента в данном массиве, а также его индексы (то есть номер спортсмена и номер попытки).

n, m = map(int, input().split()) # n-кол-во строк, m-столбцов
c = []                           # пустой список для матрицы
a = 0                            # сюда сохраним максимальное значение из матрицы
i_max = 0                        # сюда сохраним номер нужной строки
j_max = 0                        # сюда сохраним номер нужного столбца

for i in range(n):
    l=list(map(int, input().split()))  # Заполнение списка цифрами через пробел
    c.append(l)                      # Добавление вложенного списка во внешний список

for i in range(n):            # цикл по строкам
    for j in range(m):        # цикл по столбцам
        if c[i][j] > a:       # если число в матрице больше сохраненого числа
            a = c[i][j]       # то перезаписываем максимальное число
            i_max = i         # перезаписываем номер строки
            j_max = j         # и номер столбца
print(a)                      # вывод максимального значения 
print(i_max, j_max)           # вывод строку и столбец

В метании молота состязается n спортcменов. Каждый из них сделал m бросков. Побеждает спортсмен, у которого максимален наилучший бросок. Если таких несколько, то из них побеждает тот, у которого наилучшая сумма результатов по всем попыткам. Если и таких несколько, победителем считается спортсмен с минимальным номером. Определите номер победителя соревнований.

n,m = map(int,input().split())  # n-кол-во строк, m-столбцов
matrix = []                     # пустой список для матрицы
mx = 0                          # максимальный элемент в матрице
l = []                          # список для суммы бросков

for i in range(n):
    k=list(map(int, input().split())) # Заполнение списка цифрами через пробел
    matrix.append(k)                  # Добавление вложенного списка во внешний список
    
for i in range(n):
    for j in range(m):
        if matrix[i][j] > mx:    # если бросок больше сохраненого
            mx = matrix[i][j]    # записываем максимальный бросок

for i in range(n):
    if mx in matrix[i]:          # если макс бросок равен числлу из матрицы 
        l.append(sum(matrix[i])) # считаем сумму
    else:
        l.append(0)              # если у этого спортсмкена не мак бросок то  записываемм 0

print(l.index(max(l)))           # находим индекс

В метании молота состязается n спортcменов. Каждый из них сделал m бросков. Победитель определяется по лучшему результату. Определите количество участников состязаний, которые разделили первое место, то есть определите количество строк в массиве, которые содержат значение, равное наибольшему.

n, m = map(int, input().split())  # строки и столбцы массива
matrix = []                       # пустой список для матрицы
mt = 0                            # максимальный бросок
с = 0                             # счетчик 

for i in range(n):
    k=list(map(int, input().split())) # Заполнение списка цифрами через пробел
    matrix.append(k)                  # Добавление вложенного списка во внешний список
    
for i in range(n):              # цикл по строкам
    for j in range(m):          # цикл по колонкам
        if matrix[i][j] > mt:   # проверяем является ли число больше максимального
            mt = matrix[i][j]   # присваиваем переменной максимальное значение
            
for row in range(n):            # цикл по массиву для поиска количества максимальных значений
    if mt in matrix[row]:       # если в строке массива есть максимальное значение
        с += 1                  # плюс один к счетчику 
        
print(с)

На днях Иван у себя в прихожей выложил кафель, состоящий из квадратных черных и белых плиток. Прихожая Ивана имеет квадратную форму 4х4, вмещающую 16 плиток. Теперь Иван переживает, что узор из плиток, который у него получился, может быть не симпатичным. С точки зрения дизайна симпатичным узором считается тот, который не содержит в себе квадрата 2х2, состоящего из плиток одного цвета.

Ваша задача вывести «Yes», если узор является симпатичным и «No» в противном случае.

s = []                        # пустой список  для матрицы
flag = "Yes"                  # флаг по умолчанию Yes
for i in range(4):
    s.append(list(input()))   # заполняем матрицу    

for i in range(3):            # цикл по строкам до 3 т.к в условии +1
    for j in range(3):        # цикл по столбцам до 3 т.к в условии +1
        # сравниваем соседние клетки
        if s[i][j]==s[i][j+1]==s[i+1][j]==s[i+1][j+1]:
            flag = "No"
print(flag) 

Миша уже научился хорошо фотографировать и недавно увлекся программированием. Первая программа, которую он написал, позволяет формировать негатив бинарного черно-белого изображения.

Бинарное черно-белое изображение – это прямоугольник, состоящий из пикселей, каждый из которых может быть либо черным, либо белым. Негатив такого изображения получается путем замены каждого черного пикселя на белый, а каждого белого пикселя – на черный.

Миша, как начинающий программист, написал свою программу с ошибкой, поэтому в результате ее исполнения мог получаться некорректный негатив. Для того чтобы оценить уровень несоответствия получаемого негатива исходному изображению, Миша начал тестировать свою программу.

n, m = map(int, input().split()) # n-кол-во строк, m-столбцов
a = []                        # список для исходной матрицы
s = []                        # список для матрицы, полученной Мишей

for i in range(n):            # заполняем первую матрицу
    a.append(input())    
    
input()                       # считываем пробел

for j in range(n):
    s.append(input())         # заполняем вторую матрицу

countE = 0                    # счетчик для ошибок
for i in range(n):            
    for j in range(m):       
        if a[i][j] == s[i][j]:  # сравниваем эл-ты матриц
            countE += 1         # прибавляем 1 в счётчик ошибок
print(countE)                      

Рассмотрим таблицу из n строк и n столбцов. Известно, что в клетке, образованной пересечением i-й строки и j-го столбца, записано число i × j. Строки и столбцы нумеруются с единицы.

Дано целое положительное число x. Требуется посчитать количество клеток таблицы, в которых находится число x.

Выведите единственное число: количество раз, которое число x встречается в таблице.

n, x = map(int, input().split())	# n-размер таблицы, x-искомое число
s = 0                      # счетчик
for i in range(1,n+1):     # цикл по строкам
    for j in range(1,n+1): # цикл по столбцам
        if i*j==x:         # если i × j равно искомому числу
            s+=1           # к счетчику добавляем 1
print(s)
Понравилась статья? Поделиться с друзьями:
Подписаться
Уведомить о
guest

0 комментариев
Межтекстовые Отзывы
Посмотреть все комментарии
0
Оставьте комментарий! Напишите, что думаете по поводу статьи.x