Question

我正在解决一个排序问题。我遇到了一个困扰我2天的问题。

我运行代码以获得更短的输入，它就像我期望的那样工作。但是，当我在此程序中输入更长的输入时，会出现运行时错误。

以下是代码：

row_number, row_length = input().split()
row_number, row_length = int(row_number), int(row_length)
def row_input():
    data_input = []    
    for i in range(0,row_number):
        row = list(map(int,input().split()))
        data_input.append(row)
    return data_input   

def sort_data(data):
    k = int(input())
    sorted_data = []
    for row in data:
        sorted_data.append(row[k])
    sorted_data.sort()
    n = 0
    while n < row_number:
        for m in data:
            if sorted_data[n] == m[k]:
                print_data(m)
                n = n + 1

def print_data(data):
    b=''
    for n in data:
        b= b + str(n).ljust(len(str(n))+1)
    print(b)  

data = row_input()
sort_data(data)

这是简短的输入：

这是更长的输入：

100 10
64 79 18 94 46 81 74 97 71 92
46 24 23 20 68 15 53 93 24 91
17 66 34 64 28 5 55 25 44 96
16 71 80 84 5 79 63 77 69 77
33 77 24 13 58 81 41 36 73 62
93 26 16 55 61 51 39 69 29 45
44 85 1 48 23 59 52 82 50 37
77 74 9 21 35 54 81 57 32 76
82 21 72 49 98 21 77 64 6 63
68 17 93 83 12 43 84 28 96 86
9 16 3 89 38 11 70 25 41 38
49 99 31 19 85 97 80 63 16 69
50 85 80 75 36 48 56 69 63 94
78 80 83 86 92 60 56 90 22 73
69 81 45 9 67 25 82 46 68 82
98 38 23 31 38 83 37 76 69 82
95 48 21 64 25 6 38 96 69 23
44 97 46 54 21 56 65 51 66 34
87 22 27 24 55 48 90 10 8 51
21 6 74 78 8 88 26 63 72 43
64 4 42 20 54 91 2 51 79 40
93 76 52 58 40 78 98 27 53 48
85 23 86 30 91 49 81 4 59 9
88 96 77 95 36 71 7 52 14 20
69 98 21 94 14 35 28 97 3 9
60 47 56 34 35 61 9 44 80 92
4 76 57 28 60 3 46 4 6 17
59 44 88 7 71 60 84 12 91 38
76 57 5 2 25 12 46 62 32 68
14 15 11 1 34 20 54 58 45 38
89 49 16 43 74 51 80 22 88 31
8 98 51 73 32 13 59 12 56 92
36 82 9 63 77 79 77 25 52 91
63 82 58 75 13 20 79 89 55 89
58 37 93 1 29 72 78 95 47 35
90 82 58 60 55 86 82 22 44 94
55 17 51 99 29 92 1 79 96 34
32 78 41 1 24 52 11 80 3 25
30 32 32 71 85 80 63 23 80 97
35 22 11 71 10 48 43 58 31 33
30 98 60 58 28 71 95 28 21 29
74 4 13 99 90 64 28 27 73 4
52 21 52 31 35 82 35 64 21 71
92 85 13 48 5 32 92 70 15 85
47 55 25 80 24 22 19 78 17 43
3 91 71 53 49 39 96 88 59 61
79 26 98 2 95 95 70 38 82 85
69 67 41 11 95 39 20 19 96 36
11 74 48 23 84 49 47 43 27 90
4 28 35 14 70 62 52 94 46 91
72 11 14 82 59 51 93 98 55 79
90 84 84 24 21 81 11 57 27 78
98 97 59 51 89 40 96 35 25 59
73 85 64 17 46 9 79 54 27 15
48 91 7 56 41 6 4 26 96 39
43 22 34 89 52 59 55 52 38 42
10 31 9 8 21 46 29 4 97 4
44 49 78 31 53 29 11 35 46 14
44 39 57 35 9 63 85 5 97 24
9 72 49 50 41 47 23 71 15 45
51 6 98 64 75 35 39 48 2 50
92 22 72 60 96 15 17 4 79 27
90 30 98 28 92 8 83 71 24 62
5 54 86 14 71 96 87 2 58 78
37 61 60 30 46 96 49 58 27 48
14 59 22 35 75 60 55 28 91 85
21 1 85 85 78 67 24 69 22 17
76 61 84 64 33 76 61 10 33 95
71 9 1 32 31 80 69 7 25 59
69 64 78 85 21 88 56 70 92 74
79 12 8 9 54 56 37 44 1 84
6 66 54 5 82 17 41 25 3 71
8 44 63 17 75 43 87 15 85 3
15 42 15 59 38 22 46 27 19 13
54 71 76 93 67 39 46 12 78 46
23 82 71 34 31 61 94 58 10 62
30 8 43 38 7 23 77 38 93 32
32 72 46 59 64 45 14 73 62 72
76 26 47 89 25 73 79 28 60 48
41 58 85 55 29 64 39 84 20 87
24 8 70 16 69 32 17 26 58 16
40 53 40 63 22 37 11 74 7 8
23 4 56 39 27 94 91 72 14 61
41 86 3 29 41 15 99 50 82 84
33 5 22 93 73 86 99 87 26 66
73 25 55 46 69 38 99 14 43 55
43 21 82 30 90 66 6 67 49 25
81 38 65 40 80 7 90 82 33 13
18 45 1 90 53 51 51 96 32 90
32 69 51 22 71 85 80 61 99 23
88 8 41 92 4 25 64 89 30 75
93 85 99 87 67 3 54 16 98 57
33 54 31 83 64 93 3 24 65 81
74 19 15 66 17 14 34 50 57 16
10 30 20 97 32 85 83 89 68 18
46 82 9 14 54 50 55 28 26 96
29 96 3 33 12 52 11 26 19 22
50 81 95 59 76 53 10 9 72 87
25 85 54 43 53 13 52 70 38 76
20 14 30 80 23 43 27 67 42 11
5

运行较长输入时出现错误：

Traceback (most recent call last):
  File "solution.py", line 30, in <module>
    sort_data(data)
  File "solution.py", line 19, in sort_data
    if sorted_data[n] == m[k]:
IndexError: list index out of range

Answer 1

问题出在你的排序逻辑中，因为如果数据集中有多个匹配的行，你很有可能在while循环的一次迭代中增加n。

正确的解决方案比您想象的更简单：

def sort_data(data):
    k = int(input())
    output = sorted(data, key=lambda row: row[k])
    for r in output:
        print_data(r)

更新：算法失败的最小数据集是：

对您的功能进行小修改将阻止其过度索引。关键是将sorted_data[n]存储在变量中，这样当不再需要输出时，它不会尝试覆盖sorted_data索引。

def sort_data(data):
    k = int(input())
    sorted_data = []
    for row in data:
        sorted_data.append(row[k])
    sorted_data.sort()
    n = 0
    while n < row_number:
        key = sorted_data[n]
        for m in data:
            if key == m[k]:
                print_data(m)
                n = n + 1

更新：

sorted函数的关键参数是一个函数，它只选择要排序的值。在您的情况下，选择k列，这是您要排序的列。

当我有更长的输入时弹出python索引错误

1 个答案: