Inspiré par cette chaîne de commentaires ...

Je veux enklactsortir de ce défi mais je ne peux pas ...

@ETHproductions to enklact (v): pour implémenter une table de correspondance en utilisant une sous-section composée d'éléments uniques.

Enklacting est un moyen très utile de compresser une table de recherche. Par exemple, supposons que vous ayez la liste de couleurs suivante:

red
green
blue
yellow
purple
orange

Si vous voulez pouvoir prendre une couleur en entrée et retourner son index dans cette liste, il existe évidemment un moyen simple:

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

Mais il y a un moyen de faire cela de manière beaucoup moins d'octets:

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

Cela fonctionne car le premier (ou 0ème) index de chaque chaîne est unique. Cet exemple est évident, mais parfois c'est un peu plus difficile. Et si nous voulions créer une table de consultation pour cette liste?

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

Dans ce cas, nous ne pouvons pas faire ceci:

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

parce qu'il y a deux entrées différentes qui commencent par un 'T', à savoir "Thon" et "Turquie". Nous devons regarder un index différent. Si vous regardez le 4ème index de chaque chaîne, vous remarquerez qu'ils sont tous uniques. Donc on peut faire ça ...

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

Dans ce cas, la "chaîne enklaction" est "enklact".

Cela nous conduit au défi d'aujourd'hui ...

Étant donné une liste de chaînes, renvoyez toute chaîne enklaction valide. Ou, en d'autres termes, étant donné une liste de chaînes, renvoyez toute nouvelle chaîne où chaque lettre est unique et la chaîne est formée en joignant la ième lettre de chaque chaîne.

S'il n'y a pas de chaîne enklaction valide, votre soumission doit renvoyer une chaîne vide ou une valeur de cohérence cohérente. Comme d'habitude, les fonctions ou les programmes complets sont autorisés, et les formats d'entrée / sortie sont permissifs (dans des limites raisonnables).

Chaque chaîne ne contiendra que de l'ASCII imprimable, et ce défi est sensible à la casse.

C'est du code-golf , alors essayez d'écrire le programme le plus court possible dans la langue de votre choix!

Cas de 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 octets

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

Retourne une chaîne avec l'enklact, None sinon

Python 2 , 68 67 61 octets

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

Essayez-le en ligne!

Améliorations

• De 68 à 67 octets par Jo King
• De 66 à 65 octets par Lynn

Si la sortie ne doit pas nécessairement être une chaîne:

Python 3 , 49 octets

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

Essayez-le en ligne!

Retina , 43 32 octets

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

|""Lm`^.

Essayez-le en ligne! Edit: 11 octets enregistrés grâce à @MartinEnder. Explication:

+

Répétez pendant que l'entrée change ...

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

... seulement si une ligne est vide ou deux lignes commencent par le même caractère ...

m`^.

... supprime le premier caractère de chaque ligne. La répétition s’arrête donc si a) toutes les lignes commencent par des caractères différents, auquel cas la condition échoue et que l’entrée ne soit pas modifiée, ou b) au moins une ligne devient vide, auquel cas tous les caractères sont finalement supprimés, à quel point l'entrée cesse de changer.

|""L`^.

Recueillir le premier caractère de chaque ligne. (S'il n'y avait pas de solution, la boucle ci-dessus aura tout supprimé et il n'y aura rien à collecter.)

Haskell , 71 octets

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

Essayez-le en ligne!

BMO a enregistré 3 octets avec any null x→ elem""x.

Ørjan Johansen a sauvegardé un octet avec sum[1|b<-y,a==b]<2→ filter(==a)[y]==[a].

Explication

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 lancer une erreur ( Prelude.head: empty list) alors qu'il n'y a pas de solution est OK, |elem""x=""peut être effacé pour 61 octets .

Ruby , 38 octets

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

Essayez-le en ligne!

Merci à GB d'avoir signalé un bug.

Pyth , 6 octets

>1{I#C

Suite de tests.

La sortie est une liste de singleton, comme autorisé par défaut ; la liste [] (liste vide, falsy) est renvoyée au cas où la chaîne ne pourrait pas être enklactified .

Explication

> 1 {I # C - Programme complet.
     C - Transposer l'entrée, rogner les absences.
    # - Filtrer par:
  {I - Invariant sous déduplication.
> 1 - Tranche vers 1. la liste [: 1] en Python.

Pyth , 5 octets

Cela aurait été valable si le crash avait été compté comme une valeur de fausseté.

h{I#C

Suite de tests.

Haskell , 76 74 octets

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

Essayez-le en ligne! Retourne la dernière chaîne de recherche valide ou une chaîne vide s'il n'en existe aucune.

71 69 octets

Si le lancement d'une exception cohérente en tant que valeur falsy est autorisé:

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

Essayez-le en ligne! Lève une empty listexception si aucune chaîne n'est trouvée, sinon retourne la première chaîne valide.

-2 octets grâce à Ørjan Johansen

Gelée , 7 octets

z0Q€fZḢ

Retourne l'entier 0 si les chaînes ne peuvent pas être enklactified.

Essayez-le en ligne!

Comment ça marche

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 octets

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

Essayez-le en ligne!

Stax , 9 à 8 octets

åτIⁿs↓µg

Exécuter et déboguer

Explication (non emballée):

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 octets

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

Essayez-le en ligne!

sapplyrenvoie généralement un matrixlorsque tous les length(FUN(X[[i]]))sont égaux, sauf quand length(FUN(X[[i]]))==1, auquel cas il retourne un vector. Pour utiliser les opérations de la matrice, alors, nous devons substringun autre que nous devons garantir une matrix, ce qui explique pourquoi xétend à max(nchar(S)+1).

Nous filtrons ensuite les lignes sans doublons ni chaînes vides. Étant donné que nous ne pouvons renvoyer qu'une seule chaîne, nous prenons la première, à l'exception que s'il n'y a aucune ligne répondant aux critères, une erreur est générée. Nous ajoutons donc une ligne supplémentaire ""à la fin.

Ensuite, nous imprimons la enklactchaîne ified ou la chaîne vide.

R , 116 107 95 octets

R + pryr

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

Essayez-le en ligne!

base R

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

Essayez-le en ligne!

Ces deux variantes économisent 9 octets grâce à Giuseppe .

Explication:

Cela tronque efficacement toutes les piqûres du vecteur và la longueur du plus court et itère les index suivants. Ensuite, vérifie s'il y a des doublons dans les lettres choisies et sinon, les colle et les imprime cat. Si tous les index renvoient des résultats dupliqués, cela affiche une chaîne vide.
Tout est encapsulé dans une pryrfonction anonyme avec breakpour arrêter la boucle, ou la fonction de base R met à zéro le vecteur pour rompre la boucle.

Japt, 9 octets

Prend en entrée un tableau de tableaux de caractères, retourne un tableau de caractères ou undefined

y æ_f eZâ

Essayez-le (ajoutez une nouvelle ligne au début du programme avec le code qR mqà prendre en entrée sous forme de chaîne séparée par une nouvelle ligne, afin de vous éviter les tracas liés à la création des tableaux.)

Explication

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 octets

øʒDÙQ}н

Essayez-le en ligne!

Explication

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

Python 3 , 75 octets

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

Fonctionne sur des listes de caractères au lieu de chaînes. Renvoie False si aucune chaîne enklaction valide n'existe.

Essayez-le en ligne!

C (gcc) , 161 octets

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

Essayez-le en ligne!

Chaque position de caractère est testée pour la duplication et ignorée si une duplication est détectée; cela se poursuit jusqu'à la fin de la chaîne la plus courte. Malheureusement, il n’ya que l’ASCII: les chaînes DBCS / UTF-8 cassent mal cette fonction!

Japt , 12 octets

Renvoie undefinedles chaînes non-enklactiques.

y ·æ_¬n ä¦ e

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Prend une liste de caractères en entrée, retourne une liste de caractères. Contient U + F3C7, correspondant à l'opérateur "Transpose".

Résultats #1 et jette un tas d'erreurs ignorables lorsqu'il n'y a pas de chaîne appropriée.

Explication:

PadRight@#

Complétez l'entrée de sorte que chaque "chaîne" (liste de caractères) ait la même longueur. Ceci ajoute un entier 0s (pas une chaîne "0"s). Puis transposer.

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

Sélectionnez les chaînes qui ne contiennent pas d’entiers 0et qui ont tous des caractères uniques.

#&@@

Obtenez le premier.

JavaScript (ES6), 66 octets

Retourne une chaîne ou undefineds'il n'y a pas de solution.

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

Essayez-le en ligne!

Commenté

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

Charbon de bois , 23 21 octets

-2 octets grâce à @Neil !

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

Essayez-le en ligne!

Coque , 9 octets

ḟS=UḞz:∞ø

Essayez-le en ligne!

Explication

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 octets

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

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

Essayez-le en ligne!

-25 octets grâce à @Neil

Transposer du texte rectangulaire dans Retina est étonnamment difficile.

Perl 6 , 27 octets

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

Essayez-le en ligne!

Après avoir constaté que la version ruby ​​a été votée, j'ai copié l'approche et utilisé des listes de caractères au lieu de chaînes. Je n'aime pas ça

Ma soumission la plus ancienne et la plus correcte est la suivante:

Perl 6 , 38 octets

Split, zip, vérifier l'unicité, rejoindre.

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

Essayez-le en ligne!

C (gcc) , 121 113 110 octets

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

Essayez-le en ligne!

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 grâce à ceilingcat

Cela abuse de la possibilité d'ajouter simplement 1 à un pointeur de chaîne en C pour obtenir la "queue" de la chaîne. Les principaux économiseurs d'octets sont:

• d+=x[y[i++]=*(*_)++]++qui ajoute le premier caractère de la première chaîne de _to y, avance la première chaîne de _pour supprimer son premier caractère, ajoute l' xentrée correspondant à ce caractère det incrémente ladite xentrée
• q=d?*x:puts(y)qui imprime ysi dest non nul tout en fixant qune valeur non nulle, ou qnon à zéro si le premier élément de xest différent de zéro (si nous étions à la fin de l’une des chaînes, cet élément serait non zéro)

Éditer: les octets rasés en passant de la boucle while à l’appel final récursif et en supprimant les crochets de la boucle for.

Pyth, 13 octets

e+kf{[email protected]

Essayez ici

e+kf{[email protected]
           .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.

Rouge , 139 octets

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

Essayez-le en ligne!

Explication:

Prend l'entrée comme un bloc (liste) de chaînes. Retourne la chaîne enklaction ou nonesinon.

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 octets

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

Essayez-le en ligne!

-1 octet grâce au charlatan des vaches

Explication:

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 */
  }
}

Le trymot-clé est utilisé pour supprimer les erreurs qui se produisent si iest supérieure à la longueur de la plus petite chaîne aou s'il n'y a pas de réponse et headprovoque une erreur.

Java 10, 106 octets

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

Donnera une erreur au lieu de retourner une chaîne vide si aucune solution ne peut être trouvée. L'entrée est une matrice de caractères.

Essayez-le en ligne.

Explication:

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 octets

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

Retourne une liste de listes de caractères.

APL + WIN, 35 33 octets

2 octets économisés grâce à Adám

Invite les lignes de texte sous forme de matrice de caractères:

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Explication:

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