zsh

para inverter valores de chaves <=>

Em zsh, onde a sintaxe primária para definir um hash é hash=(k1 v1 k2 v2...)como em perl(versões mais recentes também suportam a estranha sintaxe ksh93/bash para compatibilidade, embora com variações quando se trata de citar as chaves)

keys=( "${(@k)hash}" )
values=( "${(@v)hash}" )

typeset -A reversed
reversed=( "${(@)values:^keys}" ) # array zipping operator

Ou usando o Oasinalizador de expansão de parâmetro para inverter a ordem da lista de chave+valor:

typeset -A reversed
reversed=( "${(@kvOa)hash}" )

ou usando um loop:

for k v ( "${(@kv}hash}" ) reversed[$v]=$k

As @aspas e duplas são para preservar chaves e valores vazios (observe que bashmatrizes associativas não suportam chaves vazias). Como a expansão de elementos em arrays associativos não está em nenhuma ordem particular, se vários elementos de $hashtiverem o mesmo valor (o que acabará sendo uma chave em $reversed), você não poderá dizer qual chave será usada como valor em $reversed.

para o seu laço

Você usaria o Rsinalizador de subscrito de hash para obter elementos com base em valor em vez de chave, combinado com ecorrespondência exata (em oposição a curinga) e, em seguida, obter as chaves para esses elementos com o ksinalizador de expansão de parâmetro:

for value ("${(@u)hash}")
  print -r "elements with '$value' as value: ${(@k)hash[(Re)$value]}"

sua abordagem perl

zsh(ao contrário de ksh93) não suporta arrays de arrays, mas suas variáveis ​​podem conter o byte NUL, então você pode usar isso para separar elementos se os elementos não contiverem bytes NUL, ou usar o ${(q)var}/ ${(Q)${(z)var}}para codificar/decodificar uma lista usando citação.

typeset -A seen
for k v ("${(@kv)hash}")
  seen[$v]+=" ${(q)k}"

for k v ("${(@kv)seen}")
  print -r "elements with '$k' as value: ${(Q@)${(z)v}}"

ksh93

ksh93 foi o primeiro shell a introduzir arrays associativos em 1993. A sintaxe para atribuir valores como um todo significa que é muito difícil fazê-lo programaticamente ao contrário de zsh, mas pelo menos é um pouco justificado em ksh93 que ksh93suporta estruturas de dados aninhadas complexas.

Em particular, aqui ksh93 suporta arrays como valores para elementos hash, então você pode fazer:

typeset -A seen
for k in "${!hash[@]}"; do
  seen[${hash[$k]}]+=("$k")
done

for k in "${!seen[@]}"; do
  print -r "elements with '$k' as value ${x[$k][@]}"
done

festança

bashadicionou suporte para matrizes associativas décadas depois, copiou a sintaxe ksh93, mas não as outras estruturas de dados avançadas, e não possui nenhum dos operadores de expansão de parâmetros avançados do zsh.

Em bash, você pode usar a abordagem de lista citada mencionada no zsh usando printf %qou com versões mais recentes ${var@Q}.

typeset -A seen
for k in "${!hash[@]}"; do
  printf -v quoted_k %q "$k"
  seen[${hash[$k]}]+=" $quoted_k"
done

for k in "${!seen[@]}"; do
  eval "elements=(${seen[$k]})"
  echo -E "elements with '$k' as value: ${elements[@]}"
done

Como observado anteriormente, no entanto, bashas matrizes associativas não suportam o valor vazio como chave, portanto, não funcionará se alguns dos $hashvalores de ' estiverem vazios. Você pode optar por substituir a string vazia por algum espaço reservado como <EMPTY>ou prefixar a chave com algum caractere que depois removeria para exibição.

O obstáculo, como tenho certeza que você sabe, é obter o valor inteiro de um array indexado ao ter seu nome como valor de uma (outra) variável. Eu não poderia fazer isso com menos do que ter um intermediário cujo valor se tornasse de formato ${v[@]}e depois usar eval nele. Então, aqui está essa abordagem:

declare -A keys
N=0 # counter for the index variables IX1, IX2, IX3, ...
for key in "${!hash[@]}"; do
    value="${hash[$key]}"
    if [ -z "${keys[$value]}" ] ; then N=$((N+1)) ; keys[$value]=IX$N ; fi
    index="${keys[$value]}" # 'index' is now name of index variable
    X="\${$index[@]}"
    eval "$index=( $X $key )" # adding next key to it
done

for value in "${!keys[@]}" ; do
    index=${keys[$value]}
    X="\${$index[@]}"
    printf "Value %s is present with the following keys: %s\n" \
       "$value" "$(eval echo "$X")"
done

Isso é para Linux bash. Ele cria arrays indexados IX1, IX2, etc., para os vários valores que encontra e mantém esses nomes no keysarray associativo para os valores. Assim, ${keys[$value]}é o nome do array indexado que contém as chaves para aquele valor. Em seguida X, configura-se a variável "frase de acesso" para a coleta de valores, permitindo eval echo "$X"traduzir para esses valores com separação de espaços. Por exemplo, se um valor tiver indexado array IX2, então Xserá a string ${IX2[@]}.

Eu acredito que zshé semelhante em não suportar matrizes de matrizes, então provavelmente exigiria uma solução semelhante. IMHO, porém, as frases de acesso zshsão um pouco mais claras.

Usando Raku (anteriormente conhecido como Perl_6)

my %hash = (
    'foo'    => 'aa',
    'bar'    => 'bb',
    'baz'    => 'aa',
    'quux'   => 'bb',
    'wibble' => 'cc',
    'wobble' => 'aa'
);

my %inverted = %hash.classify( { .value }, :as{ .key } );

for %inverted.kv -> $k, $v {
     printf( "Value \"%s\" is present with the following keys: %s\n", 
     $k, $v ) };

Resultado:

Value "aa" is present with the following keys: wobble baz foo
Value "bb" is present with the following keys: bar quux
Value "cc" is present with the following keys: wibble

Resumidamente, o cerne do trabalho aqui é feito usando a rotina do Raku classify, que testa %hashelementos de acordo com seu .valuecomponente e classifica valores equivalentes :asa .key.

Um one-liner que faz a maior parte do trabalho é o seguinte (pode ser executado no Raku REPL):

.say for %hash.classify: {.value}, :as{.key};

cc => [wibble]
aa => [baz wobble foo]
bb => [quux bar]

Adendo (1): O Raku tem uma função semelhante à classifyconhecida como categorize. Para o código acima, classifypode ser substituído por categorizecom resultados idênticos.

Adendo (2): Se você quiser reconstruir o %hashobjeto original de %inverted, você pode chamar a invertrotina nele. De acordo com os documentos: "A diferença entre inverte antipairsé que a inversão expande os valores da lista em vários pares".

https://docs.raku.org/routine/classify
https://docs.raku.org/routine/categorize
https://docs.raku.org/routine/invert
https://raku.org

Aqui está uma abordagem alternativa - tenha dados em duas matrizes indexadas. Um deles possui valores únicos e o segundo pode conter valores repetidos/duplicados. Pode-se construir o array associativo que tem elementos duplicados do segundo array como chaves e entradas correspondentes do primeiro array como valores separados por espaço.

O código abaixo evita usar evale usa apenas um forloop

código

source=("foo" "bar" "baz" "quux" "wibble" "wobble")
destination=("aa" "bb" "aa" "bb" "cc" "aa")

declare -A inverted_array

# Printout formatted arrays with headers
printf '%-10s %-20s %-30s\n' "Index" "Destination" "Source"

for ((i = ((${#source[@]} - 1)); i >= 0; i--)); do

    source_i="${source["$i"]}"
    destination_i="${destination["$i"]}"

    printf '%-10s %-20s %-30s\n' "$i" "$destination_i" "$source_i"

    tempstring="${inverted_array["$destination_i"]}"
    inverted_array["$destination_i"]="$source_i"" ""$tempstring"

done
echo
printf '%-10s %-20s\n' "Key" "Value"

# Remove the last space from the every element of the resulted array and print it formatted
for index in "${!inverted_array[@]}"; do

    removespace="${inverted_array[$index]}"
    removespace=${removespace%" "}
    inverted_array["$index"]="$removespace"
    printf '%-10s %-20s\n' "$index" "${inverted_array["$index"]}"
done
echo

Resultado:

Index      Destination          Source
5          aa                   wobble
4          cc                   wibble
3          bb                   quux
2          aa                   baz
1          bb                   bar
0          aa                   foo

Key        Value
bb         bar quux
aa         foo baz wobble
cc         wibble

PS Para expandir/demonstrar ainda mais o exemplo acima - aqui está um código a seguir que gera dois arrays. Um deles - sourcecontendo 5 caracteres aleatórios de comprimento e o segundo - destinationcontém apenas como valores aleatórios apenas um caractere 0-9a-f.

Código para gerar dois arrays de índice, cada um com 100 elementos:

    for ((i = 0; i < 100; i++)); do
        source+=("$(tr -dc 'a-zA-Z' </dev/urandom | head -c 5)")
        destination+=("$(tr -dc '0-9a-f' </dev/urandom | head -c 1)")
    done

Usando o código acima para criar um array associativo, o resultado é o seguinte:

Key        Value
9          soxRg PmUZv eOmkR cFuie wmlsO EdNdM XuloF SSfjE oHfnc FcIKE
8          hLRpa eXODM wRGkh MwZUW lfWaE WQiwU IHGjj nNEcg
7          Pdxmd ywPZQ lPQIx TKawd VTyqR
6          lIwla Docxu Dimnz ovywP HwzQv
5          ObezH tyFNS BqnWp CFlMk dDkYC
4          rNzLM GVLXH AgZSL ionEp tngzQ
3          yRfqn IdTne
2          sMSxm WKmGm ELjOL pqxqw stWnL
1          yxycd EAGRg WxBle ItLNz WUdVu shUaC qDNIO xIwdM
0          OXdHh VQcsT AFvFq sgrYK AQrjZ
f          uXJor IkwDr AOGSK hYMGE PQQfu tUjbh NwrVi iqZKO hHLYU
e          XhMpB TCCFr ATbxa
d          ReqMh lbxFx bGivd YCGtv lAtZj
c          Kvthr itbaF wIbaf LwUiB VTInv xvWbC gpyRZ
b          riimt EkLbv QYpZq kgvTi tOJRH jZykW pRuMD FJVXZ xipDx wkCMN
a          REJnb Xtunv raimk SemnZ xMwno EXwKi sekmg WUKhx