ในทฤษฎีข้อมูล "รหัสคำนำหน้า" เป็นพจนานุกรมที่ไม่มีคีย์ใดเป็นคำนำหน้าของอีก กล่าวอีกนัยหนึ่งนี่หมายความว่าไม่มีสตริงใดเริ่มต้นด้วยสตริงอื่นใด

ตัวอย่างเช่น{"9", "55"}เป็นรหัสคำนำหน้า แต่{"5", "9", "55"}ไม่ใช่

ข้อได้เปรียบที่ใหญ่ที่สุดของเรื่องนี้คือข้อความที่เข้ารหัสสามารถเขียนลงโดยไม่มีตัวคั่นระหว่างพวกเขาและมันจะยังสามารถถอดรหัสได้โดยไม่ซ้ำกัน สิ่งนี้แสดงให้เห็นในอัลกอริธึมการบีบอัดเช่นการเข้ารหัส Huffmanซึ่งจะสร้างรหัสคำนำหน้าที่ดีที่สุดเสมอ

งานของคุณง่าย: ได้รับรายการของสตริงตรวจสอบว่ามันเป็นรหัสคำนำหน้าที่ถูกต้องหรือไม่

ข้อมูลของคุณ:

• จะมีรายการของสตริงในรูปแบบที่เหมาะสม

• จะมีสตริง ASCII ที่พิมพ์ได้เท่านั้น

• จะไม่มีสตริงว่างเปล่า

ผลลัพธ์ของคุณจะเป็นค่าจริง / เท็จ : ความจริงถ้ามันเป็นรหัสคำนำหน้าที่ถูกต้องและเป็นเท็จถ้ามันไม่

ต่อไปนี้เป็นกรณีทดสอบจริง:

["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จะถูกทำซ้ำหนึ่งครั้งสำหรับทุกองค์ประกอบที่เป็นคำนำหน้าของซึ่งเป็นเพียงครั้งเดียวสำหรับรายการที่ปราศจากคำนำหน้าให้รายการเดิม คุณสมบัติคำนำหน้าจะถูกตรวจสอบโดยซิปทั้งสองรายการด้วยซึ่งตัดองค์ประกอบเกินความยาวของxx

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

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

เอาท์พุต

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

หากทั้งสองรายการมีค่าเท่ากันองค์ประกอบนั้นจะเป็นเพียงส่วนนำหน้าของตัวเองเท่านั้นและจะใช้ได้

เรติน่า 19 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

อินพุตควรคั่นด้วยตัวป้อนบรรทัด ผลผลิตเป็น0เท็จและ1เป็นความจริง

ลองออนไลน์! (แก้ไขเล็กน้อยเพื่อรองรับกรณีทดสอบที่แยกจากกันหลายช่องทางแทน)

คำอธิบาย

O`.+

เรียงลำดับบรรทัดในอินพุต หากมีคำนำหน้ามันจะจบลงตรงหน้าสตริงที่มีอยู่

Mm1`^(.+)¶\1

ลองจับคู่ ( M) บรรทัดที่สมบูรณ์ซึ่งจะพบที่จุดเริ่มต้นของบรรทัดถัดไป mเปิดใช้งานโหมดหลายดังกล่าวว่า^จุดเริ่มต้นตรงกับเส้นและ1มั่นใจได้ว่าเราจะนับเฉพาะจำนวนที่มากที่สุดหนึ่งในการแข่งขันดังกล่าวว่าการส่งออกเป็นหรือ01

0

การแลกเปลี่ยน0และ1ผลที่เรานับจำนวนของ0s

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แต่ยังใช้ประโยชน์จาก foreach loop และความเท่าเทียมกันของการอ้างอิงสตริง

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

โปรดทราบว่าอย่างที่ฉันพูดสิ่งนี้ใช้ความเท่าเทียมกันของการอ้างอิงสตริง นั่นไม่ได้หมายความว่ารหัสสามารถประพฤติผิดปกติเนื่องจากสตริง 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) เดียวกัน แต่ต่างกันoridinalที่ขึ้นต้นด้วยคำนำหน้าy.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₀ᵈ¹)

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 ไบต์ที่บันทึกไว้ขอบคุณ @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>

มาติกา 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

รวมสองครั้ง1#.1#.เพื่อรับตัวเลขเดียวแทน "ทุกคนในเมทริกซ์" และดูว่าตัวเลขนั้นเหมือนกับความยาวของอินพุต#=หรือไม่ ถ้าเป็นเช่นนั้นคำนำหน้าที่ตรงกันเท่านั้นคือการจับคู่ตนเองนั่นคือเรามีรหัสคำนำหน้า

โซลูชันการเรียงลำดับ 18 ไบต์

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

พยายามใช้วิธีอื่น วิธีนี้จะเรียงลำดับและดูคู่ที่อยู่ติดกัน

ลองออนไลน์!

R , 48 ไบต์

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

ลองออนไลน์!

คำอธิบาย: outer(s,s,startsWith)เอาต์พุตเมทริกซ์ของการตรวจสอบโลจิคัลว่าs[i]เป็นส่วนนำหน้าs[j]หรือไม่ หากsเป็นรหัสคำนำหน้าจะมีlength(s)องค์ประกอบที่แท้จริงในผลลัพธ์ที่สอดคล้องกับองค์ประกอบในแนวทแยง ( s[i]เป็นคำนำหน้าของตัวเอง)

Pyth - 13 12 ไบต์

!ssmm}d._k-Q

ลองมันออนไลน์ได้ที่นี่

Ruby, 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

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)

การทดสอบ:

(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เพื่อตรวจสอบการเตรียมการ ส่วนใหญ่เพิ่มเนื่องจากดูเหมือนจะยังไม่มีคำตอบ 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)

Japtet , 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 ไบต์

å·↑↑¶Ω

เรียกใช้และแก้ไขข้อบกพร่อง

สิ่งนี้สร้างไม่ใช่ศูนย์เพื่อความจริง

แนวคิดทั่วไปคือการพิจารณาสตริงทุกคู่ในอินพุต หากดัชนีซับสตริงของหนึ่งในอื่น ๆ ที่เคยเป็นศูนย์แล้วมันไม่ใช่รหัสคำนำหน้าที่ถูกต้อง ใน stax ดัชนีของสตริงย่อยที่ไม่มีอยู่-1ในสแตกซ์ดัชนีของอัตราผลตอบแทนด้วยวิธีนี้ดัชนีซับสตริงคู่ทั้งหมดสามารถนำมาคูณกันได้

นี่เป็นอัลกอริธึมแบบเดียวกับโซลูชัน pyth ของ isaacg แต่ฉันพัฒนาขึ้นมาเอง