UniLecs141

ReadMe.md

UniLecs 141

Входные данные: arr - числовая матрицы N x M, эл-ты матрицы - натуральные числа от 1 до 10^3. N,M от 1 до 100. Вывод: вывести общее кол-во выигрышных направлений для заданной таблицы. Направление считается выигрышным, если все числа в этом направлении от ячейки X строго меньше числа в самой ячейке X. Если ячейка X находится на краю матрицы, то вы автоматически имеете выигрышное направление.

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

Два варианта решения:

На Питоне, replit https://repl.it/@MikePeleah/UniLecs141Py

На JavaScript, replit https://repl.it/@MikePeleah/UniLecs141JS

UniLecs141.js

/* UniLecs #141. Math Lottery
* Входные данные: arr - числовая матрицы N*M, эл-ты матрицы - натуральные
* числа от 1 до 10^3. N,M от 1 до 100.
* Вывод: вывести общее кол-во выигрышных направлений для заданной таблицы.
* Направление считается выигрышным, если все числа в этом направлении
* от ячейки X строго меньше числа в самой ячейке X. Если ячейка X находится
* на краю матрицы, то вы автоматически имеете выигрышное направление.
*/

function UniLecs141(Arr){
    var Dir = {
      "up": [0, 1],
      "down": [0,-1],
      "right": [1, 0],
      "left": [-1, 0]
    }
    // получаем число столбцов и строк в матрице
    Row = Arr.length
    Col = Arr[0].length
    NWin = 0  // Число выигрышных направлений
    // Пробегаемся по матрице
    for (i = 0; i < Row; i++) {
        for (j = 0; j < Col; j++) {
            // Берём значение
            X = Arr[i][j]
            // Смотрим по всем направлениям
            for (d in Dir) {
                // Берём текущую позицию
                n=i
                m=j
                // По умолчанию считаем направление выигрышным и пробуем его
                DirWin = true
                LetsTry = true
                // В этом цикле мы будем двигаться по направлению пока имеет смысл -- значения убывают и на границу не наткнулись
                while ( LetsTry ) {
                    // Проверяем выходим ли мы за границу? Если да -- выходим из цикла
                    n += Dir[d][0]
                    m += Dir[d][1]
                    if ((n < 0) || (n >= Row) || (m < 0) || (m >= Col)) {
                        break
                    }
                    // Проверяем убывает ли значение, если нет -- направление проигрышное, выходим из цикла
                    if (Arr[n][m] >= X) {
                        DirWin = false
                        LetsTry = false
                    }
                } // ... end while
                // Если направление выигрышное, то увеличиваем счётчик
                if (DirWin) {
                    NWin += 1
                }
            } // ... end for Dir
        } // ... end for Col
    } // ... end for Row
    return NWin
}

UniLecs141.py

# UniLecs #141. Math Lottery
# Входные данные: arr - числовая матрицы N*M, эл-ты матрицы - натуральные
# числа от 1 до 10^3. N,M от 1 до 100.
# Вывод: вывести общее кол-во выигрышных направлений для заданной таблицы.
# Направление считается выигрышным, если все числа в этом направлении
# от ячейки X строго меньше числа в самой ячейке X. Если ячейка X находится
# на краю матрицы, то вы автоматически имеете выигрышное направление.


def UniLecs141(Arr):
    Dir = ((0,-1),  # Up
           (1,0),   # Right
           (0,1),   # Down
           (-1,0))  # Left
    # получаем число столбцов и строк в матрице
    Row = len(Arr)
    Col = len(Arr[0])
    print("Row ={}, Col={}".format(Row, Col))
    NWin = 0  # Число выигрышных направлений
    # Пробегаемся по матрице
    for i in range(Row) :
        for j in range(Col) :
            # Берём значение
            X = Arr[i][j]
            # Смотрим по всем направлениям
            for d in Dir :
                print ("At {},{}, trying {}".format(i,j,d))
                # Берём текущую позицию
                n=i
                m=j
                # По умолчанию считаем направление выигрышным и пробуем его
                DirWin = True
                LetsTry = True
                # В этом цикле мы будем двигаться по направлению пока имеет смысл -- значения убывают и на границу не наткнулись
                while LetsTry :
                    # Проверяем выходим ли мы за границу? Если да -- выходим из цикла
                    n += d[0]
                    m += d[1]
                    print ("  n={}, m={}".format(n,m))
                    if (n < 0) or (n >= Row) or (m < 0) or (m >= Col) :
                        break
                    # Проверяем убывает ли значение, если нет -- направление проигрышное, выходим из цикла
                    if Arr[n][m] >= X :
                        DirWin = False
                        LetsTry = False
                # ... end while
                # Если направление выигрышное, то увеличиваем счётчик
                if DirWin :
                    NWin += 1
            # ... end for Dir
        # ... end for Col
    # ... end for Row
    return NWin