Przecięcie dwóch tablic w BASH

12

Mam dwie takie tablice:

A=(vol-175a3b54 vol-382c477b vol-8c027acf vol-93d6fed0 vol-71600106 vol-79f7970e vol-e3d6a894 vol-d9d6a8ae vol-8dbbc2fa vol-98c2bbef vol-ae7ed9e3 vol-5540e618 vol-9e3bbed3 vol-993bbed4 vol-a83bbee5 vol-ff52deb2)
B=(vol-175a3b54 vol-e38d0c94 vol-2a19386a vol-b846c5cf vol-98c2bbef vol-7320102b vol-8f6226cc vol-27991850 vol-71600106 vol-615e1222)

Tablice nie są sortowane i mogą nawet zawierać zduplikowane elementy.

  1. Chciałbym zrobić przecięcie tych dwóch tablic i przechowywać elementy w innej tablicy. Jak mam to zrobić?

  2. Ponadto, jak mogę uzyskać listę elementów, które pojawiają się w B i nie są dostępne w A?

Bogdan
źródło
2
Używaj prawdziwego języka programowania, a nie powłoki do tego rodzaju zadań.
Stéphane Chazelas,
1
Czy musisz zachować kolejność elementów? Jeśli istnieją zduplikowane elementy (np. A i B zawierają foodwa razy), czy potrzebujesz ich w wyniku?
Gilles „SO- przestań być zły”,

Odpowiedzi:

14

comm(1)to narzędzie, które porównuje dwie listy i może dać ci przecięcie lub różnicę między dwiema listami. Listy należy posortować, ale łatwo to osiągnąć.

Aby uzyskać tablice na posortowaną listę odpowiednią dla comm:

$ printf '%s\n' "${A[@]}" | LC_ALL=C sort

To zmieni tablicę A w posortowaną listę. Zrób to samo dla B.

Aby użyć, commaby zwrócić skrzyżowanie:

$ comm -1 -2 file1 file2

-1 -2 mówi, aby usunąć wpisy unikalne dla file1 (A) i unikalne dla file2 (B) - przecięcie tych dwóch.

Aby to zwróciło to, co jest w pliku 2 (B), ale nie w pliku 1 (A):

$ comm -1 -3 file1 file2

-1 -3 mówi, aby usunąć wpisy unikalne dla pliku 1 i wspólne dla obu - pozostawiając tylko te unikalne dla pliku 2.

Aby zasilić dwa rurociągi comm, użyj funkcji „Process Substitution” w bash:

$ comm -1 -2 <(pipeline1) <(pipeline2)

Aby przechwycić to w tablicy:

$ C=($(command))

Kładąc wszystko razem:

# 1. Intersection
$ C=($(comm -12 <(printf '%s\n' "${A[@]}" | LC_ALL=C sort) <(printf '%s\n' "${B[@]}" | LC_ALL=C sort)))

# 2. B - A
$ D=($(comm -13 <(printf '%s\n' "${A[@]}" | LC_ALL=C sort) <(printf '%s\n' "${B[@]}" | LC_ALL=C sort)))
camh
źródło
Działa to tylko wtedy, gdy twoje wartości nie zawierają \n.
Chris Down,
@ChrisDown: Zgadza się. Zawsze próbuję pisać skrypty powłoki, które są odpowiednio cytowane i obsługują wszystkie znaki, ale zrezygnowałem z \ n. NIGDY nie widziałem go w nazwie pliku, a duża grupa narzędzi uniksowych działa z \ n ograniczonymi rekordami, które dużo tracisz, jeśli spróbujesz traktować \ n jako prawidłowy znak.
camh
1
Widziałem to w nazwach plików podczas korzystania z menedżerów plików GUI, które nie oczyszczają poprawnie wejściowych nazw plików, które są kopiowane gdzie indziej (także nikt nie powiedział nic o nazwach plików).
Chris Down,
Aby chronić, \nspróbuj tego:arr1=( one two three "four five\nsix\nseven" ); arr2=( ${arr1[@]:1} "four five\\nsix" ); n1=${#arr1[@]}; n2=${#arr2[@]}; arr=( ${arr1[@]/ /'-_-'} ${arr2[@]/ /'-_-'} ); arr=( $( echo "${arr[@]}"|tr '\t' '-t-'|tr '\n' '-n-'|tr '\r' '-r-' ) ); arr1=( ${arr[@]:0:${n1}} ); arr2=( ${arr[@]:${n1}:${n2}} ); unset arr; printf "%0.s-" {1..10}; printf '\n'; printf '{'; printf " \"%s\" " "${arr1[@]}"; printf '}\n'; printf "%0.s-" {1..10}; printf '\n'; printf '{'; printf " \"%s\" " "${arr2[@]}"; printf '}\n'; printf "%0.s-" {1..10}; printf '\n\n'; unset arr1; unset arr2
Jason R. Mick
Nie należy ustawiać LC_ALL=C. Zamiast tego ustaw LC_COLLATE=Cten sam przyrost wydajności bez innych efektów ubocznych. W celu uzyskania poprawnych wyników należy również ustawić takie samo zestawienie, commjakie zastosowano sort, np .:unset LC_ALL; LC_COLLATE=C ; comm -12 <(printf '%s\n' "${A[@]}" | sort) <(printf '%s\n' "${B[@]}" | sort)
Sorpigal
4

Możesz uzyskać wszystkie elementy, które są zarówno w A, jak i B, zapętlając obie tablice i porównując:

A=(vol-175a3b54 vol-382c477b vol-8c027acf vol-93d6fed0 vol-71600106 vol-79f7970e vol-e3d6a894 vol-d9d6a8ae vol-8dbbc2fa vol-98c2bbef vol-ae7ed9e3 vol-5540e618 vol-9e3bbed3 vol-993bbed4 vol-a83bbee5 vol-ff52deb2)
B=(vol-175a3b54 vol-e38d0c94 vol-2a19386a vol-b846c5cf vol-98c2bbef vol-7320102b vol-8f6226cc vol-27991850 vol-71600106 vol-615e1222)

intersections=()

for item1 in "${A[@]}"; do
    for item2 in "${B[@]}"; do
        if [[ $item1 == "$item2" ]]; then
            intersections+=( "$item1" )
            break
        fi
    done
done

printf '%s\n' "${intersections[@]}"

Możesz uzyskać wszystkie elementy w B, ale nie w A w podobny sposób:

A=(vol-175a3b54 vol-382c477b vol-8c027acf vol-93d6fed0 vol-71600106 vol-79f7970e vol-e3d6a894 vol-d9d6a8ae vol-8dbbc2fa vol-98c2bbef vol-ae7ed9e3 vol-5540e618 vol-9e3bbed3 vol-993bbed4 vol-a83bbee5 vol-ff52deb2)
B=(vol-175a3b54 vol-e38d0c94 vol-2a19386a vol-b846c5cf vol-98c2bbef vol-7320102b vol-8f6226cc vol-27991850 vol-71600106 vol-615e1222)

not_in_a=()

for item1 in "${B[@]}"; do
    for item2 in "${A[@]}"; do
        [[ $item1 == "$item2" ]] && continue 2
    done

    # If we reached here, nothing matched.
    not_in_a+=( "$item1" )
done

printf '%s\n' "${not_in_a[@]}"
Chris Down
źródło
Ćwiczenie: jeśli zamieniasz się Ai Bczy intersectionszawsze to samo dotyczy zmiany kolejności?
Gilles „SO - przestań być zły”,
@Gilles Jeśli tablice mogą zawierać zduplikowane elementy, nie.
Chris Down
3

Jest to dość eleganckie i wydajne podejście do tego, używając uniq- ale będziemy musieli wyeliminować duplikaty z każdej tablicy, pozostawiając tylko unikalne przedmioty. Jeśli chcesz zapisać duplikaty, istnieje tylko jeden sposób: „zapętlając obie tablice i porównując”.

Rozważmy, że mamy dwie tablice:

A=(vol-175a3b54 vol-382c477b vol-8c027acf vol-93d6fed0 vol-71600106 vol-79f7970e vol-e3d6a894 vol-d9d6a8ae vol-8dbbc2fa vol-98c2bbef vol-ae7ed9e3 vol-5540e618 vol-9e3bbed3 vol-993bbed4 vol-a83bbee5 vol-ff52deb2)
B=(vol-175a3b54 vol-e38d0c94 vol-2a19386a vol-b846c5cf vol-98c2bbef vol-7320102b vol-8f6226cc vol-27991850 vol-71600106 vol-615e1222)

Po pierwsze, pozwólmy przekształcić te tablice w zestawy. Zrobimy to, ponieważ istnieje przecięcie operacji matematycznych, które jest znane jako przecięcie zbiorów, a zbiór jest zbiorem różnych obiektów, wyraźnych lub niepowtarzalnych . Szczerze mówiąc, nie wiem, co to jest „skrzyżowanie”, jeśli mówimy o listach lub sekwencjach. Chociaż możemy wybrać podsekwencję z sekwencji, ale ta operacja (wybór) ma nieco inne znaczenie.

Przekształćmy się!

$ A=(echo ${A[@]} | sed 's/ /\n/g' | sort | uniq)
$ B=(echo ${B[@]} | sed 's/ /\n/g' | sort | uniq)
  1. Skrzyżowanie:

    $ echo ${A[@]} ${B[@]} | sed 's/ /\n/g' | sort | uniq -d

    Jeśli chcesz przechowywać elementy w innej tablicy:

    $ intersection_set=$(echo ${A[@]} ${B[@]} | sed 's/ /\n/g' | sort | uniq -d)
    
    $ echo $intersection_set
    vol-175a3b54 vol-71600106 vol-98c2bbef

    uniq -doznacza pokaż tylko duplikaty (myślę, że uniqjest dość szybki ze względu na jego realizację: Myślę, że jest to zrobione z XORoperacją).

  2. Uzyskaj listę elementów, które pojawiają się Bi nie są dostępne w A, tjB\A

    $ echo ${A[@]} ${B[@]} | sed 's/ /\n/g' | sort | uniq -d | xargs echo ${B[@]} | sed 's/ /\n/g' | sort | uniq -u

    Lub z zapisaniem w zmiennej:

    $ subtraction_set=$(echo ${A[@]} ${B[@]} | sed 's/ /\n/g' | sort | uniq -d | xargs echo ${B[@]} | sed 's/ /\n/g' | sort | uniq -u)
    
    $ echo $subtraction_set
    vol-27991850 vol-2a19386a vol-615e1222 vol-7320102b vol-8f6226cc vol-b846c5cf vol-e38d0c94

    Tak więc, na początku mamy przecięcie Ai B(który jest po prostu zbiorem duplikatów między nimi), powiedzmy, że tak A/\B, a następnie zastosowaliśmy operację odwracania przecięcia Bi A/\B(co jest po prostu tylko unikatowymi elementami), więc otrzymujemy B\A = ! (B /\ (A/\B)).

PS uniqnapisali Richard M. Stallman i David MacKenzie.

Kenichi
źródło
1

Ignorując wydajność, oto podejście:

declare -a intersect
declare -a b_only
for bvol in "${B[@]}"
do
    in_both=""
    for avol in "${A[@]}"
    do
        [ "$bvol" = "$avol" ] && in_both=Yes
    done
    if [ "$in_both" ]
    then
        intersect+=("$bvol")
    else
        b_only+=("$bvol")
    fi
done
echo "intersection=${intersect[*]}"
echo "In B only=${b_only[@]}"
John1024
źródło
0

Mój czysty bash sposób

Ponieważ zmienne te zawierają tylko vol-XXXtam, gdzie XXXjest liczba szesnastkowa, istnieje szybki sposób na użycie tablic bash

unset A B a b c i                    # Only usefull for re-testing...

A=(vol-175a3b54 vol-382c477b vol-8c027acf vol-93d6fed0 vol-71600106 vol-79f7970e
   vol-e3d6a894 vol-d9d6a8ae vol-8dbbc2fa vol-98c2bbef vol-ae7ed9e3 vol-5540e618
   vol-9e3bbed3 vol-993bbed4 vol-a83bbee5 vol-ff52deb2)
B=(vol-175a3b54 vol-e38d0c94 vol-2a19386a vol-b846c5cf vol-98c2bbef vol-7320102b
   vol-8f6226cc vol-27991850 vol-71600106 vol-615e1222)

for i in ${A[@]#vol-};do
    [ "${a[$((16#$i))]}" ] && echo Duplicate vol-$i in A
    ((a[$((16#$i))]++))
    ((c[$((16#$i))]++))
  done
for i in ${B[@]#vol-};do
    [ "${b[$((16#$i))]}" ] && echo Duplicate vol-$i in B
    ((b[$((16#$i))]++))
    [ "${c[$((16#$i))]}" ] && echo Present in A and B: vol-$i
    ((c[$((16#$i))]++))
  done

To musi generować:

Present in A and B vol-175a3b54
Present in A and B vol-98c2bbef
Present in A and B vol-71600106

W tym stanie środowisko bash zawiera:

set | grep ^c=
c=([391789396]="2" [664344656]="1" [706295914]="1" [942425979]="1" [1430316568]="1"
[1633554978]="1" [1902117126]="2" [1931481131]="1" [2046269198]="1" [2348972751]="1"
[2377892602]="1" [2405574348]="1" [2480340688]="1" [2562898927]="2" [2570829524]="1"
[2654715603]="1" [2822487781]="1" [2927548899]="1" [3091645903]="1" [3654723758]="1"
[3817671828]="1" [3822495892]="1" [4283621042]="1")

Więc możesz:

for i in ${!b[@]};do
    [ ${c[$i]} -eq 1 ] &&
        printf "Present only in B: vol-%8x\n" $i
  done

To spowoduje:

Present only in B: vol-27991850
Present only in B: vol-2a19386a
Present only in B: vol-615e1222
Present only in B: vol-7320102b
Present only in B: vol-8f6226cc
Present only in B: vol-b846c5cf
Present only in B: vol-e38d0c94

Ale to jest posortowane numerycznie! Jeśli chcesz oryginalne zamówienie, możesz:

for i in ${B[@]#vol-};do
    [ ${c[((16#$i))]} -eq 1 ] && printf "Present in B only: vol-%s\n" $i
  done

Więc wyświetlasz vols w tej samej kolejności, w jakiej zostały przesłane:

Present in B only: vol-e38d0c94
Present in B only: vol-2a19386a
Present in B only: vol-b846c5cf
Present in B only: vol-7320102b
Present in B only: vol-8f6226cc
Present in B only: vol-27991850
Present in B only: vol-615e1222

lub

for i in ${!a[@]};do
    [ ${c[$i]} -eq 1 ] && printf "Present only in A: vol-%8x\n" $i
  done

za pokazywanie tylko w A :

Present only in A: vol-382c477b
Present only in A: vol-5540e618
Present only in A: vol-79f7970e
Present only in A: vol-8c027acf
Present only in A: vol-8dbbc2fa
Present only in A: vol-93d6fed0
Present only in A: vol-993bbed4
Present only in A: vol-9e3bbed3
Present only in A: vol-a83bbee5
Present only in A: vol-ae7ed9e3
Present only in A: vol-d9d6a8ae
Present only in A: vol-e3d6a894
Present only in A: vol-ff52deb2

lub nawet:

for i in ${!b[@]};do
    [ ${c[$i]} -eq 2 ] && printf "Present in both A and B: vol-%8x\n" $i
  done

będzie ponownie wydrukować :

Present in both A and B: vol-175a3b54
Present in both A and B: vol-71600106
Present in both A and B: vol-98c2bbef
F. Hauri
źródło
Oczywiście, jeśli Duplicatelinie są bezużyteczne, można je po prostu upuścić.
F. Hauri,