Ispirato da questa catena di commenti ...

Voglio enklactuscire da questa sfida ma non posso ...

@ETHproductions to enklact (v): per implementare una tabella di ricerca usando una sottosezione composta da elementi unici.

Enklacting è un modo molto utile per comprimere una tabella di ricerca. Ad esempio, supponiamo che tu abbia il seguente elenco di colori:

red
green
blue
yellow
purple
orange

Se vuoi essere in grado di prendere un colore come input e restituire il suo indice in questo elenco, c'è ovviamente il modo più semplice:

["red", "green", "blue", "yellow", "purple", "orange"].index(input())

Ma c'è un modo per farlo in meno byte:

"rgbypo".index(input()[0])

Questo funziona perché il primo (o 0 °) indice di ogni stringa è univoco. Questo esempio è ovvio, ma a volte è un po 'più difficile. E se volessimo creare una tabella di ricerca per questo elenco?

Sweet Onion Chicken Teriyaki
Oven Roasted Chicken
Turkey Breast
Italian BMT
Tuna
Black Forest Ham
Meatball Marinara

In questo caso, non possiamo farlo:

"SOTITBM".index(input()[0])

perché ci sono due input diversi che iniziano con a 'T', vale a dire "Tonno" e "Turchia". Dobbiamo guardare un indice diverso. Se guardi il quarto indice di ogni stringa, noterai che sono tutti unici. Quindi possiamo farlo ...

"enklact".index(input()[3])

In questo caso, la "stringa enklaction" è "enklact".

Questo ci porta alla sfida di oggi ...

Dato un elenco di stringhe, restituisce qualsiasi stringa di enklaction valida. O in altre parole, dato un elenco di stringhe, restituisce qualsiasi nuova stringa in cui ogni lettera è unica e la stringa viene formata unendo la lettera i di ogni stringa.

Se non esiste una stringa enklaction valida, l'invio deve invece restituire una stringa vuota o un valore di falsy coerente. Come al solito, sono consentite funzioni o programmi completi e i formati di input / output sono permissivi (entro limiti ragionevoli).

Ogni stringa conterrà solo ASCII stampabile e questa sfida fa distinzione tra maiuscole e minuscole.

Questo è code-golf , quindi prova a scrivere il programma più breve possibile nella tua lingua preferita!

Casi test

Input:
Programming
Puzzles
Code
Golf

Output (any one of these):
"ozdl"
"gzef"


Input:
the quick
brown fox
jumped over
lazy dogs

Output:
"tbjl"
"hrua"
"eomz"
" wpy"
"qne "
"if o"
"kxvs"

Note that "u dd" and "coog" are not valid.


Input:
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

Output:
""


Input:
AbC
aBc
bbC

Output:
"Aab"


Input:
@#$%^_
Hello_World
How are you?

Output:
"#eo"
"$lw"
"%l "
"^oa"


Input:
a
ab
ac

Output:
""

Python3, 59 byte

lambda l:{len({*d}):''.join(d)for d in zip(*l)}.get(len(l))

Restituisce una stringa con enklact, None altrimenti

Python 2 , 68 67 61 byte

lambda a:`{0:j for j in zip(*a)if len(set(j))==len(j)}`[6::5]

Provalo online!

miglioramenti

• Da 68 byte a 67 byte di Jo King
• Da 66 a 65 byte di Lynn

Se l'output non dovesse essere una stringa:

Python 3 , 49 byte

lambda a:[j for j in zip(*a)if len({*j})==len(j)]

Provalo online!

Retina , 43 32 byte

+/^(.).+^\1|^$/ms&m`^.

|""Lm`^.

Provalo online! Modifica: salvato 11 byte grazie a @MartinEnder. Spiegazione:

+

Ripeti mentre l'ingresso cambia ...

/^(.).+^\1|^$/ms&

... solo se una riga è vuota o due righe iniziano con lo stesso carattere ...

m`^.

... cancella il primo carattere di ogni riga. La ripetizione si interrompe quindi se a) tutte le righe iniziano con caratteri diversi, nel qual caso la condizione non riesce e l'input non viene modificato, oppure b) almeno una riga diventa vuota, nel qual caso tutti i caratteri alla fine vengono eliminati, a quel punto l'ingresso smette di cambiare.

|""L`^.

Colleziona il primo personaggio di ogni riga. (Se non ci fosse soluzione, il ciclo precedente avrà eliminato tutto e non ci sarà nulla da raccogliere.)

Haskell , 71 byte

f x|elem""x=""|y<-head<$>x,and[filter(==a)y==[a]|a<-y]=y|1<2=f$tail<$>x

Provalo online!

BMO ha salvato 3 byte con any null x→ elem""x.

Ørjan Johansen ha salvato un byte con sum[1|b<-y,a==b]<2→ filter(==a)[y]==[a].

Spiegazione

f x|elem""x=""                      -- Once any of the strings is empty, return "".
   |y<-head<$>x                     -- Otherwise, let y be all the first letters...
   ,and[                 |a<-y]     -- If, for all a in y,
        filter(==a)y==[a]           -- a occurs just once in y:
                               =y   -- return y.
   |1<2=f$tail<$>x                  -- Else, chop off all the first letters and recurse.

Se si genera un errore ( Prelude.head: empty list) quando non c'è soluzione è OK, |elem""x=""può essere cancellato per 61 byte .

Rubino , 38 byte

->x,*y{x.zip(*y).find{|z|z==z-[p]|[]}}

Provalo online!

Grazie a GB per aver segnalato un bug.

Pyth , 6 byte

>1{I#C

Suite di test.

L'output è un elenco singleton, come consentito per impostazione predefinita ; la lista [] (lista vuota, falsa) viene restituita nel caso in cui la stringa non possa essere enklacificata .

Spiegazione

> 1 {I # C - Programma completo.
     C - Trasposizione dell'input, ritaglio assenze.
    # - Filtra per:
  {I - Invariante sotto deduplicazione.
> 1 - Slice to 1. list [: 1] in Python.

Pyth , 5 byte

Ciò sarebbe stato valido se l'arresto anomalo fosse stato considerato un valore errato.

h{I#C

Suite di test.

Haskell , 76 74 byte

f t=last$"":(id=<<foldr(zipWith(#))([[]]<$t)t)
x#[s]=[x:s|all(/=x)s]
x#e=e

Provalo online! Restituisce l'ultima stringa di ricerca valida o una stringa vuota se tale stringa non esiste.

71 69 byte

Se è consentita un'eccezione coerente come valore di falsa:

f t=head$id=<<foldr(zipWith(#))([[]]<$t)t
x#[s]=[x:s|all(/=x)s]
x#e=e

Provalo online! Genera empty listun'eccezione se non viene trovata alcuna stringa, altrimenti restituisce la prima stringa valida.

-2 byte grazie a Ørjan Johansen

Gelatina , 7 byte

z0Q€fZḢ

Restituisce il numero intero 0 se le stringhe non possono essere enklacified.

Provalo online!

Come funziona

z0Q€fZḢ  Main link. Argument: A (string array)

z0       Zip/transpose, filling shorter rows with 0.
  Q€     Unique each deduplicate resulting string.
     Z   Zip/transpose, without using a filler.
    f    Filter; keep only string that appear in the results to both sides.
      Ḣ  Head; extract the first string. Returns 0 if the array is empty.

Perl 5 , 61 byte

map$;[$_].=$F[$_],0..@F;$-++}{($_)=grep$-==y///c*!/(.).*\1/,@

Provalo online!

Stax , 9 8 byte

åτIⁿs↓µg

Esegui ed esegui il debug

Spiegazione (non imballata):

M{c0-u=}j Full program, implicit input
          e.g. ["Programming", "Puzzles", "Code", "Golf"]
M         Transpose
                ["PPCG", "ruoo", "ozdl", "gzef", "rl\0\0", "ae\0\0", "ms\0\0", "m\0\0\0", "i\0\0\0", "n\0\0\0", "g\0\0\0"]
 {     }j Find first matching element:
            e.g. "PPCG"
  c0-       Copy and remove zero bytes (padding)
                 "PPCG" "PPCG"
     u      Unique
                 "PPCG" "PCG"
      =     Check if equal:
                 1
          First matching here: "ozdl". If none is found, the stack is empty
          Implicit output if anything on stack

R , 127 byte

function(S,s=sapply(S,substring,x<-1:max(nchar(S)+1),x))cat(rbind(s[!apply(s,1,anyDuplicated)&!rowSums(s==""),],"")[1,],sep="")

Provalo online!

sapplyin genere restituisce a matrixquando tutti length(FUN(X[[i]]))sono uguali, tranne quando length(FUN(X[[i]]))==1, nel qual caso restituisce a vector. Al fine di utilizzare le operazioni di matrice, quindi, dobbiamo fare substringun ulteriore passo avanti rispetto a quello che dobbiamo garantire a matrix, motivo xper cui si estende a max(nchar(S)+1).

Quindi filtriamo le righe che non hanno duplicati e stringhe vuote. Dato che possiamo restituire solo una singola stringa, prendiamo la prima, tranne per il fatto che quando non ci sono righe che soddisfano i criteri, avremmo generato un errore, quindi aggiungeremo una riga ""in più alla fine.

Quindi stampiamo la enklactstringa ified o la stringa vuota.

R , 116 107 95 byte

R + pryr

pryr::f(for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
break}))

Provalo online!

base R

function(v)for(i in 1:min(nchar(v)))`if`(anyDuplicated(t<-substr(v,i,i)),0,{cat(t,sep="")
v=0})

Provalo online!

Queste due varianti risparmiano 9 byte grazie a Giuseppe .

Spiegazione:

Questo tronca efficacemente tutte le punture del vettore valla lunghezza del più breve e scorre attraverso gli indici successivi. Quindi controlla se ci sono duplicati all'interno delle lettere scelte e, in caso contrario, li incolla e stampa con cat. Se tutti gli indici restituiscono risultati duplicati, viene stampata una stringa vuota.
Tutto avvolto in una pryrfunzione anonima con breakper interrompere il ciclo, o la funzione base R azzera il vettore per interrompere il ciclo.

Japt, 9 byte

Accetta input come una matrice di array di caratteri, restituisce una matrice di caratteri o undefined

y æ_f eZâ

Provalo (Aggiungi una nuova riga all'inizio del programma con il codice qR mqper prendere l'input come una stringa separata newline, per evitare il fastidio di creare le matrici.)

Spiegazione

y             :Transpose
  æ_          :Pass each array Z through a function and return the first that returns true
    f         :  Filter nulls (used for padding when transposing)
      e       :  Test for equality with
       Zâ     :  Z deduplicated

05AB1E , 7 byte

øʒDÙQ}н

Provalo online!

Spiegazione

ø        # Zip the input array
 ʒ   }   # Filter by ...
  DÙQ    # ... an entry is equal to itself deduplicated
      н  # Take the first element

Python 3 , 75 byte

def f(t):c=[s.pop(0)for s in t];return all(t)and(f(t),c)[len(t)==len({*c})]

Funziona su elenchi di caratteri anziché su stringhe. Restituisce False se non esiste una stringa enklaction valida.

Provalo online!

C (gcc) , 161 byte

f(s,i)char**s;{char**t,a[255],*u=a;for(i=0;memset(a,0,255),u&&~i;i+=!!~i&&u)for(t=s;(u=u?*t++:0)&&~(i=u[i]?i:-1)&&!a[u[i]]++;);while(~i&&(u=*s++))putchar(u[i]);}

Provalo online!

Ogni posizione del personaggio viene verificata per la duplicazione e ignorata se viene rilevato un duplicato; questo continua fino alla fine della stringa più corta. È solo ASCII, purtroppo: le stringhe DBCS / UTF-8 interrompono gravemente questa funzione!

Japt , 12 byte

Restituisce undefinedper stringhe non enklactic.

y ·æ_¬n ä¦ e

Provalo online!

Spiegazione:

y ·æ_¬n ä¦ e
y             // Split the input at newlines and transpose
  ·           // Join on newlines 
   æ_         // Return the first item that returns truthy when ran through:
     ¬n       //   Sort
        ä¦    //   Reduce with !=
           e  //   All items are truthy (unique)

Wolfram Language (Mathematica) , 54 byte

#&@@Select[PadRight@#,#~FreeQ~0&&Union@#==Sort@#&]&

Provalo online!

Prende un elenco di un elenco di caratteri come input, restituisce un elenco di caratteri. Contiene U + F3C7, corrispondente all'operatore "Transpose".

Restituisce #1e genera un sacco di errori ignorabili quando non esiste una stringa adatta.

Spiegazione:

PadRight@#

Riempi l'input in modo che ogni "stringa" (elenco di caratteri) abbia la stessa lunghezza. Questo aggiunge numeri interi 0(non stringhe "0"). Quindi trasporre.

Select[ ... ,#~FreeQ~0&&Union@#==Sort@#&]

Seleziona le stringhe che non contengono numeri interi 0e che contengono tutti i caratteri univoci.

#&@@

Prendi il primo.

JavaScript (ES6), 66 byte

Restituisce una stringa o undefinedse non esiste una soluzione.

f=(a,i=0)=>a.every(s=>(o[k+=c=s[i],c]^=1)&&c,o=k=[])?k:c&&f(a,i+1)

Provalo online!

Commentate

f = (           // f = recursive function taking:
  a,            //   a[] = input array
  i = 0         //   i   = pointer
) =>            //
  a.every(s =>  // for each string s in a[]:
    (o[k +=     //   append to the key string k
      c = s[i], //   the character c at position i in s
      c] ^= 1   //   and toggle o[c] (undefined -> 1 -> 0)
    ) && c,     //   additionally, make sure that c is defined
    o = k = []  //   start with o = k = empty array
  ) ?           // every() is true if all characters were distinct and defined:
    k           //   in which case we return k
  :             // else:
    c &&        //   provided that every() didn't fail because of an undefined character,
    f(a, i + 1) //   try again at the next position

Carbone , 23 21 byte

-2 byte grazie a @Neil !

§ΦＥ⌊ＥθＬι⭆θ§λι⬤ι⁼¹№ιλ⁰

Provalo online!

Buccia , 9 byte

ḟS=UḞz:∞ø

Provalo online!

Spiegazione

fS=UḞz:∞ø
    Ḟz:∞ø  Transpose the input dropping characters of longer strings
    Ḟ        Fold right
     z:      Zip with prepend
       ∞ø    Infinite list of empty lists
ḟS=U       Find the first string without duplicates, returns an empty string if none
ḟ            Return first value satisfying predicate
  =          Equal
 S U         to itself with duplicates removed

Retina , 81 56 byte

m`$
$.=*£¢
N$`.
$.%`
¶

~`(.*?¢)+
L`.{$#1}
A`(.).*\1|£|¢

Provalo online!

-25 byte grazie a @Neil

Trasporre testo rettangolare in Retina è sorprendentemente difficile.

Perl 6 , 27 byte

{([Z] $_).first:{.Set==$_}}

Provalo online!

Dopo aver visto che la versione ruby ​​è stata votata per l'upgrade, ho copiato l'approccio e usato elenchi di caratteri, anziché stringhe. Non mi piace

La mia presentazione più vecchia e più corretta è la seguente:

Perl 6 , 38 byte

Dividi, comprimi, controlla l'unicità, unisciti.

{[~] ([Z] @_>>.comb).first:{.Set==$_}}

Provalo online!

C (gcc) , 121 113 110 110 byte

i;d;f(s)char**s;{char**_=s,x[255]={0},y[99]={0};for(d=i=0;*_;)d+=x[y[i++]=*(*_++)++]++;d=d?*x?0:f(s):puts(y);}

Provalo online!

Ungolfed

void enklactify(char *strings[]) {
    int quit = 0;
    while (!quit) {
        char **arg = strings;      // current row
        int exists[255] = {0};     // which characters exist in the column
        char output[99] = {0};     // will hold output string
        int index = 0;             // where to insert in output
        int duplicates = 0;        // have we found any duplicates?
        while (*arg != NULL) {
            char *word = *arg;     // current word
            char first = *word;    // first letter of current word
            if (exists[first])
                duplicates = 1;    // we found a duplicate
            exists[first] = 1;     // mark it as in our string
            output[index] = first; // add it to our output
            index++;
            (*arg)++;              // advances the current word to the next
                                   // character by reference (chops first char)
            arg++;                 // advance to next whole argument
        }

        if (!duplicates) {         // This is a valid solution
            puts(output);
            quit = 1;
        }

        if (exists[0]) {           // We hit the null terminator of one of the
                                   // input strings, so we failed
            quit = 1;
        }
    }
}

-3 grazie a ceilingcat

Questo abusa della possibilità di aggiungere solo 1 a un puntatore di stringa in C per ottenere la "coda" della stringa. I principali risparmiatori di byte sono:

• d+=x[y[i++]=*(*_)++]++che aggiunge il primo carattere della prima stringa di _a y, fa avanzare la prima stringa di _per rimuovere il suo primo carattere, aggiunge la xvoce a quel carattere de incrementa detta xvoce
• q=d?*x:puts(y)che stampa yse dè diverso da zero mentre impostato qsu un valore diverso da zero o impostato qsu diverso da zero se il primo elemento di xè diverso da zero (se fossimo alla fine di una delle stringhe, allora detto elemento sarebbe diverso da zero)

Modifica: byte rasati passando da ciclo continuo a chiamata di coda ricorsiva e rimuovendo parentesi da per ciclo.

Pyth, 13 byte

e+kf{IT@.TQ.t

Provalo qui

e+kf{IT@.TQ.t
           .tQ   Transpose the (implicit) input with padding.
        .TQ      Transpose the input without padding.
       @         Take the strings in both.
   f{IT          Find the ones that have no duplicates.
e+k              Get the last, or an empty string.

Rosso , 139 byte

func[b][m: length? first b foreach a b[m: min m length? a]repeat n m[c: copy[]foreach a b[append c a/(n)]if c = unique c[return rejoin c]]]

Provalo online!

Spiegazione:

Prende l'input come blocco (elenco) di stringhe. Restituisce la stringa enklaction o nonealtro.

f: func[b][
    m: length? first b                   ; the minimal length of the first string  
    foreach a b[m: min m length? a]      ; find the minimal length of all strings
    repeat n m[                          ; limit the search to the minimal length
        c: copy[]                        ; an empty block  
        foreach a b[append c a/(n)]      ; for each string append the current char
        if c = unique c[return rejoin c] ; if all chars are unique, return the block
    ]  
]

Röda , 80 77 byte

f a{a|seq 0,#_|try{{|i|a|[_[i:i+1]]|orderedUniq|concat|[_]if[#_1=#a]}_|head}}

Provalo online!

-1 byte grazie al ciarlatano Cows

Spiegazione:

f a{
  a|         /* Push the strings in a to the stream */
             /* For each string (_): */
  seq 0,#_|     /* Push a range from 0 to the length of _ to the stream */
  try{       /* Ignore errors during the following block */
    {|i|        /* For each i in the stream: */
      a|           /* Push strings in a to the stream */
      [_[i:i+1]]|  /* For each string, push the ith character to the stream */
      orderedUniq| /* Remove duplicate characters */
      concat|      /* Join the characters into a string */
      [_]if        /* Push the string to the stream if */
      [#_1=#a]     /* Its length is the length of a */
    }_|
    head        /* Take the first string in the stream and return it */
  }
}

La tryparola chiave viene utilizzata per eliminare gli errori che si verificano se iè maggiore della lunghezza della stringa più piccola ao se non vi è alcuna risposta e headcausa un errore.

Java 10, 106 byte

a->{for(int i=0;;i++){var r="";for(var s:a)r+=s[i];if(r.length()==r.chars().distinct().count())return r;}}

Fornirà un errore invece di restituire una stringa vuota se non è possibile trovare una soluzione. L'input è una matrice di caratteri.

Provalo online.

Spiegazione:

a->{                  // Method with character-matrix parameter and String return-type
  for(int i=0;;i++){  //  Loop `i` upwards
    var r="";         //   Result-String, starting empty
    for(var s:a)      //   Loop over the character-arrays of the input
      r+=s[i];        //    And append every `i`'th character to `r`
    if(r.length()==r.chars().distinct().count())
                      //   If `r` only contains unique characters
      return r;}}     //    Return `r` as result

Clojure, 59 byte

#(for[s(apply map list %):when(=(count(set s))(count %))]s)

Restituisce un elenco di elenchi di caratteri.

APL + WIN, 35 33 byte

2 byte salvati grazie ad Adám

Richiede le righe di testo come matrice di caratteri:

⊃((↑⍴¨a)=+/¨((a⍳¨a)=⍳¨⍴¨a))/a←,⌿⎕

Provalo online! Per gentile concessione di Dyalog Classic

Spiegazione:

a←,⌿⎕ prompts for input and creates a nested vector of the input matrix columns

((a⍳¨a)=⍳¨⍴¨a) creates a binary vector for each nested element with a 1 for each unique element

((↑⍴¨a)=+/¨ sums each binary vector and compares to number of characters in each element

(...)/a←⊂[1]⎕ selects only those elements where number of uniques = column length

⊃ converts nested vector back to a matrix of each valid enklaction string