_{Questa sfida è sollevare gli spiriti del nostro mod Alex A. , che di solito ha torto .}

Supponiamo di avere un amico di nome Alex che ha bisogno di aiuto con la logica e la matematica di base, in particolare l'equivalenza matematica .

Ti dà un elenco di equazioni del modulo in [variable] = [variable]cui a [variable]è sempre una singola lettera maiuscola dalla A alla Z (non una lettera minuscola, non un numero, né altro). C'è una equazione per riga nell'elenco tranne per una singola riga che dice solo therefore.

Tutte le equazioni sopra thereforesono premesse , fatti che si presume siano veri. Tutte le equazioni sottostanti thereforesono proposizioni non verificate, fatti che Alex sta tentando di dedurre dalle premesse e che possono o meno essere vere.

Ad esempio, in questo elenco di equazioni la proposizione conclusiva A = Csembra essere vera:

A = B
B = C
therefore
A = C

È tuo compito dire ad Alex se tutte le sue proposizioni seguono logicamente dalle premesse fornite. Cioè, devi dire ad Alex se ha torto o ragione nelle sue conclusioni.

Scrivi un programma / funzione che accetta una stringa di un elenco di equazioni come descritto e stampa / ritorna

Alex is right

se tutte le conclusioni seguono logicamente dalle premesse, e in caso contrario output

Alex is wrong

se una conclusione non segue logicamente dai locali.

Vince il codice più breve in byte.

Assicurati di fare attenzione a questi casi:

• La variabile è sempre uguale a se stessa. per esempio

  B = A
  therefore
  A = A
  X = X
  

  risultati in Alex is right.

• Le variabili con relazioni sconosciute non possono essere considerate uguali. per esempio

  P = Q
  therefore
  E = R
  

  risultati in Alex is wrong.

• Quando non ci sono equazioni dopo, thereforele conclusioni sono vagamente vere . per esempio

  D = C
  therefore

  e

  therefore

  entrambi risultano in Alex is right.

• Quando non ci sono equazioni prima thereforedell'unica eguaglianza di se stessi può essere dedotta. per esempio

  therefore
  R = R
  

  risulta Alex is right, ma

  therefore
  R = W
  

  risultati in Alex is wrong.

Altri esempi

Alex ha sbagliato i casi: (separati da righe vuote)

A = B
C = D
therefore
A = C

A = L
E = X
A = I
S = W
R = O
N = G
therefore
G = N
L = I
R = O
S = A
X = X
X = E

D = K
D = Q
L = P
O = L
M = O
therefore
K = L

A = B
therefore
B = C

Z = A
S = S
therefore
A = Z
A = A
S = A
A = S
Z = A
Z = A

K = L
K = X
therefore
X = P
L = X
L = P

therefore
A = B
B = C
A = C

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
T = I
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = O
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
A = Z

therefore
C = D
T = Y
A = Z

P = Q
therefore
E = R

therefore
R = W

Alex ha ragione:

H = J
therefore
J = H

K = L
K = X
therefore
L = X

C = B
B = A
therefore
A = B

K = L
K = X
K = P
therefore
L = X
L = P
X = P

A = Y
Y = Q
Q = O
therefore
O = Y
O = A

C = C
therefore
C = C

A = B
B = A
therefore
A = B
B = A

A = B
B = C
C = D
therefore
A = A
A = B
A = C
A = D
B = A
B = B
B = C
B = D
C = A
C = B
C = C
C = D
D = A
D = B
D = C
D = D

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

D = I
F = H
J = M
therefore
M = J
D = I
H = F

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = Q
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
Z = A
F = R
G = I
W = L

A = B
B = C
therefore
A = C

B = A
therefore
A = A
X = X

P = P
C = G
M = C
therefore

D = C
therefore

therefore

therefore
R = R

CJam, 49

"Alex is "qN%S{f{)er}(_el-}h;{)#},"wrong""right"?

Ispirato alla soluzione Ruby dell'istocrate. Provalo online
3 byte cancellati grazie a jimmy23013 :)

Spiegazione:

Per ogni premessa, il programma sostituisce la prima variabile con la seconda variabile nel resto del testo. Quindi controlla se ci sono conclusioni con variabili diverse.

"Alex is "    first push the part we know
qN%           read the input and split into lines
S             push a space (initial no-op replacement string, see below)
{…}h          do-while
  f{…}        for each line and the replacement string
    )         take out the last character
    er        replace the remaining character(s) with that character
  (           afterwards, take out the first line
  _el         duplicate and convert to lowercase
  -           remove all the resulting characters from the line
               this removes all lowercase letters and non-letters
               "X = Y" becomes "XY" (new replacement string)
               and "therefore" becomes "" (ending the loop)
              this is the loop condition and is left on the stack every time
;             after the loop, pop the empty string (from "therefore")
{…},          filter the remaining (conclusion) lines using the condition block
  )           take out the last character
  #           find its index in the remaining string
               this is 0 (false) iff the first character is the same as the last
              afterwards, we have an array of lines with non-equal variables
"wrong"       push "wrong"
"right"       push "right"
?             choose "wrong" if the array was not empty, else choose "right"

Vecchia versione, 85

"Alex is "26,:A;{:i{{_A=_@-}g}%$~}:F;0q"= "-'t/Nf%~\{A\Ft:A;}/1>{F=}%-"right""wrong"?

Questo utilizza un algoritmo di ricerca unione. Provalo online

Rubino, 80 76 + 2 = 78

Con i flag della riga di comando p0, eseguire

gsub$1,$2%p=$`[/e/]while~/(.) = (?!\1)(.)/
$_="Alex is #{p ?:wrong: :right}"

Spiegazione:

Questo utilizza la pura manipolazione delle stringhe. p0legge l'input completo come singola stringa nella variabile $_. Quindi, abbiniamo ripetutamente quella stringa con l'espressione regolare /(.) = (?!\1)(.)/, che trova tutte le stringhe del modulo "X = Y" dove X e Y non sono la stessa lettera e assegna X a $ 1 e Y a $ 2. Quando viene trovata una tale corrispondenza, gsub$1,$2sostituisce tutte le istanze di X con Y nella stringa. Controlliamo anche se questa corrispondenza si è verificata prima o dopo il "quindi" con

$`[/e/]

Se si è verificato dopo, è un reclamo ingiustificato e Alex ha torto. Monitoriamo se tali eventi si sono verificati utilizzando p=. L'uso di pcome variabile di tracciamento impedisce che le cose si rompano se il ciclo non colpisce mai nemmeno una volta, poiché prestituirà zero se non è mai stato assegnato.

A partire da questo post, la soluzione CJam è più lunga. Un momento orgoglioso, anche se senza dubbio fugace.

Modifica: Sì, rapidamente detronizzato. Inoltre, per finire la spiegazione, con il pflag il valore finale di $_viene emesso alla fine dell'esecuzione, quindi l'ultima riga è l'output.

CJam, 83 75 68 67 64 byte

Grazie a Dennis per aver salvato 1 byte.

"Alex is "q_elN--N/:$La/~{)-},\{__m*{:&},::^|}5*-"wrong""right"?

Suite di test. I casi di test sono troppo lunghi per un permalink, quindi copiali semplicemente dalla domanda. Nota che questo è abbastanza lento - ci vogliono un minuto o due nell'interprete online. Si può rendere molto più veloce, cambiando 5*a 2*, nel qual caso si concluderà quasi istantaneamente e risolvere tutti i casi tranne uno di prova.

Spiegazione

(Leggermente obsoleto.)

L'idea è di fare una sorta di "riempimento" di possibili uguaglianze e quindi rimuovere tutte le uguaglianze che abbiamo ottenuto dall'elenco delle conclusioni. Si può dimostrare che non abbiamo bisogno di più di 5 passaggi per il riempimento delle alluvioni, perché coprirebbero una distanza (nel grafico iniziale delle disuguaglianze) di ma la distanza massima è 25.25 = 32

"Alex is " e# Push the string.
q          e# Read the input.
_elN-      e# Make a copy, convert to lower case, remove linefeeds. This gives us a string
           e# with all the characters we don't want from the input.
-          e# Remove them from the input. This leaves two upper-case letters on each line
           e# and an empty line between premises and conclusions.
N/         e# Split into lines.
La/        e# Split around the empty line.
~          e# Dump both halves on the stack.
{)-},      e# Remove any "A = A"-type equalities from the conclusions.
\          e# Swap with the premises.
{          e# Extend the premises 5 times...
  _Wf%     e#   Duplicate the premises and reverse each one, because = is symmetric.
  |        e#   Set union with the original premises.
  __m*     e#   Make two copies and get an array of every possible pair of premises.
  {:&},    e#   Select those which have at least one character in common.
  ::^      e#   For each such pair, take the mutual set difference, i.e. those characters
           e#   that are in only one of the strings.
  |        e#   Set union with the original premises.
}5*
-          e# Remove all the equalities we've obtained from the conclusions. If all
           e# conclusions were valid, the result will now be a empty array, which is falsy.
!          e# Logical not.
"wrong""right"?
           e# Select "wrong" or "right", respectively.

R, 183 192 byte

Ho modificato la mia risposta per risolvere una limitazione evidenziata da user2357112. Esiste ancora una probabilità estremamente ridotta di chiamare Alex quando in effetti ha ragione (cosa che non sembra accadere molto spesso se capisco il contesto della sfida :-). Spero non gli dispiaccia.

i=grep("t",z<-scan(,"",,,"\n"))
cat("Alex is",if(eval(parse(t=c(paste(LETTERS,"=",1:26),sample(rep(head(z,i-1),1e3)),paste(c(TRUE,sub("=","==",tail(z,-i))),collapse="&")))))"right"else"wrong")

Devo decifrare un po 'questo:

lines = scan(, what = "", sep = "\n")
therefore_idx = grep("therefore", lines)
setup = paste(LETTERS, "=", 1:26)
premises = sample(rep(head(lines, therefore_idx - 1), 1000))
propositions = paste(c(TRUE, sub("=", "==", tail(lines, -therefore_idx))), collapse = "&")
things_to_evaluate = c(setup, premises, propositions)
boolean_result = eval(parse(text = things_to_evaluate))
cat("Alex is", if (boolean_result) "right" else "wrong")

Ad esempio, se l'ingresso è

A = B
B = C
therefore
A = C
B = C

per prima cosa valuterà setup:

A = 1
B = 2
...
Z = 26

poi il premises

A = B
B = C

verrà eseguito 1.000 volte ciascuno in un ordine casuale. Questo per assicurarsi ("quasi sicuro") che tutte le uguaglianze siano propagate. Infine, valuterà propositions:

TRUE & A == B & B == C

Haskell, 208 byte

import Data.Equivalence.Persistent
c l=equate(l!!0)$last l 
r=foldr(c)$emptyEquivalence('A','Z')
l#r=equiv r(l!!0)$last l
f x|(h,_:t)<-span((<'t').head)$lines x="Alex is "++if all(#r h)t then"right"else"wrong"

Sto scaricando il lavoro sul Data.Equivalence.Persistentmodulo, che fornisce funzioni per manipolare le classi di equivalenza. Non resta che analizzare le funzioni di input e di chiamata che a volte hanno nomi troppo lunghi per il golf corretto.

Esempio di utilizzo:

*Main> f "A = B\nB = C\ntherefore\nA = C"
"Alex is right"

*Main> f "A = B\nB = D\ntherefore\nA = C"
"Alex is wrong"

Mathematica, 182

f[s_]:="Alex is "<>If[True===And@@Simplify[#2,#1]&@@(StringSplit[s,"\n"]/.{a___,"therefore",b___}:>StringSplit/@{{a},{b}}/.{x_,_,y_}:>Symbol[x<>"$"]==Symbol[y<>"$"]),"right","wrong"]

Funziona su input stringa, come da sfida.

In[]:= f["A = B
B = C
therefore
A = C"]
Out[]= Alex is right

In[]:= f["D = K
D = Q
L = P
O = L
M = O
therefore
K = L"]
Out[]= Alex is wrong

Retina, 90 byte

Per eseguire, posizionare le seguenti 12 righe di codice in 12 file separati (+11 byte conteggiati per ciascun file oltre il primo). <empty>designa un file vuoto; \ndesigna una nuova riga letterale. In alternativa, mantieni le \ns così come sono, metti tutte le linee in un singolo file e usa l' -sopzione. Assicurarsi che tutti i file utilizzino letterali letterali, non Windows \r\n, e notare lo spazio alla fine dell'ultima riga.

s+`^(.) = (.)(.*)\1
$1 = $2$3$2
)`^. .+\n
<empty>
^.+|(.) = \1
<empty>
^\n*$
right
^[^r]+
wrong
^
Alex is 

Come funziona

La prima sostituzione corrisponde alla prima premessa nell'input, ogni volta che la lhs della premessa si verifica successivamente nel file. Sostituisce quell'occorrenza successiva con il rhs della premessa. Il +modificatore assicura che la sostituzione venga ripetuta fino a quando non corrisponde più. Pertanto, se la prima premessa è A = B, tutti i successivi As nel file vengono trasmutati in Bs.

La seconda sostituzione rimuove la prima premessa dall'input, poiché ora abbiamo terminato. Quindi il )modificatore ritorna alla prima sostituzione e si ripete fino a quando non ci sono stati cambiamenti in un intero passaggio attraverso il ciclo. Ciò accade quando tutte le premesse sono state sostituite e rimosse e l'input inizia con therefore.

La terza sostituzione corrisponde alla prima riga di input (che è therefore) o qualsiasi altra parte del modulo A = Ae la elimina. Se tutte le proposte sono supportate dalle premesse, tutte corrisponderanno a questo modulo, quindi ciò che rimane dovrebbe consistere esclusivamente di nuove righe. La quarta sostituzione lo trasforma in right. Altrimenti, la quinta sostituzione cambia tutto ciò che rimane (che non contiene da rquando è thereforestato eliminato) in wrong. Infine, l'ultima sostituzione si aggiunge Alex is all'inizio.

Python 2, 264 byte

C'è già una straordinaria risposta in Python 3 di mbomb007 . Questa risposta ruba in modo flagrante da quella (in particolare il trucco "Alex is wrriognhgt").

E questa risposta è anche significativamente più lunga di quella ...

Bene, comunque, l'idea in questa risposta è quella di mantenere un dizionario di coppie chiave-valore, in cui le chiavi sono i 26 caratteri maiuscoli e il valore corrispondente di ciascuna chiave è l'insieme di lettere equivalenti alla chiave. (Se tutte le 26 lettere fossero equivalenti, ogni chiave avrebbe un set di 26 lettere per il suo valore corrispondente.)

def a(s):
 d={C:set(C)for C in map(chr,range(65,91))};p,c=s.split('t');c,p=[x.split('\n')for x in[c[9:],p]]
 for u in p[:-1]:
    g,h=u[::4];y=d[g]|d[h]
    for v in y:
     for w in y:d[v]|=d[w];d[w]|=d[v]
 print'Alex is','wrriognhgt'[all(u[0]in d[u[4]]for u in c if u)::2]

(Per salvare byte, questa risposta mescola spazi e tab , che è legale in Python 2.)

Questo codice è davvero piuttosto efficiente, perché il dizionario è limitato a una dimensione massima possibile (26 per 26 come descritto sopra) che non dipende dal numero di righe di input.

Ora, mentre giocavo a golf con questa soluzione, mi sono reso conto che avrei potuto salvare quattro byte usando stringhe anziché set per i valori del dizionario, sostituendo

d={C:set(C)for C in map(

con

d={C:C for C in map(

Ovviamente allora devi anche sostituire (NOTA: NON FARE QUESTO) le tre istanze dell'operazione di unione impostata |con la concatenazione di stringhe +, ma ciò non modifica la lunghezza del codice. Il risultato è che tutto dovrebbe funzionare allo stesso modo, tranne per il fatto che non eliminerà i duplicati come fai con i set (continuerà ad aggiungersi alla fine della stringa). Sembra OK - un po 'meno efficiente, certo, ma 260 byte invece di 264.

Bene, si scopre che la versione a 260 byte è così inefficiente da causare un MemoryErrorquando l'ho provata

A = B
A = B
therefore
B = A

Questo è stato sorprendente per me. Analizziamo la versione di "concatenazione di stringhe" a 260 byte!

Naturalmente inizierebbe con le coppie chiave-valore A:Ae B:B(più altre 24 che non contano). Scriveremo d[A]per indicare il valore del dizionario corrispondente alla chiave A, quindi all'inizio avremmo d[A] = A. Ora, data la premessa A = B, inizierebbe concatenando i valori d[A]=Ae d[B]=Bottenendo y = AB. Quindi passerebbe sopra questa stringa due volte: for v in AB: for w in AB:...

Quindi, la prima volta attraverso il ciclo, abbiamo v=Ae w=A. Applicazione d[v] += d[w]e d[w] += d[v]risultati nella seguente sequenza di dizionari:

{A:A, B:B}      (start)
{A:AA, B:B}     (d[A] += d[A])
{A:AAAA, B:B}     (d[A] += d[A])

Quindi, con v=Ae w=B:

{A:AAAA, B:B}     (start)
{A:AAAAB, B:B}    (d[A] += d[B])
{A:AAAAB, B:BAAAAB}   (d[B] += d[A])

Quindi v=B, w=A:

{A:AAAAB, B:BAAAAB}   (start)
{A:AAAAB, B:BAAAABAAAAB}     (d[B] += d[A])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (d[A] += d[B])

E v=B, w=B:

{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (start)
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])

La sequenza di passaggi sopra implementerebbe la premessa singola A = B, con la conclusione che Aè uguale a ogni lettera nella stringa AAAABBAAAABAAAAB, mentre Bè uguale a ogni lettera in BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Supponiamo ora che la prossima premessa sia di A = B nuovo . Per prima cosa calcoli y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Successivamente, passa due volte sopra questa stringa: for v in y: for w in y:...

Si. Forse non sarebbe un'implementazione molto efficiente.

ES6, 128 byte

Liberamente basato sulla versione Ruby.

r=s=>(m=/^[^e]*(.) = (?!\1)(.)/.exec(s))?r(s.replace(RegExp(m[1],'g'),m[2])):'Alex is '+(/(.) = (?!\1)/.test(s)?'wrong':'right')

Cerca qualsiasi non-eguaglianza prima del "quindi" e sostituisce in modo ricorsivo la variabile in ogni momento della stringa (questo salva byte su un ciclo while).

C, 240 byte

#define V[v-65]
v[26];char*r[]={"wrong","right"};i=65;j;g(a){return a V^a?g(a V):a;}main(){char b[16];for(;i<91;++i)i V=i;while(gets(b)&&*b<99)b[0]V=b[4]V=b[0]V<b[4]V?b[0]V:b[4]V;while(gets(b))j|=g(*b)^g(b[4]);printf("Alex is %s\n",r[!j]);}

Funziona combinando i valori in alberi impostati, quindi qualsiasi valore equivalente porta alla stessa radice set. Ungolfed, con tipi impliciti resi espliciti.

// Anything before `V` becomes an index into `v`, offset by -'A'.
#define V [v-65]
int v[26];
char* r[] = {"wrong", "right"};
int i=65;
int j;
// Finds a set identifier for a by recursing until some index points to itself.
int g(int a) {
    return a V ^ a
           ? g(a V)
           : a;
}
int main() {
    char b[16];
    // Initialize all entries to point to themselves.
    for(; i < 91; ++i)
        i V = i;
    // For each premise "A = B", set the entries for A and B to point to the
    // smaller of their current values. This exits after reading "therefore"
    // as 't' > 99.
    while (gets(b) && *b < 99)
        b[0]V = b[4]V = b[0]V < b[4]V
                        ? b[0]V
                        : b[4]V;
    // For each conclusion "A = B", OR j with non-zero if the set identifiers
    // for A and B are different.
    while (gets(b))
        j |= g(*b) ^ g(b[4]);
    printf("Alex is %s\n", r[!j]);
}

180 byte

Questa versione più breve funziona per tutti i casi dall'OP, ma per alcuni altri input afferma erroneamente che Alex ha torto. Utilizza un approccio simile, ma per ogni premessa imposta semplicemente la seconda voce sul valore corrente della prima voce. Nel confronto, esamina solo i valori esatti invece di cercare un albero.

v[26];*V=v-65;char*r[]={"wrong","right"};i;j;main(){char b[16];for(;i<26;++i)v[i]=i;while(gets(b)&&*b<99)V[b[4]]=V[*b];while(gets(b))j|=V[*b]^V[b[4]];printf("Alex is %s\n",r[!j]);}

Un input di esempio per il quale ciò non riesce:

A = B
C = B
quindi
A = C

05AB1E , 32 byte

…±º€ˆ „–у©#|€á[ćD.l#`:}\€ËPè«.ª

Ispirato da @aditsu risposta CJam s' .

Provalo online o verifica tutti i casi di test .

Spiegazione:

…±º€ˆ      # Push dictionary string "alex is "
„–у©      # Push dictionary string "wrong right"
     #     # Split by spaces: ["wrong","right"]
|          # Push all input-lines as list
 ۈ        # Only leave the letters of each line
   [       # Start an infinite loop:
    ć      #  Extract the head of the list; pop and push remainder-list and head separately
     D     #  Duplicate the head
      .l   #  If it's a lowercase string:
        #  #   Stop the infinite loop
    `      #  Push both letters in the string to the stack
     :     #  Replace all these letters in the remainder-list
 }\        # After the infinite loop: discard the duplicated "therefore"
   €       # For each letter-pair in the remainder list of condition-lines:
    Ë      #  Check if both letters are equal (1 if truhy; 0 if falsey)
   P       # Check if everything was truthy by taking the product
    è      # Use this to index into the earlier ["wrong","right"]-list
     «     # Append it to the "alex is " string
      .ª   # Sentence capitalize it
           # (after which the result is output implicitly)

Vedi questo mio suggerimento 05AB1E (sezione Come usare il dizionario? ) Per capire perché …±º€ˆè "alex is "ed „–у©è "wrong right".

bash + awk + SWI-Prolog , 167 byte

head -n1 <(awk '/therefore/{s=1;next};{if(s)print"?=("$1","$3")";else print};END{print"write(\"Alex is right\");write(\"Alex is wrong\"). halt."}' -|paste -sd ,|swipl)

Provalo online!

Inizialmente, questa sarebbe stata solo una risposta di Prolog, ma gli strumenti che ho potuto trovare per trasformare effettivamente il formato di input in qualcosa di utilizzabile erano abbastanza limitati che ho deciso di fare quella parte in bash, anche se non avevo quasi nessuna esperienza facendo qualsiasi cosa in bash, e non avevo mai nemmeno toccato awk. Ho finito per passare abbastanza ore su di esso per voler pubblicarlo anche dopo che è cresciuto in questo 167 byte, a mala pena golf su tutti i mostri.

In sostanza, ciò che fa il programma awk è prendere l'input da stdin, cancellare la linea con therefore, sostituire ogni A = Bdopo con ?=(A,B)e aggiungere write(\"Alex is right\");write(\"Alex is wrong\"). halt.. Quindi, paste -sd ,sostituisce ogni nuova riga tranne l'ultima con una virgola, trasformandola in due query valide nella shell SWI-Prolog, che vengono quindi eseguite con il risultato stampato troncato a una riga da head -n1, che richiede <(...)invece di una pipe per motivi che vanno oltre la mia comprensione. Tutto questo, solo per usare un builtin !