정보 이론에서 "접두사 코드"는 다른 키의 접두사가없는 사전입니다. 다시 말해, 이는 어떤 문자열도 다른 문자열로 시작하지 않음을 의미합니다.

예를 들어 {"9", "55"}접두사 코드이지만 {"5", "9", "55"}그렇지 않습니다.

이것의 가장 큰 장점은 인코딩 된 텍스트를 구분 기호없이 기록 할 수 있으며 여전히 고유하게 해독 할 수 있다는 것입니다. 이것은 항상 최적의 접두사 코드를 생성하는 Huffman coding 과 같은 압축 알고리즘에 나타납니다 .

당신의 작업은 간단합니다 : 문자열 목록이 주어지면 유효한 접두사 코드인지 여부를 결정하십시오.

입력 :

• 합리적인 형식 의 문자열 목록이 됩니다 .

• 인쇄 가능한 ASCII 문자열 만 포함합니다.

• 빈 문자열을 포함하지 않습니다.

당신의 결과는 진실 / 거짓 값 이 될 것입니다 : 유효한 접두사 코드 인 경우 Truthy, 그렇지 않은 경우 false.

실제 테스트 사례는 다음과 같습니다.

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

테스트 스위트

입력의 두 요소 순열을 모두 취하고 각각을 다른 문자열의 한 문자열의 색인에 맵핑하고 (접 두부의 경우 0) 모든 결과가 진실인지 여부를 리턴합니다 (0이 아님).

하스켈, 37 바이트

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

각 요소 x의 l원래 목록을 제공 접두사가없는 목록은 정확히 한 번만 인의 접두사가 있다고 모든 요소에 대해 한 번 반복한다. 접두사 속성은 두 목록을 모두 압축 x하여 길이를 초과하는 요소를 잘라냅니다 x.

자바 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

파이썬 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.

자바 스크립트 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>

하스켈, 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)

두 목록이 같으면 요소는 접두사 만 있고 유효합니다.

레티 나 , 19 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

입력은 라인 피드로 분리되어야합니다. 결과는 0허위와 1진실입니다.

온라인으로 사용해보십시오! (여러 개의 공백으로 구분 된 테스트 사례를 지원하도록 약간 수정되었습니다.)

설명

O`.+

입력에서 행을 정렬하십시오. 접두사가 있으면 접두사가 포함 된 문자열 바로 앞에 붙습니다.

Mm1`^(.+)¶\1

M다음 줄의 시작 부분에있는 완전한 줄 을 일치 시키십시오 ( ). 이 m되도록 여러 모드 활성화 ^일치 라인의 시작과 1보장하지만 우리는 출력이되도록 최대 하나의 일치를 계산하는 것이 0또는 1.

0

교환 0하고 1결과적으로 0s 의 수를 계산합니다 .

자바, 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;
}

내가 말했듯이 이것은 문자열 참조 평등을 사용합니다. 즉, 문자열 interning 으로 인해 코드가 이상하게 작동 할 수 있습니다 . 이 코드는 명령 행에서 전달 된 인수를 사용할 때와 명령 행에서 읽은 것을 사용할 때도 작동합니다. 테스트 할 값을 하드 코딩하려면 수동으로 문자열 생성자를 호출하여 강제로 인턴이 발생하지 않도록해야합니다.

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. 모든 y를 얻으십시오
3. LEFT OUTER JOIN접두사로 시작 하는 것과 동일한 i(id)를 기준으로 동일한 파생 테이블에oridinaly.z LIKE u.z||'%'
4. c(초기 배열)을 기준으로 결과를 EVERY그룹화 하고 그룹화 기능을 사용 합니다. 두 번째 테이블의 모든 행 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₀ᵈ¹).

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

파이썬, 58 55 바이트

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

자바 스크립트 (ES6), 52 54

thx @Neil으로 저장된 2 바이트 편집

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 : 출력을 a에 저장 List

(69 바이트)

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

수학, 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 답변을보기 전에 편견없이 접근하기 위해 이것을 썼습니다. 접근 방식이 거의 동일하다는 것이 밝혀졌습니다. 이것이 자연스러운 "array thinknig"솔루션 인 것 같습니다.

문자열 길이가 다르기 때문에 박스 입력을 사용하십시오.

/~각 요소와 쌍을 이루는 각 요소 의 자체 기능 테이블 을 작성 하고 시작시 일치하는 것이 있는지 확인하십시오 {.@E.. 1-0 결과의 행렬이 생성됩니다.

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 바이트

인수를 입력으로 사용하고 stdout을 출력으로 사용합니다.

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

스칼라, 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)==a선점을 확인하는 데 사용 되는 간단한 이중 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)));

온라인으로 사용해보십시오!

Stax , 6 바이트

å·↑↑¶Ω

실행 및 디버깅

이것은 진실을 위해 0이 아닌 것을 만들어냅니다.

일반적인 아이디어는 입력에서 모든 문자열 쌍을 고려하는 것입니다. 다른 하나의 부분 문자열 색인이 0이면 유효한 접두사 코드가 아닙니다. stax에서 존재하지 않는 부분 문자열의 색인은-1 입니다. 이런 식으로 모든 쌍별 부분 문자열 인덱스를 곱할 수 있습니다.

이것은 isaacg의 pyth 솔루션과 동일한 알고리즘이지만 독립적으로 개발했습니다.