Inspiriert von dieser Kommentarkette ...

Ich möchte enklactaus dieser Herausforderung herauskommen, aber ich kann nicht ...

@ETHproductions to enklact (v): Implementieren einer Nachschlagetabelle unter Verwendung eines Unterabschnitts, der aus eindeutigen Elementen besteht.

Enklacting ist eine sehr nützliche Methode zum Komprimieren einer Nachschlagetabelle. Angenommen, Sie hatten die folgende Liste von Farben:

red
green
blue
yellow
purple
orange

Wenn Sie in der Lage sein möchten, eine Farbe als Eingabe zu verwenden und ihren Index in dieser Liste zurückzugeben, gibt es offensichtlich den direkten Weg:

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

Aber es gibt eine Möglichkeit, wie wir dies mit weniger Bytes erreichen können:

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

Dies funktioniert, weil der erste (oder 0.) Index jeder Zeichenfolge eindeutig ist. Dieses Beispiel ist offensichtlich, aber manchmal ist es etwas schwieriger. Was wäre, wenn wir eine Nachschlagetabelle für diese Liste erstellen wollten?

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

In diesem Fall können wir das nicht tun:

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

weil es zwei verschiedene Eingänge gibt, die mit einem beginnen 'T', nämlich "Thunfisch" und "Truthahn". Wir müssen uns einen anderen Index ansehen. Wenn Sie sich den 4. Index jeder Zeichenfolge ansehen, werden Sie feststellen, dass sie alle eindeutig sind. Also können wir das machen ...

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

In diesem Fall lautet die "Enklaktionszeichenfolge" "enklact".

Das führt uns zur heutigen Herausforderung ...

Wenn Sie eine Liste von Zeichenfolgen angegeben haben, geben Sie eine gültige Enklaktionszeichenfolge zurück. Mit anderen Worten, wenn Sie eine Liste von Zeichenfolgen haben, geben Sie jede neue Zeichenfolge zurück, bei der jeder Buchstabe eindeutig ist, und die Zeichenfolge wird durch Verbinden des i-ten Buchstabens jeder Zeichenfolge gebildet.

Wenn es keine gültige Enklaction-Zeichenfolge gibt, muss Ihre Übermittlung stattdessen eine leere Zeichenfolge oder einen konsistenten falschen Wert zurückgeben. Wie üblich sind entweder Funktionen oder vollständige Programme zulässig, und die Eingabe- / Ausgabeformate sind (innerhalb des zulässigen Rahmens) zulässig.

Jede Zeichenfolge enthält nur druckbares ASCII, und bei dieser Abfrage wird die Groß- und Kleinschreibung beachtet.

Das ist Code-Golf , also versuchen Sie, das kürzestmögliche Programm in der Sprache Ihrer Wahl zu schreiben!

Testfälle

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

Gibt einen String mit dem Enklact zurück, ansonsten None

Python 2 , 68 67 61 Bytes

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

Probieren Sie es online!

Verbesserungen

• Von 68 Bytes bis 67 Bytes von Jo King
• Von 66 bis 65 Bytes von Lynn

Wenn die Ausgabe keine Zeichenfolge sein müsste:

Python 3 , 49 Bytes

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

Probieren Sie es online!

Retina , 43 32 Bytes

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

|""Lm`^.

Probieren Sie es online! Bearbeiten: 11 Bytes dank @MartinEnder gespeichert. Erläuterung:

+

Wiederholen, während sich die Eingabe ändert ...

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

... nur wenn eine Zeile leer ist oder zwei Zeilen mit dem gleichen Zeichen beginnen ...

m`^.

... löscht das erste Zeichen jeder Zeile. Die Wiederholung stoppt daher, wenn entweder a) alle Zeilen mit unterschiedlichen Zeichen beginnen, in welchem ​​Fall die Bedingung fehlschlägt und die Eingabe nicht geändert wird, oder b) mindestens eine Zeile leer wird, in welchem ​​Fall alle Zeichen schließlich gelöscht werden, Ab diesem Zeitpunkt ändert sich der Eingang nicht mehr.

|""L`^.

Sammle das erste Zeichen jeder Zeile. (Wenn es keine Lösung gab, hat die obige Schleife alles gelöscht und es gibt nichts zu sammeln.)

Haskell , 71 Bytes

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

Probieren Sie es online!

BMO sparte 3 Bytes mit any null x→ elem""x.

Ørjan Johansen hat ein Byte mit sum[1|b<-y,a==b]<2→ gespeichert filter(==a)[y]==[a].

Erläuterung

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.

Wenn beim Auslösen eines Fehlers ( Prelude.head: empty list) keine Lösung gefunden wird, |elem""x=""kann dieser für 61 Byte gelöscht werden .

Ruby , 38 Bytes

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

Probieren Sie es online!

Vielen Dank an GB für den Hinweis auf einen Fehler.

Pyth , 6 Bytes

>1{I#C

Testsuite.

Die Ausgabe ist standardmäßig eine Singleton-Liste . Die Liste [] (leere Liste, falsch) wird zurückgegeben, falls der String nicht enklaktifiziert werden kann .

Erläuterung

> 1 {I # C - Volles Programm.
     C - Transponieren Sie die Eingabe und schneiden Sie die Abwesenheiten ab.
    # - Filtern nach:
  {I - Invariante unter Deduplizierung.
> 1 - Slice to 1. Liste [: 1] in Python.

Pyth , 5 Bytes

Dies wäre gültig gewesen, wenn Abstürze als falscher Wert gewertet worden wären.

h{I#C

Testsuite.

Haskell , 76 74 Bytes

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

Probieren Sie es online! Gibt die letzte gültige Suchzeichenfolge oder eine leere Zeichenfolge zurück, wenn keine solche Zeichenfolge vorhanden ist.

71 69 Bytes

Wenn das Auslösen einer konsistenten Ausnahme als falscher Wert zulässig ist:

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

Probieren Sie es online! Löst eine empty listAusnahme aus, wenn keine Zeichenfolge gefunden wird. Anderenfalls wird die erste gültige Zeichenfolge zurückgegeben.

-2 Bytes dank Ørjan Johansen

Gelee , 7 Bytes

z0Q€fZḢ

Gibt die Ganzzahl 0 zurück, wenn die Zeichenfolgen nicht enklaktifiziert werden können.

Probieren Sie es online!

Wie es funktioniert

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/,@

Probieren Sie es online!

Stax , 9 8 Bytes

åτIⁿs↓µg

Führen Sie es aus und debuggen Sie es

Erklärung (ausgepackt):

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="")

Probieren Sie es online!

sapplyGibt normalerweise a zurück, matrixwenn alle length(FUN(X[[i]]))Werte gleich sind, außer wenn length(FUN(X[[i]]))==1in diesem Fall a zurückgegeben wird vector. Um die Matrixoperationen verwenden zu können, müssen wir also substringeine weitere Operation ausführen, als wir garantieren müssen matrix, weshalb xsich diese auf erstreckt max(nchar(S)+1).

Wir filtern dann nach Zeilen, die keine Duplikate und keine leeren Zeichenfolgen enthalten. Da wir nur eine einzige Zeichenfolge zurückgeben können, nehmen wir die erste, mit der Ausnahme, dass wir, wenn keine Zeilen vorhanden sind, die Kriterien erfüllen, einen Fehler auslösen und eine zusätzliche Zeile ""an das Ende anhängen .

Dann drucken wir die enklactobied Zeichenfolge oder die leere Zeichenfolge aus.

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

Probieren Sie es online!

Basis R

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

Probieren Sie es online!

Diese beiden Varianten sparen dank Giuseppe 9 Bytes .

Erläuterung:

Dadurch werden alle Zeichenfolgen im Vektor effektiv vauf die kürzeste Länge gekürzt und nachfolgende Indizes durchlaufen. Anschließend wird geprüft, ob Duplikate in ausgewählten Buchstaben enthalten sind. Wenn nicht, werden diese zusammengefügt und mit gedruckt cat. Wenn alle Indizes doppelte Ergebnisse liefern, wird eine leere Zeichenfolge ausgegeben.
Alle in eine anonyme pryrFunktion eingeschlossen break, um die Schleife anzuhalten , oder die Basis-R-Funktion, um den Vektor auf Null zu setzen, um die Schleife zu unterbrechen .

Japt, 9 Bytes

Nimmt Eingaben als Array von Zeichenarrays entgegen, gibt ein Array von Zeichen zurück oder undefined

y æ_f eZâ

Probieren Sie es aus (Fügen Sie zu Beginn des Programms eine neue Zeile mit dem Code hinzu qR mq, um die Eingabe als durch neue Zeilen getrennte Zeichenfolge zu akzeptieren, damit Sie die mühsame Erstellung der Arrays vermeiden.)

Erläuterung

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}н

Probieren Sie es online!

Erläuterung

ø        # 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})]

Funktioniert mit Zeichenlisten anstelle von Zeichenfolgen. Gibt False zurück, wenn keine gültige Enklaktionszeichenfolge vorhanden ist.

Probieren Sie es online!

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

Probieren Sie es online!

Jede Zeichenposition wird auf Duplizierung geprüft und übersprungen, wenn ein Duplikat erkannt wird. Dies wird fortgesetzt, bis die kürzeste Zeichenfolge endet. Es ist leider nur ASCII: DBCS / UTF-8-Strings brechen diese Funktion stark!

Japt , 12 Bytes

Gibt undefinedfür nicht-enklaktische Zeichenfolgen zurück.

y ·æ_¬n ä¦ e

Probieren Sie es online!

Erläuterung:

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@#&]&

Probieren Sie es online!

Nimmt eine Liste mit Zeichen als Eingabe und gibt eine Liste mit Zeichen zurück. Enthält U + F3C7, entsprechend dem Operator "Transponieren".

Gibt #1eine Reihe von ignorierbaren Fehlern zurück und löst sie aus, wenn keine geeignete Zeichenfolge vorhanden ist.

Erläuterung:

PadRight@#

Füllen Sie die Eingabe so auf, dass jede "Zeichenfolge" (Liste der Zeichen) gleich lang ist. Hiermit wird die Ganzzahl 0s (nicht die Zeichenfolge "0"s) angehängt . Dann transponieren.

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

Wählen Sie die Zeichenfolgen aus, die keine Ganzzahlen enthalten 0und alle eindeutigen Zeichen enthalten.

#&@@

Holen Sie sich den ersten.

JavaScript (ES6), 66 Byte

Gibt entweder eine Zeichenfolge zurück oder undefinedwenn keine Lösung vorhanden ist.

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

Probieren Sie es online!

Kommentiert

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

Holzkohle , 23 21 Bytes

-2 Bytes dank @Neil !

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

Probieren Sie es online!

Schale , 9 Bytes

ḟS=UḞz:∞ø

Probieren Sie es online!

Erläuterung

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

Netzhaut , 81 56 Bytes

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

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

Probieren Sie es online!

-25 Bytes dank @Neil

Das Transponieren von rechteckigem Text in Retina ist überraschend schwierig.

Perl 6 , 27 Bytes

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

Probieren Sie es online!

Nachdem ich gesehen habe, dass die Ruby-Version verbessert wurde, habe ich den Ansatz kopiert und Zeichenlisten anstelle von Zeichenfolgen verwendet. Es gefällt mir nicht

Meine ältere und korrektere Einsendung ist wie folgt:

Perl 6 , 38 Bytes

Teilen, Reißverschluss ziehen, Eindeutigkeit prüfen, beitreten.

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

Probieren Sie es online!

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

Probieren Sie es 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 dank ceilingcat

Dies missbraucht die Möglichkeit, einem String-Zeiger in C nur 1 hinzuzufügen, um den 'Schwanz' des Strings zu erhalten. Die wichtigsten Bytesparer sind:

• d+=x[y[i++]=*(*_)++]++die anhängt das erste Zeichen der ersten Zeichenfolge _zu y, rückt die erste Folge von _seinen ersten Zeichen zu entfernen, die fügt xzu dieser Zeicheneingabe zu dund inkrementiert den xEintritt
• q=d?*x:puts(y)Dies gibt aus, yob der Wert dungleich Null ist, während der qWert ungleich Null ist, oder qob der Wert ungleich Null ist, wenn das erste Element von xungleich Null ist. Null)

Bearbeiten: Rasierte Bytes durch Umschalten von while-Schleife auf rekursiven Tail-Aufruf und Entfernen von Klammern aus for-Schleife.

Pyth, 13 Bytes

e+kf{[email protected]

Probieren Sie es hier aus

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.

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

Probieren Sie es online!

Erläuterung:

Nimmt die Eingabe als Block (Liste) von Zeichenfolgen. Gibt die Enklaction- Zeichenfolge oder eine noneandere zurück.

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

Probieren Sie es online!

-1 Byte dank Kühe quaken

Erläuterung:

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

Das trySchlüsselwort wird verwendet, um Fehler zu verwerfen, die auftreten, wenn idie Länge der kleinsten Zeichenfolge überschritten awird oder wenn keine Antwort headvorliegt und ein Fehler auftritt .

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

Gibt einen Fehler aus, anstatt einen leeren String zurückzugeben, wenn keine Lösung gefunden werden kann. Die Eingabe ist eine Zeichenmatrix.

Probieren Sie es online aus.

Erläuterung:

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)

Gibt eine Liste mit Listen von Zeichen zurück.

APL + WIN, 35 33 Bytes

2 Bytes gespart dank Adám

Fordert zur Eingabe der Textzeilen als Zeichenmatrix auf:

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Erläuterung:

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