Trong lý thuyết thông tin, "mã tiền tố" là một từ điển trong đó không có khóa nào là tiền tố của người khác. Nói cách khác, điều này có nghĩa là không có chuỗi nào bắt đầu bằng bất kỳ chuỗi nào khác.

Ví dụ, {"9", "55"}là một mã tiền tố, nhưng {"5", "9", "55"}không phải.

Ưu điểm lớn nhất của điều này là văn bản được mã hóa có thể được viết ra mà không có dấu phân cách giữa chúng và nó vẫn sẽ được giải mã duy nhất. Điều này xuất hiện trong các thuật toán nén như mã hóa Huffman , vốn luôn tạo mã tiền tố tối ưu.

Nhiệm vụ của bạn rất đơn giản: Đưa ra một danh sách các chuỗi, xác định xem đó có phải là mã tiền tố hợp lệ hay không.

Đầu vào của bạn:

• Sẽ là một danh sách các chuỗi trong bất kỳ định dạng hợp lý .

• Sẽ chỉ chứa các chuỗi ASCII có thể in.

• Sẽ không chứa bất kỳ chuỗi trống nào.

Đầu ra của bạn sẽ là giá trị trung thực / falsey : Sự thật nếu đó là mã tiền tố hợp lệ và falsey nếu không.

Dưới đây là một số trường hợp thử nghiệm thực sự:

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

Dưới đây là một số trường hợp thử nghiệm sai:

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

Đây là môn đánh gôn, vì vậy các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất bằng byte thắng.

Bình thường, 8 byte

.AxM.PQ2

Bộ kiểm tra

Lấy tất cả 2 hoán vị phần tử của đầu vào, ánh xạ từng phần vào chỉ mục của một chuỗi trong chuỗi khác (0 cho tiền tố) và trả về việc tất cả các kết quả có phải là sự thật (khác không).

Haskell, 37 byte

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

Mỗi phần tử xcủa lđược lặp lại một lần cho mỗi phần tử mà nó là tiền tố, chính xác là một lần cho danh sách không có tiền tố, đưa ra danh sách ban đầu. Thuộc tính tiền tố được kiểm tra bằng cách nén cả hai danh sách x, cắt bỏ các phần tử vượt quá độ dài x.

Java, 128 127 126 125 124 121 byte

(Cảm ơn @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;}

Bị đánh cắp

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

Đầu ra

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

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

Đối với mỗi phần tử acủa l, hàm a.findtìm thấy chỉ mục của lần xuất hiện đầu tiên atrong chuỗi đầu vào, -1cho sự vắng mặt. Vì vậy, 0chỉ ra một tiền tố. Trong danh sách prefix-miễn phí, lập bản đồ chức năng này chỉ trả về một single 0cho abản thân. Các chức năng kiểm tra rằng đây là trường hợp cho mọi a.

51 byte:

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

Thay thế ~bằng một ký tự bằng mã ASCII 128 trở lên.

Đối với mỗi phần tử atrong l, một bản sao được bao gồm cho mỗi phần tử là tiền tố của phần tử đó. Đối với danh sách không có tiền tố, phần tử duy nhất như vậy là achính nó, vì vậy phần này cung cấp danh sách gốc.

CJam, 14 byte

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

Bộ thử nghiệm.

Giải trình

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 byte

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

Giải pháp trước đây của tôi, đã xử lý các mảng chuỗi của tất cả các ký tự UTF-8:

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

Tôi đã có thể tránh JSON.stringifyvì thử thách chỉ định các ký tự ASCII có thể in được.

Kiểm tra

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 byte

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

Điều này có một vài phần:

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

Nếu hai danh sách bằng nhau, thì một phần tử chỉ là tiền tố của chính nó và nó hợp lệ.

Võng mạc , 19 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Đầu vào phải được phân tách theo dòng. Đầu ra là 0cho giả và1 cho sự thật.

Hãy thử trực tuyến!(Thay đổi một chút để hỗ trợ nhiều trường hợp thử nghiệm được phân tách bằng không gian thay thế.)

Giải trình

O`.+

Sắp xếp các dòng trong đầu vào. Nếu một tiền tố tồn tại, nó sẽ kết thúc trực tiếp trước một chuỗi chứa nó.

Mm1`^(.+)¶\1

Cố gắng khớp ( M) một dòng hoàn chỉnh cũng được tìm thấy ở đầu dòng tiếp theo. Các mkích hoạt chế độ multiline mà ^khởi đầu trận đấu dòng và 1đảm bảo rằng ta chỉ tính nhiều nhất một trận đấu như vậy mà đầu ra là 0hay 1.

0

Để trao đổi 0và 1trong kết quả, chúng tôi đếm số 0s.

Java, 97 byte

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

Sử dụng hầu hết các thủ thuật được tìm thấy trong câu trả lời của @ Marv , nhưng cũng sử dụng vòng lặp foreach và đẳng thức tham chiếu chuỗi.

Chưa hoàn thành:

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

Lưu ý rằng, như tôi đã nói, điều này sử dụng đẳng thức tham chiếu chuỗi. Điều đó không có nghĩa là mã có thể hành xử kỳ quặc do thực hiện Chuỗi . Mã này hoạt động khi sử dụng các đối số được truyền từ dòng lệnh và cả khi sử dụng một cái gì đó đọc từ dòng lệnh. Tuy nhiên, nếu bạn muốn mã hóa các giá trị để kiểm tra, bạn cần gọi thủ công Trình xây dựng chuỗi để buộc thực hiện không xảy ra:

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 byte

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

Đầu ra:

Không có bản demo trực tiếp lần này. http://sqlfiddle.com chỉ hỗ trợ 9.3 và để chạy bản demo 9.4 này là bắt buộc.

Làm thế nào nó hoạt động:

1. Chia mảng chuỗi với số và đặt tên cho nó y
2. Nhận tất cả y
3. LEFT OUTER JOIN vào cùng một bảng dẫn xuất dựa trên cùng i (id), nhưng khác nhauoridinal với bắt đầu bằng tiền tốy.z LIKE u.z||'%'
4. Kết quả nhóm dựa trên c(mảng ban đầu) và sử dụng EVERYchức năng nhóm. Nếu mỗi hàng từ bảng thứ haiIS NULL điều đó có nghĩa là không có tiền tố.

Đầu vào nếu ai đó quan tâm:

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

CHỈNH SỬA:

SQL Server 2016+ thực hiện:

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

Lưu ý: Đây là danh sách được phân tách bằng dấu phẩy, không phải là mảng thực. Nhưng ý chính là giống như trong PostgreSQL.

EDIT 2:

Thực tế WITH ORDINALITYcó thể được thay thế:

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 byte

¬(⊇pa₀ᵈ)

Hãy thử trực tuyến!

Đầu ra thông qua thành công / thất bại vị ngữ. Mất hơn 60 giây trong trường hợp thử nghiệm trung thực cuối cùng ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] nhưng nhanh chóng vượt qua nó bằng một byte được thêm vào , loại bỏ một số lượng lớn khả năng sớm hơn chương trình ( Ċtrước khi kiểm tra hoán vị thay vì ᵈsau khi kiểm tra hoán vị, để giới hạn độ dài của danh sách con hai).

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

Ít tầm thường 9 byte biến thể hơn ¬(⊇Ċpa₀ᵈ)mà chạy trong thời gian hợp lý là ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ), và ¬(⊇oa₀ᵈ¹).

Perl 6 , 24 byte

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

Hãy thử trực tuyến!

Wow, đáng ngạc nhiên ngắn trong khi sử dụng một tích hợp dài.

Giải trình

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

Vợt, 70 byte

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

Python, 58 55 byte

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

JavaScript (ES6), 52 54

Chỉnh sửa 2 byte đã lưu thx @Neil

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

Kiểm tra

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>

Toán học 75 69 68 byte

Vô tư như thường lệ. Nhưng Martin B đã có thể giảm mã xuống 7 byte.

Phương pháp 1: Lưu trữ đầu ra trong một Array

(68 byte)

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

Thật

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

Sai

Phương pháp 2: Lưu trữ đầu ra trong một List

(69 byte)

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

Toán học, 41 byte

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

APL (Dyalog Unicode) , 13 byte ^SBCS

-2 byte:

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

Hãy thử trực tuyến!

Giải trình:

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

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

Hãy thử trực tuyến!

Lưu ý: Tôi thực sự đã viết điều này trước khi xem câu trả lời của APL, để tiếp cận nó mà không thiên vị. Hóa ra các cách tiếp cận gần như giống hệt nhau, đó là điều thú vị. Tôi đoán đây là giải pháp "mảng thinknig" tự nhiên

Lấy đầu vào đóng hộp vì các chuỗi có độ dài không bằng nhau.

Tạo bảng tự chức năng /~của từng yếu tố được ghép nối với từng yếu tố và xem có bắt đầu khớp không{.@E. . Điều này sẽ tạo ra một ma trận kết quả 1-0.

Tính tổng hai lần 1#.1#. để có được một số duy nhất đại diện cho "tất cả các số trong ma trận" và xem liệu số đó có giống với độ dài của đầu vào không#= . Nếu đúng, chỉ có tiền tố phù hợp là tự khớp, tức là chúng ta có mã tiền tố.

giải pháp sắp xếp, 18 byte

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

Cố gắng ở cách tiếp cận khác nhau. Giải pháp này sắp xếp và xem xét các cặp liền kề.

Hãy thử trực tuyến!

R , 48 byte

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

Hãy thử trực tuyến!

Giải thích: đưa outer(s,s,startsWith)ra một ma trận logic kiểm tra xem có phải s[i]là tiền tố của không s[j]. Nếu slà mã tiền tố, thì có chính xác length(s)các phần tử TRUE, tương ứng với các phần tử đường chéo ( s[i]là tiền tố của chính nó).

Pyth - 13 12 byte

!ssmm}d._k-Q

Hãy thử trực tuyến tại đây .

Ruby, 48 byte

Sử dụng đối số làm đầu vào và thiết bị xuất chuẩn làm đầu ra.

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

Scala, 71 byte

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

Vợt 130 byte

(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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

C (gcc) , 93 byte

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

Hãy thử trực tuyến!

Đôi đơn giản cho vòng lặp sử dụng strstr(a,b)==ađể kiểm tra tiền đề. Chủ yếu được thêm vào vì dường như chưa có câu trả lời C.

05AB1E , 13 byte

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

Quá lâu .. Ban đầu tôi có một giải pháp 9 byte, nhưng nó đã thất bại cho trường hợp kiểm tra khóa trùng lặp.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

á2 ËrbÃe

Thử nó

á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 # (Trình biên dịch tương tác Visual C #) , 70 byte

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

Hãy thử trực tuyến!

Stax , 6 byte

å·↑↑¶Ω

Chạy và gỡ lỗi nó

Điều này tạo ra khác không cho sự thật.

Ý tưởng chung là xem xét mọi cặp chuỗi trong đầu vào. Nếu chỉ số chuỗi con của một trong số kia là 0, thì đó không phải là mã tiền tố hợp lệ. Trong stax, chỉ số của một chuỗi con không tồn tại-1 . Bằng cách này, tất cả các chỉ số chuỗi con cặp khôn ngoan có thể được nhân với nhau.

Đây là thuật toán tương tự như giải pháp thứ ba của isaacg, nhưng tôi đã phát triển nó một cách độc lập.