Geely schriftlicher Test – Fragen zum Programmiercode

F1:

Angenommen, es gibt eine Tabelle mit n Zeilen und m Spalten, die in n✖️m Blöcke unterteilt werden kann.

• Es gibt eine diagonale Linie, die die obere linke Ecke mit der unteren rechten Ecke verbindet. Alle Blöcke in der Tabelle, die die diagonale Linie berühren, sind weiß, das heißt, die diagonale Linie verläuft durch die kleinen Blöcke in der Tabelle.
• Geben Sie die Größe der Tabelle ein und geben Sie die Anzahl der weißen Blöcke aus.

Ein Rechteck mit n Zeilen und m Spalten kann als in n✖️m quadratische Blöcke der Größe eins unterteilt betrachtet werden. Zählen Sie die Anzahl der passierenden Blöcke auf der Ausgangsdiagonale.

Beispiel: Geben Sie 3, 4 ein. sollte 6 ausgeben

• Wenn entwedern oder m ist1, dann verläuft die Diagonale nur durch einen Block, nämlich n * m.
• Andernfalls verläuft die diagonale Linie durch die erste Zeile des Rechtecks, die letzte Zeile , erste Spalte und letzte Spalte werden die Blöcke auf diesen vier Zeilen wiederholt gezählt. Die verbleibenden Blöcke werden nur einmal gezählt. Daher kann die Anzahl der passierenden Blöcke auf der Diagonale wie folgt berechnet werden:
  • Anzahl der diagonalen Blöcke = $N+M-1-gcd(n,m)+1$
  • Daruntergcd(n, m)AnzeigeDie größte gemeinsame Zahl der Summe von n.

import math

def count_diagonal_blocks(n, m):
    if n == 1 or m == 1:
        return n * m
    else:
        return n + m - math.gcd(n, m)

# 输入表格的大小
n = 3
m = 4

# 计算对角线上经过的块的数量
diagonal_blocks = count_diagonal_blocks(n, m)
print("对角线上经过的块的数量:", diagonal_blocks)

---

F2:

Geben Sie eine Liste von Zeichenfolgen ein, die ein Labyrinth darstellen.

• Unter diesen repräsentiert j die Wand, 空格 den Eingang und k die Ausgangsposition der Person .
• Menschen können sich nur nach links oder rechts oder nach oben oder unten bewegen.
• Beachten Sie, dass das Labyrinth nicht quadratisch sein muss.
• Bitte geben Sie „true“ aus, um anzuzeigen, dass Personen herauskommen können, andernfalls geben Sie „false“ aus.

Geben Sie beispielsweise [„j jj“, „j kj“, „jjjj“] ein. Ausgabe wahr

Wenn es nur ein Element k gibt, wird auch true ausgegeben
Wenn der äußere Kreis nur aus Wand j besteht, wird auch false ausgegeben

def can_escape_maze(maze):
    if not maze:
        return False

    def dfs(x, y):
        if x < 0 or x >= len(maze) or y < 0 or y >= len(maze[0]) or maze[x][y] == 'j':
            return False

        if maze[x][y] == ' ':
            return True

        maze[x] = maze[x][:y] + 'j' + maze[x][y + 1:]

        if (dfs(x + 1, y) or
            dfs(x - 1, y) or
            dfs(x, y + 1) or
            dfs(x, y - 1)):
            return True

        return False

    # 检查外围一圈是否都是墙
    for i in range(len(maze)):
        if i == 0 or i == len(maze) - 1:
            for j in range(len(maze[i])):
                if maze[i][j] != 'j':
                    return False
        else:
            if maze[i][0] != 'j' or maze[i][-1] != 'j':
                return False

    # 找到起始位置
    for i in range(1, len(maze) - 1):
        for j in range(1, len(maze[i]) - 1):
            if maze[i][j] == 'k':
                return dfs(i, j)

    return False

# 输入迷宫
maze = [
    "jjjjjjjj",
    "j j jj j",
    "j jkj  j",
    "j j j jj",
    "j j j  j",
    "j      jj",
    "jjjjjjjj"
]

# 检查是否可以走出迷宫
result = can_escape_maze(maze)
print(result)

---

F3:

Geben Sie ein Array der Größe n✖️n ein, das im Uhrzeigersinn von von außen nach innen ausgegeben werden muss.

• Beispiel, Import $[[1,2,3],[4,5,6],[7,8,9]]$ 输出应该为 $[1,2,3,6,9,8,7,4,5]$

Durchlaufen Sie die äußeren Elemente der Matrix nacheinander im Uhrzeigersinn von außen nach innen und dann Schicht für Schicht nach innen gehen

def spiral_order(matrix):
    if not matrix:
        return []

    result = []
    while matrix:
        # 从左到右
        result += matrix[0]

        # 从上到下
        if len(matrix) > 1:
            for row in matrix[1:-1]:
                if row:
                    result.append(row[-1])

        # 从右到左
        if len(matrix) > 1:
            result += matrix[-1][::-1]

        # 从下到上
        if len(matrix) > 2:
            for row in matrix[-2:0:-1]:
                if row:
                    result.append(row[0])

        # 剔除已经遍历的外围元素
        matrix = matrix[1:-1]
        for i in range(len(matrix)):
            if matrix[i]:
                matrix[i] = matrix[i][1:-1]

    return result

# 输入矩阵
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 获取顺时针排列的结果
result = spiral_order(matrix)
print(result)