Question

我必须列出两个清单。一个是姓名（str），另一个是工资（int）。然后，我必须用名字对工资进行分类。问题是，总是当我这样做时，只有工资被分类。

names = ["Asia","Łukasz","Aneta","Ola","Mikołaj"]
wages = [15000,1500,200,14500,2600]

print("Here(should) be sorted list")
wages.sort()
for i in range (len(wages)) :
    print(wages[i],names[i])

要明确的是，我想将这两个列表保持为一个并对它们进行排序。用简单的方法就可以了。没有函数，集合，拉链等。只需循环。

Answer 1

如果你想用循环做这个，你可以自己实现一些排序算法，并在wages和for j in range(len(wages)-1,0,-1): for i in range(j): if wages[i]>wages[i+1]: tempWage = wages[i] wages[i] = wages[i+1] wages[i+1] = tempWage tempName = names[i] names[i] = names[i+1] names[i+1] = tempName之间交换相应的元素。

以下是冒泡排序的示例：

using System;
using System.Collections.Generic;
public struct PacketPenetration
{    
    private Dictionary<double, double[,]> penetration;
    public PacketPenetration(Dictionary<double, double[,]> penetration)
    {        
        this.penetration = penetration;
    }

    public Dictionary<double, double[,]> Penetration { get { return penetration; } }

    public double this[double index1, int index2, int index3]
    {
        get
        {
            return this.penetration[index1][index2,index3];
        }
    }
}

Answer 2

对，没有拉链和套装。我们会这么做。

首先，复印一份工资：

>>> wages_c = wages[:]

对副本进行排序：

>>> wages_c.sort()

现在，迭代副本并找到相应的原始名称：

>>> for wage in wages_c:
...     key = wages.index(wage)
...     print(wages[key], names[key])

这是愚蠢的，如果你有重复的名字或重复的工资，它将不起作用，但它不使用zip或集。

原始解决方案：

我们从您的列表开始：

>>> names = ["Asia","Łukasz","Aneta","Ola","Mikołaj"]
>>> wages = [15000,1500,200,14500,2600]

合并他们：

>>> names_and_wages = list(zip(names, wages))

按第二个元素排序：

>>> names_and_wages.sort(key=lambda x: x[1])

并打印：

>>> for name, wage in names_and_wages:
...     print(name, wage)

Answer 3

好吧。如果您不想以任何方式合并列表，那么您需要手动编写排序算法，返回一系列移动，您可以将这些移动应用于两个列表以使它们进入相同的顺序。如果列表中只有一个列表中的唯一元素，则可以简化此操作，然后查看每个元素移动到的位置，并将相同的更改应用于其他列表。

更明智的回答

您有两个彼此依赖的列表，即列表中元素的位置。

你需要根据你想要的名字或工资来决定它们吗？

您可以使用循环轻松zip这两个列表

i = 0
merged = []
while i < len(wages):
  merged.append((wages[i], names[i]))

然后使用sort和key = lambda x: x[0]按工资排序，key = lambda x: x[1]按名称排序。

Answer 4

您可以使用类似于numpy.argsort的功能：将索引列表按正确的顺序排序，然后使用它重新排列两个列表：

inds = list(range(len(wages))) # This can be converted into a while loop that appends elements until `len(wages)` is reached
inds.sort(key=lambda x: wages[x]) # Or did you want names[x] here?
sorted_wages = []
sorted_names = []
for ind in inds:
    sorted_wages.append(wages[ind])
    sorted_names.append(names[ind])

您可以使用一个键来选择工资（如图所示lambda x: wages[x]）或名称（lambda x: names[x]）进行排序。如果你真的想要，可以用

之类的东西替换第一行

inds = []
count = 0
while count < len(wages):
    inds.append(count)
    count += 1

结果如预期：

>>> sorted_wages
[200, 1500, 2600, 14500, 15000]
>>> sorted_names
['Aneta', 'Łukasz', 'Mikołaj', 'Ola', 'Asia']

Answer 5

我认为一种方法是建立一个字典来存储名称和工资。

String regex = "[\\p{Punct}\\s]";
String input = "don't nod";
System.out.println(input.replaceAll(regex, ""));

Answer 6

修改：没有任何功能，严重......没有len()，没有range()，没有.sort()

初始化我们的东西，

In [1]: names = ["Asia","Łukasz","Aneta","Ola","Mikołaj"]
   ...: wages = [15000,1500,200,14500,2600]
   ...:

计算列表的长度

In [2]: l = 0
   ...: for w in wages: l += 1
   ...:

执行一个简单的冒泡排序，我们不仅在我们正在排序的列表中交换元素，而且还在兄弟列表中交换元素

In [3]: j = 0
   ...: while j<(l-1):
   ...:     i = 0 
   ...:     while i<(l-1-j):
   ...:         if wages[i]>wages[i+1]:
   ...:             wages[i], wages[i+1] = wages[i+1], wages[i]
   ...:             names[i], names[i+1] = names[i+1], names[i]
   ...:         i += 1
   ...:     j += 1
   ...:

并打印结果

In [4]: print names, '\n', wages
['Aneta', 'Łukasz', 'Mikołaj', 'Ola', 'Asia']
[200, 1500, 2600, 14500, 15000]

在冒泡排序中，每个后续内循环都在较短（1）子列表上运行，因为每个内循环的净效果是将当前子列表的最大元素放在其中可用的最后位置。

我们只需要l-1个循环，因为在l-1 - 内循环中，我们在长度为2的子列表上操作，当它完成时，整个子列表完全排序。

冒泡排序不是一种有效的算法，但考虑到问题的 homeworkicity ，我认为使用非常简单的算法比使用有效算法更为重要。

列表排序 - 将两个列表合并为一个

6 个答案:

原始解决方案：