数组操作，并将它们组

Question

我有两个阵列

id_array :{2 1 1 2 3 1 2} 
type_array :{apple apple orange orange pineapple pineapple pineapple} 

我要处理的上述阵列和基于我想组以下的ID和类型，如下所示：

苹果2 apple 1 orange 1 2 菠萝3 菠萝1 2

Answer 1

这是非常平行于acheong87的答案，但我会用一本字典的数据结构

set types {apple apple orange orange pineapple pineapple pineapple} 
set ids {2 1 1 2 3 1 2} 

set groups [dict create] 
foreach id $ids type $types { 
    dict lappend groups $type [list $id $type] 
} 
puts $groups 
# apple {{2 apple} {1 apple}} orange {{1 orange} {2 orange}} pineapple {{3 pineapple} {1 pineapple} {2 pineapple}} 

set out [list] 
dict for {type sublist} $groups {lappend out $sublist} 
puts out 
# {{2 apple} {1 apple}} {{1 orange} {2 orange}} {{3 pineapple} {1 pineapple} {2 pineapple}} 

---

更新因要求说明：

set ids {2 1 1 2 3 1 2} 
set types {apple apple orange orange pineapple pineapple pineapple} 
set groups [list] 
set current_type "" 
set prev_id -1 
foreach id $ids type $types { 
    if {$type ne $current_type || $id < $prev_id} { 
     if {[info exists group]} {lappend groups $group} 
     set group [list] 
     set current_type $type 
    } 
    lappend group [list $id $type] 
    set prev_id $id 
} 
lappend groups $group 
puts [list $groups] 

相比，你问的这个输出

{{{2 apple}} {{1 apple}} {{1 orange} {2 orange}} {{3 pineapple}} {{1 pineapple} {2 pineapple}}} 

注意额外的支撑。最终列表$groups是列表的列表。每个元素（或“子列表”）保持一致的结构。我们看到：

• 与含有列表1个元素{2苹果}的列表，
• 与含有列表1个元素{1个苹果}的列表，
• 与含有列表{2个元素的列表1 orange}和列表{2 orange}，
• 一个包含列表{1 pineapple}的元素的列表，以及
• 列出了包含列表{2菠萝}和列表{2 pineapple} 。报告这个最终名单

一种方法是：

foreach sublist $groups { 
    foreach pair $sublist { 
     lassign $pair id type 
     puts "$id -> $type" 
    } 
} 

印刷

2 -> apple 
1 -> apple 
1 -> orange 
2 -> orange 
3 -> pineapple 
1 -> pineapple 
2 -> pineapple 

---

回答最后一个请求：给定上述最终名单：

set answer [list] 
foreach sublist $groups { 
    lappend answer [lindex $sublist 0 1] 
    foreach pair $sublist {lappend answer [lindex $pair 0]} 
} 
puts [join $answer] 

打印

apple 2 apple 1 orange 1 2 pineapple 3 pineapple 1 2 

Answer 2

欢迎来到Stack Overflow。通常，我们喜欢看到用户尝试解决他们自己的问题，因为它有助于将注意力集中到特定的含糊或误解，未来的访问者可能会发现有用。然而，我们通常也愿意提供帮助，无论如何：

Tcl有一个有趣的形式foreach，它允许我们同时迭代多个列表。

set id_array [list 2 1 1 2 3 1 2] 
set type_array [list apple apple orange orange pineapple pineapple pineapple] 
foreach id $id_array type $type_array { 
    lappend hash($type) [list $id $type] 
} 
foreach name [array names hash] { 
    lappend output $hash($name) 
} 
puts $output 

这种输出，对我来说，

{{1 orange} {2 orange}} {{3 pineapple} {1 pineapple} {2 pineapple}} {{2 apple} {1 apple}}