情報理論では、「プレフィックスコード」とは、どのキーも別のキーのプレフィックスではない辞書です。言い換えれば、これは、文字列が他の文字列で始まらないことを意味します。

たとえば、{"9", "55"}はプレフィックスコードですが、そうで{"5", "9", "55"}はありません。

これの最大の利点は、エンコードされたテキストを区切り文字なしで書き留めることができ、一意に解読できることです。これは、常に最適なプレフィックスコードを生成するHuffmanコーディングなどの圧縮アルゴリズムに現れます。

タスクは簡単です。文字列のリストが与えられたら、それが有効なプレフィックスコードかどうかを判断します。

あなたの入力：

• 妥当な形式の文字列のリストになります。

• 印刷可能なASCII文字列のみが含まれます。

• 空の文字列は含まれません。

出力は、真/偽の値になります。有効なプレフィックスコードの場合はTruthy、そうでない場合はfalseyです。

真のテストケースを次に示します。

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

いくつかの誤ったテストケースを次に示します。

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

これはコードゴルフなので、標準の抜け穴が適用され、バイト単位の最短回答が勝ちます。

Pyth、8バイト

.AxM.PQ2

テストスイート

入力の2つの要素の順列すべてを取得し、それぞれをもう一方の文字列のインデックス（プレフィックスは0）にマップし、すべての結果が真実（ゼロ以外）かどうかを返します。

Haskell、37バイト

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

の各要素xはl、プレフィックスであるすべての要素に対して1回繰り返されます。これは、プレフィックスのないリストに対して1回だけであり、元のリストを提供します。prefixプロパティはx、で両方のリストを圧縮することでチェックされます。これにより、の長さを超える要素が切り取られますx。

Java（登録商標）、128 127 126 125 124 121バイト

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

非ゴルフ

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

出力

[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バイト

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

の各要素aに対してl、関数a.findはa入力文字列で最初に出現するインデックスを検索-1し、不在を与えます。したがって、0プレフィックスを示します。接頭辞のないリストでは、この関数をマッピングすると単一の0、aそれ自体に対してれます。関数は、これがすべての場合に当てはまることをチェックしaます。

51バイト：

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

交換 ~ASCIIコード128以上の文字にます。

の各要素aに対してl、その接頭辞である各要素のコピーが含まれます。プレフィックスのないリストの場合、そのような要素はaそれ自体だけなので、これにより元のリストが得られます。

CJam、14バイト

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

テストスイート。

説明

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バイト

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

すべてのUTF-8文字の文字列配列を処理する私の以前のソリューション：

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

回避できた JSON.stringifyチャレンジでは印刷可能なASCII文字のみが指定され、。

テスト

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バイト

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

これにはいくつかの部分があります。

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

2つのリストが等しい場合、要素はそれ自体のプレフィックスのみであり、有効です。

網膜、19バイト

バイトカウントはISO 8859-1エンコードを前提としています。

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

入力は改行で区切る必要があります。出力は0偽物と1真実のためです。

オンラインでお試しください！（代わりに、スペースで区切られた複数のテストケースをサポートするために少し変更されています。）

説明

O`.+

入力の行を並べ替えます。接頭辞が存在する場合、それを含む文字列の直前に配置されます。

Mm1`^(.+)¶\1

M次の行の先頭にもある完全な行と一致させてください（）。は、行の先頭に一致するmように複数行モードをアクティブにし、出力がまたはになるように、最大​​で1つの一致のみをカウントするようにします。^101

0

スワップに0し、1その結果に、我々は多くのカウント0秒。

Java、97バイト

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

@ Marv's answerにあるほとんどのトリックを使用しますが、foreachループと文字列参照の等価性も使用します。

縮小されていない：

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

先ほど言ったように、これは文字列参照の等価性を使用していることに注意してください。つまり、文字列のインターンが原因でコードが奇妙に動作する可能性があるということです。このコマンドは、コマンドラインから渡された引数を使用する場合、およびコマンドラインから読み取ったものを使用する場合にも機能します。ただし、テストする値をハードコーディングする場合は、手動でStringコンストラクターを呼び出して、強制的にインターンが発生しないようにする必要があります。

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バイト

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

出力：

今回はライブデモはありません。http://sqlfiddle.comは9.3のみをサポートし、このデモを実行するには9.4が必要です。

使い方：

1. 文字列配列を番号で分割して名前を付ける y
2. すべてを取得
3. LEFT OUTER JOIN同じi（id）に基づくが、oridinalプレフィックスで始まる異なる派生テーブルにy.z LIKE u.z||'%'
4. c（初期配列）および使用に基づいて結果をグループ化するEVERYグループ化し、グループ化機能ます。2番目のテーブルのすべての行IS NULLは、プレフィックスがないことを意味します。

誰かが興味を持っている場合に入力：

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

編集：

SQL Server 2016+ 実装：

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

注：これは、実際の配列ではなく、コンマ区切りのリストです。しかし、主なアイデアはPostgreSQLです。

編集2：

実際WITH ORDINALITYに交換することができます：

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バイト

¬(⊇pa₀ᵈ)

オンラインでお試しください！

述語の成功/失敗による出力。最後の真実のテストケースで60秒以上かかります["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] が、追加のバイトを使用してすぐに渡します。これにより、プログラムが他の方法よりも早く多くの可能性を排除します（Ċ置換ᵈをチェックした後ではなく、置換をチェックする前に、サブリストの長さを制限します二）。

¬(     )    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.

あまり些細な9バイトは、より変異体で¬(⊇Ċpa₀ᵈ)あり、合理的な時間内にその実行¬(⊇o₁a₀ᵈ)、¬(⊇o↔a₀ᵈ)と¬(⊇oa₀ᵈ¹)。

Perl 6、24バイト

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

オンラインでお試しください！

うわー、長い組み込みを使用しながら驚くほど短い。

説明

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

ラケット、70バイト

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

Python、58 55バイト

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

JavaScript（ES6）、52 54

2バイト保存されたthx @Neilを編集

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

テスト

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バイト

いつものように雄弁。しかし、Martin Bはコードを7バイト減らすことができました。

方法1：出力を Array

（68バイト）

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

本当

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

偽

方法2：出力を保存する List

（69バイト）

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

Mathematica、41バイト

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

APL（Dyalog Unicode）、13 バイト ^SBCS

-2バイト：

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

オンラインでお試しください！

説明：

≢=∘≢∘⍸∘.(⊃⍷)⍨  ⍝ 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バイト

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

オンラインでお試しください！

注：実際にこれを書いたのは、APLの回答を見る前に、偏りなくアプローチするためです。アプローチがほぼ同じであることが判明しました。これは興味深いことです。これは自然な「配列思考」ソリューションだと思います

文字列の長さが等しくないため、ボックス入力を使用してください。

/~各要素とペアになっている各要素の自己機能テーブルを作成し、開始時に一致するかどうかを確認し{.@E.ます。これにより、1-0の結果のマトリックスが生成されます。

それを2回合計して1#.1#.「マトリックス内のすべて1」を表す単一の数値を取得し、その数値が入力の長さと同じかどうかを確認します#=。そうである場合、唯一のプレフィックス一致は自己一致です。つまり、プレフィックスコードがあります。

ソートソリューション、18バイト

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

別のアプローチを試みます。このソリューションは、隣接するペアをソートして調べます。

オンラインでお試しください！

R、48バイト

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

オンラインでお試しください！

説明：が接頭辞であるouter(s,s,startsWith)かどうかをチェックする論理の行列を出力します。がプレフィックスコードである場合、結果には、対角要素に対応する正確なTRUE要素があります（それ自体のプレフィックスです）。s[i]s[j]slength(s)s[i]

Pyth- 13 12バイト

!ssmm}d._k-Q

こちらからオンラインでお試しください。

ルビー、48バイト

入力として引数を使用し、出力として標準出力を使用します。

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

Scala、71バイト

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

ラケット130バイト

(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

ゴルフをしていない：

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

テスト：

(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"])

出力：

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

C（gcc）、93バイト

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

オンラインでお試しください！

strstr(a,b)==apreficesのチェックに使用する単純なdouble forループ。主に追加されたのは、まだCの回答がないようです。

05AB1E、13 バイト

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

あまりにも長い..最初は9バイトのソリューションがありましたが、重複したキーテストケースでは失敗しました。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

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バイト

á2 ËrbÃe

それを試してみてください

á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バイト

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

オンラインでお試しください！

スタックス、6 バイト

å·↑↑¶Ω

実行してデバッグする

これにより、真偽の非ゼロが生成されます。

一般的な考え方は、入力内の文字列のすべてのペアを考慮することです。一方のサブストリングインデックスがゼロである場合、それは有効なプレフィックスコードではありません。staxでは、存在しない部分文字列のインデックスはになります-1。このようにして、すべてのペアワイズ部分文字列インデックスを乗算できます。

これはisaacgのpythソリューションと同じアルゴリズムですが、私は独自に開発しました。