Für diese Herausforderung müssen Sie das Ruby- AbbrevModul in möglichst wenig Code implementieren .

Herausforderung

• Die Eingabe erfolgt in einer beliebigen Sprache als Array (Array, Liste, Sequenz usw.) von Zeichenfolgen. Sie können eine Funktion schreiben oder durch Kommas getrennte Wörter in STDIN akzeptieren.

• Sie müssen dann den Satz eindeutiger Präfixe für diese Zeichenfolgen berechnen. Dies bedeutet, dass Sie einen Hash (oder eine Karte, ein Objekt usw.) der Abkürzungen an ihre ursprünglichen Zeichenfolgen zurückgeben müssen.

  • Ein "Präfix" ist eine Teilzeichenfolge der ursprünglichen Zeichenfolge, die am Anfang der Zeichenfolge beginnt. Beispielsweise ist "pref" ein Präfix des Wortes "prefix".

  • Ein eindeutiges Präfix kann nur ein Wort bedeuten. Wenn Ihre Eingabe beispielsweise lautet car,cat, cahandelt es sich nicht um ein eindeutiges Präfix, da dies entweder "Auto" oder "Katze" bedeuten kann.

  • Die Ausnahme von dieser Regel ist, dass ein Wort immer ein Präfix für sich selbst ist. Wenn Sie beispielsweise Eingaben wie haben car,carpet, car:carmüssen Sie in Ihrer Ausgabe sein.

• Sie können dann den Hash / map / object / etc zurückgeben. von Ihrer Funktion aus (oder tun Sie das Gleiche in Ihrer Sprache), oder drucken Sie es key:valuepaarweise in Form von an STDOUT aus f:foo,fo:foo,.... (Die Schlüssel-Wert-Paare können auch durch Leerzeichen getrennt werden, wenn dies Ihren Code verkürzt.)

Testfälle

Input  code,golf,going
Output c:code,co:code,cod:code,code:code,gol:golf,golf:golf,goi:going,goin:going,going:going

Input  pie
Output p:pie,pi:pie,pie:pie

Input  pie,pier,pierre
Output pie:pie,pier:pier,pierr:pierre,pierre:pierre

Input  a,dog
Output a:a,d:dog,do:dog,dog:dog

Regeln

• Die Eingabe enthält keine doppelten Elemente.

• Ihre Ausgabe kann in beliebiger Reihenfolge erfolgen. du musst es nicht sortieren.

• Sie dürfen keine eingebauten AbbrevModule / Funktionen / Dinge wie Ruby's verwenden.

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

APL (46)

(Ja, der APL-Zeichensatz passt in ein Byte und bietet ausreichend Platz.)

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}

Dies ist eine Funktion, die eine Liste von Zeichenfolgen verwendet und eine 2-mal-N-Matrix zurückgibt, wobei jede Zeile ein eindeutiges Präfix und das Wort enthält, zu dem sie gehört:

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}'code' 'golf' 'going'
 c      code  
 co     code  
 cod    code  
 code   code   
 gol    golf  
 golf   golf  
 goi    going 
 goin   going 
 going  going 

Erläuterung:

• ∆←⍵: Speichere das richtige Argument in ∆.
• {↑∘⍵¨⍳⍴⍵}¨∆: Für jedes Element von ∆erhalten Sie die möglichen Präfixe dieses Elements:
  • ⍳⍴⍵: bekomme eine Liste von 1bis zur Länge von⍵
  • ↑∘⍵¨: Holen Sie sich für jede dieser Zahlen so viele Elemente aus ⍵.
• ∪⊃,/: verketten Sie die Listen und nehmen Sie die eindeutigen Werte.
• {... }¨: für jedes der eindeutigen Präfixe:
  • ∆/⍨⊃¨⍵∘⍷¨∆: Wählen Sie die Wörter aus, die mit diesem Präfix beginnen
  • (⊂⍵),: auch das Präfix einschließen und verketten
  • ∆/⍨2=⍴∆←: gib die Liste nur zurück, wenn es zwei Elemente gibt (das Präfix und ein passendes Wort)
• ↑: verwandle die Liste der Tupel in eine Matrix

Python 2.7 - 146 141 Bytes

l=raw_input().split(',')
for w in l:
 for a in range(len(w)):
    e=w[:a+1]
    if e==w or len(filter(lambda b:b.startswith(e),l))==1:print e+':'+w

Beachten Sie, dass die Einrückung in den Zeilen 4 und 5 nicht 4 Leerzeichen beträgt. Dies ist ein Nebeneffekt des SE-Markdown-Interpreters. Das ist ein buchstäbliches Tabulatorzeichen, also nur ein Byte.

Dies entspricht technisch nicht den Vorgaben, aber ich werde es ändern, wenn Doorknob dies klarstellt. Es werden Zeilenumbrüche anstelle von Kommas verwendet, um die Ausgabe zu trennen. Beispielsweise:

$ python2 abbreviations.py <<< code,golf,golfing
c:code
co:code
cod:code
code:code
golf:golf
golfi:golfing
golfin:golfing
golfing:golfing

Neu: Ich konnte 5 Zeichen loswerden, indem ich die Zeichenfolge, die ich überprüfe, einer Variablen zuordnete e. Das bedeutet , dass ich nur eingeben müssen , eanstatt w[:a]dreimal. Es bedeutet auch , speichere ich Zeichen , indem Sie e=w[:a+1]und Wechsel ...range(1,len(w)+1)zu range(len(w)).

Erläuterung:

l=raw_input().split(',') # Gets a line of input from stdin and splits it at every ',' to make a list
for w in l: # For each word in that list...

 for a in range(1,len(w)+1): # For each number a from 1 to the length of that word...

    if (w[:a]==w # w[:a] gets the string w up to the ath index. For example, 'aeiou'[:3] == 'aei'.
                 # We're testing every possible w[:a] to see if it's a unique abbreviation.
                 # However, a word is always its own abbreviation, so we hardcode that in by testing
                 # if w[:a] is the same as w.

or len(filter( # filter takes a function and an iterable as an argument, and returns a list of every
               # element of that iterable where that_function(that_element) returns a True-y value

lambda b:b.startswith(w[:a]),l) # We define an anonymous function that returns True for any string
                                # that begins with our current w[:a]. We filter for words that return
                                # True.

)==1): # If exactly one word returns True for this, it's a unique abbreviation!

     print w[:a]+':'+w # Print the abbreviation, a colon, and the full word.

J - 47 Zeichen

(,.~~.@,~[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>)

J sieht Strings nur als Vektoren von Zeichen, was bedeutet, dass beim Versuch, eine Liste von Strings zu erstellen, tatsächlich eine Tabelle von Zeichen erstellt wird, sodass die Enden mit Leerzeichen aufgefüllt werden. Js Lösung hierfür heißt " Box" . Daher verwendet diese Funktion eine Box-Liste von Zeichenfolgen als Argument, um die Länge zu erhalten.

   'code';'golf';'going'
+----+----+-----+
|code|golf|going|
+----+----+-----+

Außerdem fehlt J ein Hash-Typ, so dass er einer zweispaltigen Tabelle von Elementen am nächsten kommt, beispielsweise Strings in Boxen. Wenn das nicht akzeptabel ist und ich standardmäßig das Schlüsselwertformular verwenden muss, kann ich die Ausgabe in dieses Formular mit insgesamt 67 Zeichen umformatieren :

;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>)

Erklärung durch Explosion:

(,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) NB. unambiguous prefixes
                                    (     )&.>  NB. for each string:
                                     <\         NB.   take all prefixes
                                       ,.<      NB.   pair each with string
        [:                         ;            NB. gather up "partial" hashes
          (#~1-                  )@             NB. remove those rows where:
               1({.\        ){."1               NB.   each key
                    e."_1                       NB.   is an element of
               1(        ]\.){."1               NB.   the rest of the keys
 ,.~                                            NB. hash each word to itself
       ,                                        NB. add these rows to hash
    ~.@                                         NB. remove duplicate rows

Beispiele:

   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) 'pie';'pier';'pierre'
+------+------+
|pie   |pie   |
+------+------+
|pier  |pier  |
+------+------+
|pierre|pierre|
+------+------+
|pierr |pierre|
+------+------+
   NB. 1-char words have to be made into lists with ,
   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) (,'a');'dog'
+---+---+
|a  |a  |
+---+---+
|dog|dog|
+---+---+
|d  |dog|
+---+---+
|do |dog|
+---+---+
   NB. "key:value," format, reversed order to save chars
   ;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>) 'code';'golf';'going'
goin:going,goi:going,gol:golf,cod:code,co:code,c:code,going:going,golf:golf,code:code,

Haskell 96 87

import Data.List
i=inits
f a=a>>= \x->[(y,x)|y<-i x,y/="",y`notElem`(a>>=i)\\i x||y==x]

Ungolfed-Version:

 import Data.List
 f a = concatMap (\x ->
     [(y, x) |
      y <- inits x,
      y /= "",
      y `notElem` concatMap inits a \\ inits x || y == x]
     ) a

Beispiel:

> f ["pi","pier","pierre"]
[("pi","pi"),("pier","pier"),("pierr","pierre"),("pierre","pierre")]

Ich habe die initsFunktion verwendet, die alle Präfixe einer Liste / Zeichenfolge findet. Zählt es als Betrug?

Python 3 (97)

c=','
S=c+input()
for w in S.split(c):
 e=w
 while e:e<w<w*S.count(c+e)or print(e+':'+w);e=e[:-1]

Wir iterieren über Präfixe jedes Wortes in der Eingabe und drucken das entsprechende Präfix / Wort-Paar, wenn es entweder genau einmal vorkommt oder zu einem ganzen Wort gehört. Wir nutzen das Kurzschlussverhalten vonor (undprint dessen Funktion), um nur dann zu drucken, wenn eine dieser Bedingungen erfüllt ist.

Das while Schleife schneidet das letzte Zeichen wiederholt ab, um kürzere und kürzere Präfixe zu erstellen, die enden, wenn die leere Zeichenfolge verbleibt. Dies ist das einzige Mal, dass wir irgendetwas indizieren oder aufteilen.

Wir zählen die Vorkommen des Präfixes ein der Eingabe, indem wir die ursprüngliche durch Kommas getrennte Eingabezeichenfolge Snach Teilzeichenfolgen durchsuchen','+e . Wir stellen der Eingabezeichenfolge vorab ein Komma voran. Dieser Zusatz bewirkt ein zusätzliches leeres Zeichenkettenelement, wenn wirsplit , das jedoch keine Auswirkung hat, da es keine nicht leeren Teilzeichenfolgen enthält.

Um zu überprüfen, ob die Teilzeichenfolge edas ganze Wort ist w, vergleichen wir sie mit dem Zeichenfolgenvergleichsoperator. Dies wird lexikografisch verglichen, sodass kürzere Präfixe kleiner sind. Der Doppelvergleich schlägt fehl, wenn entweder e==woderS.count(c+e)<2 .

Wenn das Drucken von Ausgaben im Formular e,wzulässig wäre, würde ich ein Zeichen durch Schreiben speicherne+c+w stattdessen .

Gutschrift an undergroundmonorail, aus deren Antwort ich meine gesamte Codestruktur ableitete.

Ruby, 114

def f(l);h={};l.each{|w|w.size.times{|i|k=w[0..i];h[k]=h[k]&&0||w}};h.delete_if{|k,v|v==0};l.each{|w|h[w]=w};h end

Ungolfed:

def f(list)
  hash = {}
  list.each do |word|
    word.size.times do |i|
      key = word[0..i]
      h[key] = (hash[key] && 0) || word
    end
  end
  hash.delete_if{|key, value| v==0}
  list.each{|word| hash[word] = word}
  hash 
end

k4 (70)

nicht besonders golfen; Ich bin sicher, es könnte kürzer sein

ziemlich ähnlich dem J impl. oben denke ich - sammelt im Grunde nur alle (richtigen) Präfixe, entfernt die Wörter aus den Präfixen wieder (um den "car"/ "carpet"case zu behandeln), gruppiert sie in Äquivalenzklassen, wählt die Klassen mit nur einem Element aus, reduziert sie von Listen auf Zeichenfolgen und fügt in der Map Zeichenfolgen zu sich selbst hinzu.

f:{(x!x),*:'{(&1=#:'x)#x}{x@=y@:&~y in x}.,/'+{1_'(c#,x;(!c:#x)#\:x)}'x}

einige Testfälle

Beachten Sie, dass in k/ qeine Zeichenfolge eine Liste von Zeichen ist. Daher muss eine Zeichenfolge, die nur ein einzelnes Zeichen enthält, mit der unären ,Funktion als solche gekennzeichnet werden . & mmwrt eine Liste von Zeichenketten, die nur eine einzige Zeichenkette enthalten

Diese verwenden qdie showFunktion, die für einige Datenstrukturen eine integrierte Formatierung aufweist, um die Ergebnisse besser lesbar zu machen:

  .q.show f("code";"golf";"going")
"code" | "code"
"golf" | "golf"
"going"| "going"
,"c"   | "code"
"co"   | "code"
"cod"  | "code"
"gol"  | "golf"
"goi"  | "going"
"goin" | "going"
  .q.show f@,"pie"
"pie"| "pie"
,"p" | "pie"
"pi" | "pie"
  .q.show f("pie";"pier";"pierre")
"pie"   | "pie"
"pier"  | "pier"
"pierre"| "pierre"
"pierr" | "pierre"
  .q.show f(,"a";"dog")
,"a" | ,"a"
"dog"| "dog"
,"d" | "dog"
"do" | "dog"
  .q.show f("car";"carpet")
"car"   | "car"
"carpet"| "carpet"
"carp"  | "carpet"
"carpe" | "carpet"

JavaScript - 212

w=prompt(o=[]).split(",");w.map(function(k,l){for(i=0;++i<k.length;){p=k.slice(0,i);if(w.filter(function(r,t){return t!=l}).every(function(r){return r.indexOf(p)}))o.push(p+":"+k)}o.push(k+":"+k)});console.log(o)

Anfängliches Golf.

Eingang:

code,golf,going

Ausgabe:

["c:code", "co:code", "cod:code", "code:code", "gol:golf", "golf:golf", "goi:going", "goin:going", "going:going"]

Perl, 93 77

Mit Zeilenumbrüchen und Einrückung zur besseren Lesbarkeit:

sub f{
    (map{
        $h{$x}=[($x=$`.$&,$_)x!$h{$x}]while/./g;
        $_,$_
    }@_),map@$_,values%h
}

Ein bisschen zu spät und zu lang, aber ich bin froh, dass es endlich unter 100 ist. Die Funktion gibt eine Liste zurück, die einer Hash-Variablen zugewiesen werden kann:

%h = f(qw/code golf going pie pier pierre/);
print "$_ $h{$_}\n" for sort keys %h;

und

perl prefix.pl
c code
co code
cod code
code code
goi going
goin going
going going
gol golf
golf golf
pie pie
pier pier
pierr pierre
pierre pierre

Tatsächlich ist die zurückgegebene Liste noch nicht gefiltert - die Hash-Konstruktion ist zum Zeitpunkt ihrer Zuweisung abgeschlossen, dh außerhalb der Funktion. WENN es nicht sauber / fair genug ist, addieren Sie 3, um den Inhalt der Funktion zu zählen, und setzen Sie ihn in geschweifte Klammern +.

F: 44 Bytes

{x!p@'(?0,&:)'p in\:&1=#:'=,/p:`$(-1_)\'$x}

ANMERKUNGEN

• Q-Sprache hat einen inneren Kern, der intern als K4 bezeichnet wird (in dieser Antwort und einer anderen vorherigen Antwort auf diese Frage verwendet).

• Laden Sie zum Testen des Codes den Interpreter herunter (kx.com, kostenlos für nicht kommerzielle Zwecke, Unterstützung für Windows, Linux, Mac).

Interpreter lässt zwei Syntax zu:

• ausführlicher (lesbarere Namen, eindeutige Namen für moands und diads, mehr Bibliotheken, ...). Laden Sie die Quelldatei mit der Erweiterung q oder mit einem interaktiven Interpreter

• kompakt (funktionaler innerer Kern, Ein-Buchstaben-Operatoren, gleicher Buchstabe für beide Verwendungszwecke Monade / Diade, ...). Laden Sie die Quelldatei mit der Erweiterung k oder den interaktiven Interpreter im Modus k (schreiben Sie \ an der Eingabeaufforderung). Code muss in diesem Modus getestet werden

Der Code definiert ein Lambda (anonyme Funktion). Um der Funktion einen Namen zu geben, benötigen wir das Präfix name: (ex f: {..}), also 46 Bytes

PRÜFUNG

(angenommene benannte Funktion: Ersetzen Sie ansonsten den Code durch f)

f `code`golf`going

`code`golf`going!(`code`cod`co`c;`golf`gol;`going`goin`goi)

Gibt ein Wörterbuch zurück (Syntaxschlüssel! Werte). Tasten sind eine Liste von Symbolen (`symb`symb ..) und Werte eine Liste von Symbollisten. Wenn wir die Sentente am interaktiven Interpreter ausführen, haben wir eine bequemere Darstellung (jeder Schlüssel und zugeordnete Werte in einer anderen Zeile)

code | `code`cod`co`c
golf | `golf`gol
going| `going`goin`goi

ERLÄUTERUNG

x ist das implizite Argument zum Lambda

$x Symbolliste in Stringliste konvertieren

(-1_)\ Durchläuft jedes Element der Symbolliste

(Liest wie für jede Zeichenfolge berechnet Präfixe (beim Essen Iteration löscht das letzte Zeichen der Zeichenfolge (-1_), bis leere Zeichenfolge)

$ wird wieder in eine Symbolliste umgewandelt (Liste aller Präfixe)

p: und weist zu p

,/ raze all (verkettet und erstellt eine einstufige Struktur)

= classify -> ordnet jedem eindeutigen Präfix die entsprechenden Wörter zu

#:' berechnet die Länge (Anzahl der Wörter, die jedem Präfix zugeordnet sind)

1= true, wenn length = 1 (eindeutig), andernfalls false

& Wobei -> Index der wahren Elemente

p in\: Bestimmt für alle Präfixe, ob sie ein eindeutiges Präfix haben

(..)' gilt (..) für jeden Wert rechts (eindeutiges Präfix)

?0,&: -> eindeutige 0 verkettet wo (um Wörter als Präfix von sich selbst zu bewältigen)

p@ Indizes in Symbole umwandeln

x!.. Konstruiere ein Wörterbuch mit x (Wörtern) als Schlüssel und .. als Werten

Gelesen als:

• Erstellt ein Wörterbuch und gibt es mit den Wörtern als Schlüssel und Werten zurück.

• ... Werte von Indizes an unterschiedlichen Positionen 0 (alle Wörter) und mit eindeutigem Präfix

• ... eindeutig berechnet als Präfixe, die nur bei einem Wort vorkommen (Wortliste, die jedem Symbol zugeordnet ist, hat die Länge eins)

• ... Listen, die sich aus der Klassifizierung aller eindeutigen Symbole mit den entsprechenden Wörtern ergeben

• ... Präfixe, die durch Wiederholen des letzten Zeichens jedes Wortes berechnet werden

PHP 7.0, 67 Bytes (nach der Challenge)

for(;a&$c=$s[++$k]??($s=$argv[++$i])[$k=+$t=!1];)echo$t.=$c,":$s,";

Nimmt Eingaben von Befehlszeilenargumenten entgegen. druckt ein Komma nach; renn mit-nr .

Fügen Sie für neueres PHP ein Byte hinzu: Ersetzen &adurch""< .

Verwenden Sie für älteres PHP diese 70 Bytes:

PHP, 70 Bytes

for(;a&$s=$argv[++$i];)for($k=+$t="";a&$c=$s[$k++];)echo$t.=$c,":$s,";

Brachylog , 23 Bytes

∋Xa₀Y;?↔⟨∋a₀⟩ᶜ1∧Y;X|∋gj

Probieren Sie es online!

Übernimmt die Eingabe als Liste über die Eingabevariable und generiert eine Liste von [key, value]Paaren über die Ausgabevariable. Jede Eingabezeichenfolge, die kein Präfix einer anderen Eingabezeichenfolge ist, wird zweimal als Präfix von sich selbst generiert, obwohl der Header von TIO dies verbirgt, indem er verwendet ᵘ, um die vollständige Liste zu erhalten, anstatt ᶠ.

 X                         X
∋                          is an element of
                           the input variable
    Y                      and Y
  a₀                       is a prefix of
 X                         X.
             ᶜ             The number of ways in which
        ⟨∋  ⟩              an element can be selected from
     ;?↔⟨   ⟩              the input variable
    Y; ↔⟨ a₀⟩              such that it has Y as a prefix
              1            is equal to 1.
               ∧Y          Y is not necessarily 1,
                   |       and the output variable
                Y;X        is the list [Y, X].
                   |       If every choice from the first rule has been taken already,
                           the output variable is
                    ∋      an element of
                   |       the input variable
                     gj    paired with itself.

Perl 5 -a , 76 Bytes

map{say"$, $a"if($,=substr$a,0,$_)eq$a||2>grep/^$,/,@F}1..length($a=$_)for@F

Probieren Sie es online!

APL (Dyalog Classic) , 38 Byte

danke Erik the Outgolfer, der mich daran erinnert hat, eine Einzelbyte-Zeichenkodierung zu verwenden

{⊃,/⍵{b,¨⍨(⊂¨⍵~⊃,/a~⊂⍵)∪b←⊂⊂⍺}¨a←,\¨⍵}

Probieren Sie es online!

Python (127)

Also konnte ich @undergroundmonorail nicht kommentieren, aber ich dachte, dass ein Wörterbuchansatz besser wäre? Ich bin mir sicher, dass es mit einigem Listen- / Wörterbuchverständnis auch enorm reduziert werden könnte, aber es kann nicht funktionieren, wenn man aus dem Diktat herausspringt.

i=raw_input().split(",")
d = {}
for x in i:
    for c in range(1,len(x)+1):
        if x[:c] in d:
            del d[x[:c]]
        else:
            d[x[:c]]=x
print d

Der Ausdruck gibt das Wörterbuch ungeordnet aus.

EDIT: Ahh ich habe das Auto verpasst: Auto / Auto: Teppich Kriterien. Vielleicht eine Längenprüfung?

Groovy - 212 Zeichen

Golf gespielt:

c="collectEntries";f="findAll";def g={def h=[:].withDefault{[]};it.each{def w->w.size().times{ h[w[0..it]] << w}};(h."$f"{k,v->v.size()==1}."$c"{k,v->[k,v[0]]}).plus(h."$f"{k,v->v.contains(k)}."$c"{k,v->[k,k]})}

Beispielausgabe:

println g(["code","golf","going"])

[c:code, co:code, cod:code, code:code, gol:golf, golf:golf, goi:going, goin:going, going:going]

Ungolfed:

def g = { def list ->
    def hash = [:].withDefault{[]}
    list.each {
        def word -> word.size().times{ hash[word[0..it]] << word }
    }

    def map = hash.findAll{ k,v -> v.size() == 1 }.collectEntries{ k,v -> [k,v[0]] }
    map.plus(hash.findAll{ k,v -> v.contains(k) }.collectEntries{ k,v -> [k,k] }
    map
}

JavaScript (Node.js) , 88 Byte

L=>L.map(s=>[...s].map(c=>L.filter(t=>t>S&t<S+'~',S+=c)[1]&&s>S||(R[S]=s),S=''),R={})&&R

Probieren Sie es online!

Zsh , 95 Bytes

local -A m
for w;{m[$w]=$w;x=
for c (${(s::)w})x+=$c&&[ ${(M)@:#$x*} = $w ]&&m[$x]=$w
}
local m

Probieren Sie es online!

Die einzige Möglichkeit, ein assoziatives Array in Bash / Zsh "zurückzugeben", besteht darin, es ohne das localSchlüsselwort zu deklarieren und dann im übergeordneten Bereich darauf zuzugreifen. Dies würde ein Byte sparen. I / O über Variablen ist jedoch im Allgemeinen verpönt, sodass wir stattdessen die Array-Definition drucken.

local -A m                          # declare m as associative
                                    # "local" is shorter than "typeset"/"declare"
for w;{                             # for each word
    m[$w]=$w                        # the word is a prefix of itself
    x=                              # ensure x is empty
    for c (${(s::)w})               # for each character in the word
        x+=$c &&                    # append to x (building a prefix
          [ ${(M)@:#$x*} = $w ] &&  # if the only match is the word itself:
          m[$x]=$w                  # ... then x is a prefix of w
}
local m                             # print m

Rubin , 84 Bytes

Ich habe gerade bemerkt, dass es bereits eine Ruby-Lösung gibt. Dies verbessert im Wesentlichen die alte Lösung, indem Präfixe intelligenter ausgewählt werden (ohne dass jedes Wort am Ende als "Präfix" hinzugefügt werden muss) und Präfixe gezählt werden, um die Eindeutigkeit zu überprüfen, bevor sie zum Hash hinzugefügt werden, anstatt den Wert mit zu überschreiben ein Dummy, wenn es ein Duplikat gibt und dann den Eintrag löscht.

->w{h={};w.map{|e|(1..e.size).map{|i|w.count{|d|d[0,i]==e[0,i]}<2?h[e[0,i]]=e:0}};h}

Probieren Sie es online!