In der Informationstheorie ist ein "Präfixcode" ein Wörterbuch, in dem keiner der Schlüssel ein Präfix eines anderen ist. Mit anderen Worten bedeutet dies, dass keine der Zeichenfolgen mit einer der anderen beginnt.

Dies ist beispielsweise {"9", "55"}ein Präfixcode, dies {"5", "9", "55"}ist jedoch nicht der Fall.

Der größte Vorteil dabei ist, dass der codierte Text ohne Trennzeichen aufgeschrieben werden kann und dennoch eindeutig entschlüsselbar ist. Dies zeigt sich in Komprimierungsalgorithmen wie der Huffman-Codierung , die immer den optimalen Präfixcode generiert.

Ihre Aufgabe ist einfach: Bestimmen Sie anhand einer Liste von Zeichenfolgen, ob es sich um einen gültigen Präfixcode handelt.

Deine Eingabe:

• Wird eine Liste von Zeichenfolgen in jedem vernünftigen Format sein .

• Enthält nur druckbare ASCII-Zeichenfolgen.

• Enthält keine leeren Zeichenfolgen.

Ihre Ausgabe ist ein Wahrheits- / Falsch- Wert: Wahrheit, wenn es ein gültiger Präfix-Code ist, und Falsch, wenn dies nicht der Fall ist.

Hier sind einige echte Testfälle:

["Hello", "World"]                      
["Code", "Golf", "Is", "Cool"]
["1", "2", "3", "4", "5"]
["This", "test", "case", "is", "true"]          

["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]

Hier sind einige falsche Testfälle:

["4", "42"]                             
["1", "2", "3", "34"]                   
["This", "test", "case", "is", "false", "t"]
["He", "said", "Hello"]
["0", "00", "00001"]
["Duplicate", "Duplicate", "Keys", "Keys"]

Dies ist Code-Golf, daher gelten Standard-Regelungslücken und die kürzeste Antwort in Bytes gewinnt.

Pyth, 8 Bytes

.AxM.PQ2

Testsuite

Nehmen Sie alle 2 Elementpermutationen der Eingabe, ordnen Sie jede dem Index einer Zeichenfolge in der anderen zu (0 für ein Präfix) und geben Sie zurück, ob alle Ergebnisse wahr sind (nicht Null).

Haskell, 37 Bytes

f l=[x|x<-l,y<-l,zip x x==zip x y]==l

Jedes Element xvon lwird einmal für jedes Element, dessen Präfix es ist, wiederholt. Dies ist genau ein Mal für eine Liste ohne Präfix, wobei die ursprüngliche Liste angegeben wird. Die Präfixeigenschaft wird durch Zippen beider Listen mit überprüft x, wodurch Elemente über die Länge von abgeschnitten werden x.

Java, 128 127 126 125 124 121 Byte

(Vielen Dank, @Kenny Lau, @Maltysen, @Patrick Roberts, @Joba)

Object a(String[]a){for(int i=0,j,l=a.length;i<l;i++)for(j=0;j<l;)if(i!=j&a[j++].startsWith(a[i]))return 1<0;return 1>0;}

Ungolfed

Object a(String[] a) {
    for (int i = 0, j, l = a.length; i < l; i++) 
        for (j = 0; j < l;) 
            if (i != j & a[j++].startsWith(a[i])) return 1<0;
    return 1>0;
}

Ausgabe

[Hello, World]
true

[Code, Golf, Is, Cool]
true

[1, 2, 3, 4, 5]
true

[This, test, case, is, true]
true

[111, 010, 000, 1101, 1010, 1000, 0111, 0010, 1011, 0110, 11001, 00110, 10011, 11000, 00111, 10010]
true

[4, 42]
false

[1, 2, 3, 34]
false

[This, test, case, is, false, t]
false

[He, said, Hello]
false

[0, 00, 00001]
false

[Duplicate, Duplicate, Keys, Keys]
false

Python 2, 48 51 Bytes

lambda l:all(1/map(a.find,l).count(0)for a in l)

Für jedes Element avon ermittelt ldie Funktion a.findden Index des ersten Vorkommens ain der Eingabezeichenfolge und gibt -1eine Abwesenheit an. Gibt also 0ein Präfix an. In einer Liste ohne Präfix gibt die Zuordnung dieser Funktion nur eine einzige 0für asich zurück. Die Funktion prüft, ob dies bei jedem der Fall ist a.

51 Bytes:

lambda l:[a for a in l for b in l if b<=a<b+'~']==l

Ersetzen Sie ~durch ein Zeichen mit dem ASCII-Code 128 oder höher.

Für jedes Element ain list eine Kopie für jedes Element enthalten, das ein Präfix davon ist. Bei einer Liste ohne Präfix ist das einzige solche Element aselbst, sodass die ursprüngliche Liste erhalten wird.

CJam, 14 Bytes

q~$W%2ew::#0&!

Testsuite.

Erläuterung

q~   e# Read and evaluate input.
$    e# Sort strings. If a prefix exists it will end up directly in front 
     e# of a string which contains it.
W%   e# Reverse list.
2ew  e# Get all consecutive pairs of strings.
::#  e# For each pair, find the first occurrence of the second string in the first.
     e# If a prefix exists that will result in a 0, otherwise in something non-zero.
0&   e# Set intersection with 0, yielding [0] for falsy cases and [] for truthy ones.
!    e# Logical NOT.

JavaScript ES6, 65 43 40 Bytes

a=>!/(.*)\1/.test(''+a.sort().join``)
      ^            ^               ^ embedded NUL characters

Meine vorherige Lösung, die String-Arrays aller UTF-8-Zeichen handhabte:

a=>!/[^\\]("([^"]*\\")*[^\\])",\1/.test(JSON.stringify(a.sort()))

Ich konnte es vermeiden, JSON.stringifyda die Aufforderung nur druckbare ASCII-Zeichen angibt.

Prüfung

f=a=>!/(\0.*)\1/.test('\0'+a.sort().join`\0`) // since stackexchange removes embedded NUL characters

O.textContent += 'OK: '+
[["Hello", "World"]                      
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]          
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a)) 

O.textContent += '\nKO: '+
[["4", "42"]                             
,["1", "2", "3", "34"]                   
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

<pre id=O></pre>

Haskell, 49 Bytes

g x=[1|z<-map((and.).zipWith(==))x<*>x,z]==(1<$x)

Dies hat ein paar Teile:

-- Are two lists (or strings) equal for their first min(length_of_1,length_of_2) elements, i.e. is one the prefix of the other?
(and.).zipWith(==)

-- Check whether one element is the prefix of the other, for all pairs of elements (including equal pairs)
map((and.).zipWith(==))x<*>x

-- This is a list of 1's of length (number of elements that are the prefix of the other)
[1|z<-map((and.).zipWith(==))x<*>x,z]

-- This is the input list, with all the elements replaced with 1's
(1<$x)

Wenn die beiden Listen gleich sind, ist ein Element nur das Präfix von sich selbst und es ist gültig.

Retina , 19 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

O`.+
Mm1`^(.+)¶\1
0

Der Eingang sollte zeilenweise getrennt sein. Ausgabe ist 0für falsch und1 für wahr.

Probieren Sie es online!(Leicht modifiziert, um stattdessen mehrere durch Leerzeichen getrennte Testfälle zu unterstützen.)

Erläuterung

O`.+

Sortieren Sie die Zeilen in der Eingabe. Wenn ein Präfix existiert, endet es direkt vor einer Zeichenfolge, die es enthält.

Mm1`^(.+)¶\1

Versuchen Sie, Meine vollständige Zeile abzugleichen ( ), die sich auch am Anfang der nächsten Zeile befindet. Der maktiviert den Multiline-Modus so, dass er ^mit dem Zeilenanfang übereinstimmt, und 1stellt sicher, dass höchstens eine Übereinstimmung gezählt wird, sodass die Ausgabe 0oder ist 1.

0

Zum Tauschen 0und 1im Ergebnis zählen wir die Anzahl der 0s.

Java, 97 Bytes

Object a(String[]a){for(String t:a)for(String e:a)if(t!=e&t.startsWith(e))return 1<0;return 1>0;}

Verwendet die meisten Tricks aus @ Marvs Antwort aber auch die Gleichheit von foreach-Schleife und String-Referenz.

Nicht abgeschlossen:

Object a(String[]a){
    for (String t : a)
        for (String e : a)
            if (t != e & t.startsWith(e))
                return 1<0;
    return 1>0;
}

Beachten Sie, dass dies, wie gesagt, die Zeichenfolgenreferenzgleichheit verwendet. Das bedeutet, dass sich der Code aufgrund von String-Internierung merkwürdig verhalten kann . Der Code funktioniert nicht nur bei der Verwendung von Argumenten, die über die Befehlszeile übergeben wurden, sondern auch bei der Verwendung von Elementen, die über die Befehlszeile gelesen wurden. Wenn Sie die zu testenden Werte fest codieren möchten, müssen Sie den String-Konstruktor manuell aufrufen, um zu erzwingen, dass keine Internierung stattfindet:

System.out.println(a(new String[] {new String("Hello"), new String("World")}));
System.out.println(a(new String[] {new String("Code"), new String("Golf"), new String("Is"), new String("Cool")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("4"), new String("5")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("true")}));
System.out.println(a(new String[] {new String("111"), new String("010"), new String("000"), new String("1101"), new String("1010"), new String("1000"), new String("0111"), new String("0010"), new String("1011"), new String("0110"), new String("11001"), new String("00110"), new String("10011"), new String("11000"), new String("00111"), new String("10010")}));
System.out.println(a(new String[] {new String("4"), new String("42")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("34")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("false"), new String("t")}));
System.out.println(a(new String[] {new String("He"), new String("said"), new String("Hello")}));
System.out.println(a(new String[] {new String("0"), new String("00"), new String("00001")}));
System.out.println(a(new String[] {new String("Duplicate"), new String("Duplicate"), new String("Keys"), new String("Keys")}));

PostgreSQL, 186 , 173 Bytes

WITH y AS(SELECT * FROM t,LATERAL unnest(c)WITH ORDINALITY s(z,r))
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

Ausgabe:

Diesmal keine Live-Demo. http://sqlfiddle.com unterstützt nur 9.3 und zum Ausführen dieser Demo wird 9.4 benötigt.

Wie es funktioniert:

1. Teilen Sie das String-Array mit der Nummer und dem Namen y
2. Holen Sie sich alle y
3. LEFT OUTER JOINauf die gleiche abgeleitete Tabelle basierend auf der gleichen i(id), aber mit unterschiedlichen oridinal, die mit dem Präfix beginneny.z LIKE u.z||'%'
4. Gruppieren Sie das Ergebnis basierend auf c(anfängliches Array) und verwenden Sie die EVERYGruppierungsfunktion. Wenn jede Zeile aus der zweiten Tabelle IS NULLkeine Präfixe enthält.

Eingabe bei Interesse:

CREATE TABLE t(i SERIAL,c text[]);

INSERT INTO t(c)
SELECT '{"Hello", "World"}'::text[]
UNION ALL SELECT  '{"Code", "Golf", "Is", "Cool"}'
UNION ALL SELECT  '{"1", "2", "3", "4", "5"}'
UNION ALL SELECT  '{"This", "test", "case", "is", "true"}'         
UNION ALL SELECT  '{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011","0110", "11001", "00110", "10011", "11000", "00111", "10010"}'
UNION ALL SELECT  '{"4", "42"}'
UNION ALL SELECT  '{"1", "2", "3", "34"}'                   
UNION ALL SELECT  '{"This", "test", "case", "is", "false", "t"}'
UNION ALL SELECT  '{"He", "said", "Hello"}'
UNION ALL SELECT  '{"0", "00", "00001"}'
UNION ALL SELECT  '{"Duplicate", "Duplicate", "Keys", "Keys"}';

BEARBEITEN:

SQL Server 2016+ Implementierung:

WITH y AS (SELECT *,z=value,r=ROW_NUMBER()OVER(ORDER BY 1/0) FROM #t CROSS APPLY STRING_SPLIT(c,','))
SELECT y.c, IIF(COUNT(u.z)>0,'F','T')
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z+'%' 
GROUP BY y.c;

LiveDemo

Hinweis: Es handelt sich um eine durch Kommas getrennte Liste, nicht um ein echtes Array. Aber die Grundidee ist die gleiche wie in PostgreSQL.

EDIT 2:

Tatsächlich WITH ORDINALITYkönnte ersetzt werden:

WITH y AS(SELECT *,ROW_NUMBER()OVER()r FROM t,LATERAL unnest(c)z)
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

SqlFiddleDemo

Brachylog , 8 Bytes

¬(⊇pa₀ᵈ)

Probieren Sie es online!

Ausgaben durch Prädikat Erfolg / Misserfolg. Nimmt mehr als 60 Sekunden für den letzten wahrheitsgemäßen Testfall in Anspruch ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] , übergibt ihn jedoch schnell mit einem hinzugefügten Byte , wodurch eine große Anzahl von Möglichkeiten beseitigt wird, die früher als das Programm ( Ċvor dem Prüfen von Permutationen und nicht ᵈnach dem Prüfen von Permutationen) auftreten, um die Länge der Unterliste auf zu begrenzen zwei).

¬(     )    It cannot be shown that
   p        a permutation of
  ⊇         a sublist of the input
      ᵈ     is a pair of values [A,B] such that
    a₀      A is a prefix of B.

Weniger trivial 9-Byte - Varianten als ¬(⊇Ċpa₀ᵈ)der Lauf in angemessener Zeit sind ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ)und ¬(⊇oa₀ᵈ¹).

Perl 6 , 24 Bytes

{.all.starts-with(.one)}

Probieren Sie es online!

Wow, überraschend kurz bei Verwendung eines langen eingebauten.

Erläuterung

{                      }  # Anonymous code block taking a list
 .all                     # Do all of the strings
     .starts-with(    )   # Start with
                  .one    # Only one other string (i.e. itself)

Schläger, 70 Bytes

(λ(l)(andmap(λ(e)(not(ormap(curryr string-prefix? e)(remv e l))))l))

Python, 58-55 Bytes

lambda l:sum(0==a.find(b)for a in l for b in l)==len(l)

JavaScript (ES6), 52 54

Bearbeite 2 Bytes, die dank @Neil gespeichert wurden

a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

Prüfung

f=a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

O.textContent += 'OK: '+
[["Hello", "World"]                      
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]          
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", 
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a)) 

O.textContent += '\nKO: '+
[["4", "42"]                             
,["1", "2", "3", "34"]                   
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

<pre id=O></pre>

Mathematica 75 69 68 Bytes

Laut wie immer. Aber Martin B konnte den Code um 7 Bytes reduzieren.

Methode 1: Speichern der Ausgabe in einem Array

(68 Bytes)

f@a_:=!Or@@(Join@@Array[a~Drop~{#}~StringStartsQ~a[[#]]&,Length@a])

f@{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", "0110", "11001", "00110", "10011", "11000", "00111", "10010"}

Wahr

f@{"He", "said", "Hello"}

Falsch

Methode 2: Speichern der Ausgabe in a List

(69 Bytes)

f@a_:=!Or@@Flatten[a~Drop~{#}~StringStartsQ~a[[#]]&/@Range@Length@a]

Mathematica, 41 Bytes

!Or@@StringStartsQ@@@Reverse@Sort@#~Subsets~{2}&

APL (Dyalog Unicode) , 13 Byte ^SBCS

-2 Bytes:

≢=∘≢∘⍸∘.(⊃⍷)⍨

Probieren Sie es online!

Erläuterung:

≢=∘≢∘⍸∘.(⊃⍷)⍨  ⍝ Monadic function train
         ⍷     ⍝ "Find": Convert the right argument into a boolean vector,
               ⍝ where ones correspond to instances of the left argument
        ⊃     ⍝ Take the first item of the above vector (i.e., only prefixes)
     ∘.(  )⍨  ⍝ Commutative outer product: take the above function and apply
              ⍝ it for each possible pair of elements in the input
              ⍝ If the input is a prefix code, the above should have a number of ones
              ⍝ equal to the length of the input (i.e., each item is a prefix of only itself)
              ⍝ To test this...
     ⍸        ⍝ Find the location of all ones in the above
   ≢∘         ⍝ Take the length of the above
≢=∘           ⍝ Compare to the length of the input

J , 17 Bytes

#=1#.1#.{.@E.&>/~

Probieren Sie es online!

Hinweis: Ich habe dies tatsächlich geschrieben, bevor ich mir die APL-Antwort angesehen habe, um mich ihr ohne Vorurteile zu nähern. Es stellt sich heraus, dass die Ansätze fast identisch sind, was interessant ist. Ich denke, das ist die natürliche "Array thinknig" -Lösung

Boxed Input nehmen, da die Strings ungleich lang sind.

Erstellen Sie eine Selbstfunktionstabelle /~für jedes Element, das mit jedem Element gepaart ist, und prüfen Sie, ob am Anfang eine Übereinstimmung vorliegt{.@E. . Dadurch wird eine Matrix mit 1: 0-Ergebnissen erstellt.

Summiere es zweimal 1#.1#., um eine einzelne Zahl zu erhalten, die "alle in der Matrix" darstellt, und überprüfe, ob diese Zahl der Länge der Eingabe entspricht#= . Wenn ja, sind die einzigen Präfix-Übereinstimmungen Selbst-Übereinstimmungen, dh wir haben einen Präfix-Code.

Sortierlösung, 18 Bytes

0=1#.2{.@E.&>/\/:~

Versuchen Sie einen anderen Ansatz. Diese Lösung sortiert und betrachtet benachbarte Paare.

Probieren Sie es online!

R , 48 Bytes

function(s)sum(outer(s,s,startsWith))==length(s)

Probieren Sie es online!

Erläuterung: outer(s,s,startsWith)Gibt eine Matrix von Logiken aus, die prüfen, ob s[i]ein Präfix von ist s[j]. Wenn ses sich um einen Präfixcode handelt, length(s)enthält das Ergebnis genau WAHRE Elemente, die den diagonalen Elementen entsprechen ( s[i]ein Präfix für sich selbst).

Pyth - 13 12 Bytes

!ssmm}d._k-Q

Probieren Sie es hier online aus .

Ruby, 48 Bytes

Verwendet Argumente als Eingabe und stdout als Ausgabe.

p !$*.map{a,*b=$*.rotate!
a.start_with? *b}.any?

Scala, 71 Bytes

(s:Seq[String])=>(for{x<-s;y<-s}yield x!=y&&x.startsWith(y)).forall(!_)

Schläger 130 Bytes

(define g #t)(for((n(length l)))(for((i(length l))#:unless(= i n))(when(string-prefix?(list-ref l i)(list-ref l n))(set! g #f))))g

Ungolfed:

(define(f l)
  (define g #t)
  (for ((n (length l)))
    (for ((i (length l)) #:unless (= i n))
      (when (string-prefix? (list-ref l i) (list-ref l n))
        (set! g #f))))g)

Testen:

(f [list "Hello" "World"])             
(f [list "Code" "Golf" "Is" "Cool"])
(f [list "1" "2" "3" "4" "5"])
(f [list "This" "test" "case" "is" "true"])          
(f [list "111" "010" "000" "1101" "1010" "1000" "0111" "0010" "1011" 
         "0110" "11001" "00110" "10011" "11000" "00111" "10010"])

(f [list "4" "42"])                             
(f [list "1" "2" "3" "34"])                   
(f [list "This" "test" "case" "is" "false" "t"])
(f [list "He" "said" "Hello"])
(f [list "0" "00" "00001"])
(f [list "Duplicate" "Duplicate" "Keys" "Keys"])

Ausgabe:

#t
#t
#t
#t
#t
#f
#f
#f
#f
#f
#f

C (gcc) 93 Bytes

p(r,e,f,i,x)char**r;{for(f=i=0;i<e;++i)for(x=0;x<e;++x)f|=x!=i&&strstr(r[i],r[x])==r[i];r=f;}

Probieren Sie es online!

Einfache double for-Schleife, mit der strstr(a,b)==anach Präferenzen gesucht wird. Hauptsächlich hinzugefügt, da es noch keine C-Antwort zu geben scheint.

05AB1E , 13 Bytes

2.ÆDí«ε`Å?}O_

Zu lange. Anfangs hatte ich eine 9-Byte-Lösung, die jedoch für den Testfall mit duplizierten Schlüsseln fehlgeschlagen ist.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

2.Æ             # Get all combinations of two elements from the (implicit) input-list
   Dí           # Duplicate and reverse each pair
     «          # Merge the lists of pairs together
      ε         # Map each pair to:
       `        #  Push both strings to the stack
        Å?      #  And check if the first starts with the second
          }O    # After the map: sum to count all truthy values
            _   # And convert it to truthy if it's 0 or falsey if it's any other integer
                # (which is output implicitly as result)

Japt , 8 Bytes

á2 ËrbÃe

Versuch es

á2 ËrbÃe     :Implicit input of array
á2           :Permutations of length 2
   Ë         :Map each pair
    r        :  Reduce by
     b       :  Get the index of the second in the first - 0 (falsey) if it's a prefix
      Ã      :End map
       e     :All truthy (-1 or >0)

C # (Visual C # Interactive Compiler) , 70 Byte

l=>!l.Any(x=>l.Where((y,i)=>l.IndexOf(x)!=i).Any(z=>z.StartsWith(x)));

Probieren Sie es online!

Stax , 6 Bytes

å·↑↑¶Ω

Führen Sie es aus und debuggen Sie es

Dies erzeugt für die Wahrheit einen Wert ungleich Null.

Die allgemeine Idee besteht darin, jedes Zeichenfolgenpaar in der Eingabe zu berücksichtigen. Wenn der Teilzeichenfolgenindex einer in der anderen jemals Null ist, ist dies kein gültiger Präfixcode. In stax ergibt sich der Index einer nicht vorhandenen Teilzeichenfolge-1 . Auf diese Weise können alle paarweisen Teilzeichenfolgenindizes miteinander multipliziert werden.

Dies ist derselbe Algorithmus wie die Pyth-Lösung von isaacg, aber ich habe ihn unabhängig entwickelt.