Inspirado en esta cadena de comentarios ...

Quiero enklactsalir de este desafío pero no puedo ...

@ETHproductions to enklact (v): para implementar una tabla de búsqueda utilizando una subsección que consta de elementos únicos.

Enklacting es una forma muy útil de comprimir una tabla de búsqueda. Por ejemplo, supongamos que tenía la siguiente lista de colores:

red
green
blue
yellow
purple
orange

Si desea poder tomar un color como entrada y devolver su índice en esta lista, obviamente hay una forma sencilla:

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

Pero hay una forma en que podríamos hacer esto de una manera menos bytes:

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

Esto funciona porque el primer (o 0º) índice de cada cadena es único. Este ejemplo es obvio, pero a veces es un poco más difícil. ¿Qué pasaría si quisiéramos hacer una tabla de búsqueda para esta lista?

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

En este caso, no podemos hacer esto:

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

porque hay dos entradas diferentes que comienzan con a 'T', a saber, "Atún" y "Turquía". Debemos mirar un índice diferente. Si observa el cuarto índice de cada cadena, notará que todas son únicas. Entonces podemos hacer esto ...

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

En este caso, la "cadena de enklaction" es "enklact".

Eso nos lleva al desafío de hoy ...

Dada una lista de cadenas, devuelve cualquier cadena de enklaction válida. O, en otras palabras, dada una lista de cadenas, devuelve cualquier cadena nueva donde cada letra sea única, y la cadena se forma uniendo la iésima letra de cada cadena.

Si no hay una cadena de enklaction válida, su envío debe devolver una cadena vacía o un valor falso falso en su lugar. Como de costumbre, se permiten funciones o programas completos, y los formatos de entrada / salida son permisivos (dentro de lo razonable).

Cada cadena solo contendrá ASCII imprimible, y este desafío distingue entre mayúsculas y minúsculas.

Este es el código de golf , ¡así que trate de escribir el programa más corto posible en el idioma que elija!

Casos de prueba

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 bytes

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

Devuelve una cadena con el enklact, Ninguno de lo contrario

Python 2 , 68 67 61 bytes

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

Pruébalo en línea!

Mejoras

• De 68 bytes a 67 bytes por Jo King
• De 66 a 65 bytes por Lynn

Si la salida no tuviera que ser una cadena:

Python 3 , 49 bytes

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

Pruébalo en línea!

Retina , 43 32 bytes

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

|""Lm`^.

Pruébalo en línea! Editar: Guardado 11 bytes gracias a @MartinEnder. Explicación:

+

Repita mientras la entrada cambia ...

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

... solo si una línea está vacía o dos líneas comienzan con el mismo carácter ...

m`^.

... borra el primer caracter de cada línea. Por lo tanto, la repetición se detiene si a) todas las líneas comienzan con caracteres diferentes, en cuyo caso la condición falla y la entrada no cambia, o b) al menos una línea se vacía, en cuyo caso todos los caracteres eventualmente se eliminan, en ese punto la entrada deja de cambiar.

|""L`^.

Recoge el primer personaje de cada línea. (Si no hubo solución, el bucle anterior habrá eliminado todo y no habrá nada que recopilar).

Haskell , 71 bytes

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

Pruébalo en línea!

BMO ha guardado 3 bytes con any null x→ elem""x.

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

Explicación

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.

Si arrojar un error ( Prelude.head: empty list) cuando no hay solución está bien, |elem""x=""se puede borrar por 61 bytes .

Ruby , 38 bytes.

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

Pruébalo en línea!

Gracias a GB por señalar un error.

Pyth , 6 bytes

>1{I#C

Banco de pruebas.

El resultado es una lista singleton, según lo permitido por defecto ; la lista [] (lista vacía, falsedad) se devuelve en caso de que la cadena no se pueda enclactificar .

Explicación

> 1 {I # C - Programa completo.
     C - Transponer la entrada, recortando ausencias.
    # - Filtrado por:
  {I - Invariante bajo deduplicación.
> 1 - Corte a 1. lista [: 1] en Python.

Pyth , 5 bytes

Esto habría sido válido si el bloqueo hubiera contado como un valor falso.

h{I#C

Banco de pruebas.

Haskell , 76 74 bytes

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

Pruébalo en línea! Devuelve la última cadena de búsqueda válida o una cadena vacía si no existe dicha cadena.

71 69 bytes

Si arrojar una excepción consistente como valor falso está permitido:

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

Pruébalo en línea! Lanza una empty listexcepción si no se encuentra una cadena, de lo contrario devuelve la primera cadena válida.

-2 bytes gracias a Ørjan Johansen

Jalea , 7 bytes

z0Q€fZḢ

Devuelve el entero 0 si las cadenas no se pueden enklactificar.

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Stax , 9 8 bytes

åτIⁿs↓µg

Ejecutar y depurarlo

Explicación (sin embalaje):

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 bytes

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

Pruébalo en línea!

sapplynormalmente devuelve a matrixcuando todos length(FUN(X[[i]]))son iguales, excepto cuando length(FUN(X[[i]]))==1, en cuyo caso devuelve a vector. Para utilizar las operaciones matriciales, entonces, tenemos que ir substringmás allá de lo que necesitamos para garantizar a matrix, razón por la cual se xextiende a max(nchar(S)+1).

Luego filtramos las filas que no tienen duplicados ni cadenas vacías. Como solo podemos devolver una sola cadena, tomamos la primera, excepto que cuando no hay filas que cumplan con los criterios, arrojaríamos un error, por lo que agregamos una fila adicional ""al final.

Luego imprimimos la enklactcadena ified o la cadena vacía.

R , 116 107 95 bytes

R + pryr

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

Pruébalo en línea!

base R

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

Pruébalo en línea!

Estas dos variantes ahorran 9 bytes gracias a Giuseppe .

Explicación:

Esto efectivamente trunca todas las picaduras en el vector va la longitud del más corto e itera a través de los índices posteriores. Luego verifica si hay duplicados dentro de las letras elegidas y si no, las pega e imprime con cat. Si todos los índices devuelven resultados duplicados, esto imprime una cadena vacía.
Todos se envuelven en una pryrfunción anónima breakpara detener el ciclo, o la función base R pone a cero el vector para romper el ciclo.

Japt, 9 bytes

Toma la entrada como una matriz de matrices de caracteres, devuelve una matriz de caracteres o undefined

y æ_f eZâ

Pruébelo (agregue una nueva línea al comienzo del programa con el código qR mqpara tomar la entrada como una cadena separada de nueva línea, para ahorrarle la molestia de crear las matrices).

Explicación

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 bytes

øʒDÙQ}н

Pruébalo en línea!

Explicación

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

Python 3 , 75 bytes

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

Opera en listas de caracteres en lugar de cadenas. Devuelve False si no existe una cadena de enklaction válida.

Pruébalo en línea!

C (gcc) , 161 bytes

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]);}

Pruébalo en línea!

Se prueba la duplicación de cada posición de personaje y se omite si se detecta un duplicado; esto continúa hasta que finalice la cadena más corta. Solo es ASCII, lamentablemente: ¡las cadenas DBCS / UTF-8 rompen esta función mal!

Japt , 12 bytes

Devoluciones undefinedpara cadenas no enklactic.

y ·æ_¬n ä¦ e

Pruébalo en línea!

Explicación:

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 bytes

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

Pruébalo en línea!

Toma una lista de la lista de caracteres como entrada, devuelve una lista de caracteres. Contiene U + F3C7, correspondiente al operador "Transposición".

Devuelve #1y arroja un montón de errores ignorables cuando no hay una cadena adecuada.

Explicación:

PadRight@#

Rellene la entrada para que cada "cadena" (lista de caracteres) tenga la misma longitud. Esto agrega enteros 0s (no cadenas "0"). Luego transponer.

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

Seleccione las cadenas que no tienen enteros 0y tienen todos los caracteres únicos.

#&@@

Consigue el primero.

JavaScript (ES6), 66 bytes

Devuelve una cadena o undefinedsi no existe una solución.

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

Pruébalo en línea!

Comentado

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

Carbón , 23 21 bytes

-2 bytes gracias a @Neil !

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

Pruébalo en línea!

Casco , 9 bytes

ḟS=UḞz:∞ø

Pruébalo en línea!

Explicación

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 bytes

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

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

Pruébalo en línea!

-25 bytes gracias a @Neil

Transponer texto rectangular en Retina es sorprendentemente difícil.

Perl 6 , 27 bytes

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

Pruébalo en línea!

Después de ver que la versión ruby ​​ha sido votada, he copiado el enfoque y he usado listas de caracteres, en lugar de cadenas. No me gusta

Mi envío más antiguo y más correcto es el siguiente:

Perl 6 , 38 bytes

Dividir, comprimir, verificar la unicidad, unirse.

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

Pruébalo en línea!

C (gcc) , 121 113 110 bytes

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);}

Pruébalo en línea!

Sin golf

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 gracias a ceilingcat

Esto abusa de la capacidad de agregar 1 a un puntero de cadena en C para obtener la 'cola' de la cadena. Los principales ahorradores de bytes son:

• d+=x[y[i++]=*(*_)++]++que agrega el primer carácter de la primera cadena de _a y, avanza la primera cadena de _para eliminar su primer carácter, agrega la xentrada en ese carácter de incrementa dicha xentrada
• q=d?*x:puts(y)que imprime ysi dno es cero mientras se establece qen un valor distinto de cero, o se establece qen no cero si el primer elemento de xno es cero (si estuviéramos al final de una de las cadenas, entonces dicho elemento sería no cero)

Editar: bytes afeitados cambiando del ciclo while a la llamada de cola recursiva y eliminando los corchetes del ciclo for.

Pyth, 13 bytes

e+kf{IT@.TQ.t

Pruébalo aquí

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.

Rojo , 139 bytes

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]]]

Pruébalo en línea!

Explicación:

Toma la entrada como un bloque (lista) de cadenas. Devuelve la cadena de enklaction o de noneotro modo.

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 bytes

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

Pruébalo en línea!

-1 byte gracias a Cows quack

Explicación:

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 trypalabra clave se usa para descartar los errores que ocurren si ies mayor que la longitud de la cadena más pequeña ao si no hay respuesta y headcausa un error.

Java 10, 106 bytes

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

Dará un error en lugar de devolver una cadena vacía si no se puede encontrar una solución. La entrada es una matriz de caracteres.

Pruébalo en línea.

Explicación:

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 bytes

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

Devuelve una lista de listas de caracteres.

APL + WIN, 35 33 bytes

2 bytes guardados gracias a Adám

Solicita las líneas de texto como una matriz de caracteres:

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

Pruébalo en línea! Cortesía de Dyalog Classic.

Explicación:

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