Bilgi teorisinde "önek kodu", anahtarlardan hiçbirinin başka bir önek olmadığı bir sözlüktür. Başka bir deyişle, bu, hiçbir dizenin diğerinin hiçbiriyle başlamayacağı anlamına gelir.

Örneğin {"9", "55"}, bir önek kodudur, fakat {"5", "9", "55"}değildir.

Bunun en büyük avantajı, kodlanmış metnin aralarında bir ayırıcı olmadan yazılabilmesi ve yine de benzersiz bir şekilde deşifre edilebilir olmasıdır. Bu gibi sıkıştırma algoritmaları gösterir her zaman en uygun önek kodunu üreten Huffman kodlaması görülür .

Göreviniz basit: Dizelerin bir listesi verildiğinde, geçerli bir önek kodu olup olmadığını belirleyin.

Girişiniz:

• Herhangi bir makul formatta dizelerin bir listesi olacaktır .

• Yalnızca yazdırılabilir ASCII dizeleri içerecektir.

• Boş dizeler içermeyecek.

Çıktınız bir truthy / falsey değeri olacaktır: Geçerli bir önek kodu ise Truthy ve değilse falsey.

İşte bazı gerçek test durumları:

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

İşte bazı yanlış test durumları:

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

Bu kod-golf'dür, bu nedenle standart boşluklar uygulanır ve baytlarda en kısa sürede cevap verilir.

Pyth, 8 bayt

.AxM.PQ2

Test odası

Girişin tüm 2 eleman permütasyonunu alın, her birini diğerindeki bir dizginin indeksine eşleyin (önek için 0) ve tüm sonuçların kaba olup olmadığını (sıfır olmayan) döndürün.

Haskell, 37 bayt

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

Her eleman x , lönek içermeyen bir liste için tam olarak bir kez olan, öneki olduğu her öğe için bir kez tekrarlanır, orijinal liste verilir. Prefix özelliği, her iki listeyi de sıkıştırmak suretiyle kontrol edilir x, bu da elemanları uzunluğu keser x.

Java, 128 127 126 125 124 121 bayt

(Teşekkürler @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;
}

Çıktı

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

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

Her eleman aiçin l, fonksiyon giriş dizisindeki a.findilk olayın indeksini bulur a, bu -1da devamsızlık sağlar. Yani, 0bir ön eki gösterir. Öneksiz bir listede, bu işlevin eşlenmesi kendisi 0için yalnızca bir tane döndürür a. İşlev bunun her şey için geçerli olup olmadığını kontrol eder a.

51 bayt:

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

değiştirmek ~ASCII kod 128 veya daha yüksek olan bir karakterle .

Her öğe için ade lbir kopya bunun bir önek olduğu her element için dahildir. Önek içermeyen bir liste için, yalnızca bu öğenin akendisidir, bu nedenle orijinal liste verilir.

CJam, 14 bayt

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

Test odası.

açıklama

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 bayt

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

Tüm UTF-8 karakterlerinin dizge dizilerini işleyen önceki çözümüm:

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

Kaçınmayı başardım JSON.stringifyZorluk yalnızca yazdırılabilir ASCII karakterlerini belirttiğinden .

Ölçek

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 bayt

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

Bunun birkaç kısmı var:

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

İki liste eşitse, bir öğe yalnızca kendisinin ön ekidir ve geçerlidir.

Retina , 19 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Giriş satır besleme ile ayrılmalıdır. Çıktı 0sahtekarlık ve 1hakikat için.

Çevrimiçi deneyin! (Bunun yerine birden çok boşlukla ayrılmış test durumlarını desteklemek için hafifçe değiştirilmiş.)

açıklama

O`.+

Girişteki satırları sıralayın. Eğer bir önek varsa, doğrudan onu içeren bir dizgenin önüne çıkar.

Mm1`^(.+)¶\1

MBir sonraki satırın başında da bulunan tam bir satırı eşleştirmeye çalışın ( ). mÖyle ki satırlı modunu aktive ^maçlar hat başlangıçlar ve 1olmasını sağlar sadece çıkış olacak şekilde en az bir maç sayımı 0ya 1.

0

Değişmek 0ve 1sonuç olarak, 0s sayısını sayarız .

Java, 97 bayt

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'ın cevabında bulunan püf noktalarının çoğunu kullanır , fakat aynı zamanda foreach döngüsünü ve string referans eşitliğini kullanır.

Unminified:

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

Dediğim gibi, bunun string referans eşitliği kullandığına dikkat edin. Bu, String ınterning nedeniyle kodun tuhaf davranabileceği anlamına gelir . Kod, komut satırından iletilen argümanları kullanırken ve ayrıca komut satırından okunan bir şeyi kullanırken çalışır. Ancak, test edilecek değerleri kodlamak istiyorsanız, interning'i gerçekleştirmeye zorlamak için String yapıcısını elle çağırmanız gerekir:

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 bayt

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

Çıktı:

Bu sefer canlı demo yok. http://sqlfiddle.com sadece 9.3'ü destekliyor ve bu gösterimi yapmak için 9.4 gerekiyor.

Nasıl çalışır:

1. Dize dizisini sayı ile ayırın ve adlandırın y
2. Hepsini al
3. LEFT OUTER JOINaynı i(kimliği) temel alan aynı türetilmiş tabloya , ancak oridinalönekle başlayan farklıy.z LIKE u.z||'%'
4. c(İlk dizi) dayalı grup sonucu ve EVERYgruplama işlevini kullanın . İkinci tablodaki her satır IS NULLönek olmadığı anlamına gelir.

Birisi ilgileniyorsa giriş:

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

DÜZENLE:

SQL Server 2016+ uygulama:

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

Not: Virgülle ayrılmış listedir, gerçek dizi değildir. Ancak ana fikir, ile aynıdır PostgreSQL.

EDIT 2:

Aslında WITH ORDINALITYdeğiştirilebilir:

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 bayt

¬(⊇pa₀ᵈ)

Çevrimiçi deneyin!

Tahmini başarı / başarısızlık yoluyla çıktılar. Son deneme testinde 60 saniyeden fazla zaman alır ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] ancak hızlı bir şekilde programın daha Ċönce ᵈyapabileceğinden çok daha fazla olasılıkları ortadan kaldıran ek bir baytla geçer (alt listenin uzunluğunu sınırlamak için izinleri kontrol ettikten sonra izinleri kontrol etmeden önce) iki).

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

Az önemsiz 9 bayt daha varyantları ¬(⊇Ċpa₀ᵈ)olan makul bir süre içinde hangi çalışma ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ)ve ¬(⊇oa₀ᵈ¹).

Perl 6 , 24 bayt

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

Çevrimiçi deneyin!

Wow, uzun bir dahili kullanırken şaşırtıcı derecede kısa.

açıklama

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

Raket, 70 bayt

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

Python, 58 55 bayt

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

JavaScript (ES6), 52 54

2 bayt düzenle kaydedildi thx @Neil

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

Ölçek

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 bayt

Her zamanki gibi konuşkan. Ancak Martin B kodu 7 bayt azaltabildi.

Yöntem 1: çıktıyı bir saklamak Array

(68 bayt)

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

Doğru

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

Yanlış

Yöntem 2: çıktıyı bir saklamak List

(69 bayt)

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

Mathematica, 41 bayt

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

APL (Dyalog Unicode) , 13 bayt ^SBCS

-2 bayt:

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Not: Bunu aslında APL'nin cevabına bakmadan önce, önyargısız yaklaşmak için yazdım. Yaklaşımların neredeyse aynı olduğu ortaya çıktı, bu ilginç. Sanırım bu doğal bir "dizi düşünme" çözümü.

Dizeleri eşit olmayan uzunlukta olduğundan kutulu girdi alın.

/~Her bir elemanla eşleştirilmiş her bir elemanın kendi kendine işlev tablosu yarat ve başlangıçta bir eşleşme olup olmadığına bak.{.@E. . Bu 1-0 sonuçlu bir matris üretecektir.

"Matristeki 1#.1#.herkesi" temsil eden tek bir numara almak için iki kez toplayın ve bu sayının girişin uzunluğu ile aynı olup olmadığını kontrol edin.#= . Öyleyse, yalnızca önek eşleşmeleri kendi kendine eşleşir, yani bir önek kodumuz vardır.

sıralama çözümü, 18 bayt

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

Farklı yaklaşımlarda teşebbüs. Bu çözüm bitişik çiftleri sıralar ve inceler.

Çevrimiçi deneyin!

R , 48 bayt

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

Çevrimiçi deneyin!

Açıklama: bir ön ek outer(s,s,startsWith)olup olmadığını kontrol s[i]eden bir mantık matrisi çıkarır s[j]. Eğer sbir ön ek kod, daha sonra tam olarak orada length(s)çapraz elemanlara sonucu TRUE elemanları ( s[i]kendi başına bir öneki).

Pyth - 13 12 bayt

!ssmm}d._k-Q

Burada çevrimiçi deneyin .

Ruby, 48 bayt

Argümanları giriş, stdout işlevi olarak kullanır.

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

Scala, 71 bayt

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

Raket 130 bayt

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

Test yapmak:

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

Çıktı:

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

C (gcc) , 93 bayt

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

Çevrimiçi deneyin!

strstr(a,b)==aTercihleri ​​kontrol etmek için döngü için basit çift . Temelde henüz bir C cevabı görünmediğinden dolayı eklendi

05AB1E , 13 bayt

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

Çok uzun .. Başlangıçta 9 baytlık bir çözüme ulaştım, ancak kopyalanan anahtar sınama durumu için başarısız oldu.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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 bayt

á2 ËrbÃe

Dene

á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 # Etkileşimli Derleyici) , 70 bayt

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

Çevrimiçi deneyin!

Stax , 6 bayt

å·↑↑¶Ω

Koş ve hata ayıkla

Bu, truthy için sıfır olmayan üretir.

Genel fikir, girdideki her bir çift çifti dikkate almaktır. Eğer birinin diğerinin alt dizini sıfır ise, o zaman geçerli bir önek kodu değildir. Stax'ta, mevcut olmayan bir alt dizinin endeksi-1 . Bu şekilde, tüm çift tabanlı alt dize endeksleri birlikte çoğaltılabilir.

Bu isaacg'ın pyth çözümü ile aynı algoritma, ama ben bağımsız olarak geliştirdim.