33

सूचना सिद्धांत में, एक "उपसर्ग कोड" एक शब्दकोश है जहां कोई भी कुंजी किसी अन्य का उपसर्ग नहीं है। दूसरे शब्दों में, इसका मतलब यह है कि कोई भी तार दूसरे से शुरू नहीं होता है।

उदाहरण के लिए, {"9", "55"}एक उपसर्ग कोड है, लेकिन {"5", "9", "55"}नहीं है।

इसका सबसे बड़ा फायदा यह है कि इनकोडिंग टेक्स्ट को उनके बीच कोई विभाजक नहीं लिखा जा सकता है, और यह अभी भी विशिष्ट रूप से निर्णायक होगा। यह हफ़मैन कोडिंग जैसे संपीड़न एल्गोरिदम में दिखाई देता है , जो हमेशा इष्टतम उपसर्ग कोड उत्पन्न करता है।

आपका कार्य सरल है: तार की एक सूची को देखते हुए, यह निर्धारित करें कि यह एक वैध उपसर्ग कोड है या नहीं।

आपका सुझाव:

किसी भी उचित प्रारूप में तार की एक सूची होगी ।
केवल मुद्रण योग्य 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"]

यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे कम जवाब मिलता है।

code-golf string compression decision-problem code-golf ascii-art number-theory division code-golf ascii-art code-golf code-golf number array-manipulation code-golf ascii-art code-golf code-golf string code-golf sequence number-theory code-golf math geometry code-golf combinatorics code-golf integer code-golf arithmetic number-theory code-golf arithmetic restricted-source number-theory restricted-complexity

— DJMcMayhem
स्रोत

क्या आप एक सुसंगत सत्य मूल्य चाहते हैं या यह "कुछ सकारात्मक पूर्णांक" जैसे हो सकते हैं (जो विभिन्न आदानों के बीच भिन्न हो सकते हैं)।

— मार्टिन एंडर

@ मार्टिनबटनर कोई भी सकारात्मक पूर्णांक ठीक है।

— DJMcMayhem

@DrGreenEggsand HamDJ मुझे नहीं लगता कि उत्तर का मतलब आउटपुट की स्थिरता को संबोधित करना है, इसलिए यह सवाल है। ;)

— मार्टिन एंडर

जिज्ञासा से बाहर: चुनौती कहती है: "इसका सबसे बड़ा फायदा, यह है कि एन्कोडेड पाठ को उनके बीच कोई विभाजक नहीं लिखा जा सकता है, और यह अभी भी विशिष्ट रूप से निर्णायक होगा।" कैसे कुछ 001विशिष्ट विशिष्ट होगा ? यह 00, 1या तो हो सकता है 0, 11।

— जोबा

2

@ जोबा यह आपकी चाबियों पर निर्भर करता है। यदि आपके पास 0, 00, 1, 11सभी कुंजी के रूप में हैं, तो यह उपसर्ग-कोड नहीं है, क्योंकि 0 00 का एक उपसर्ग है, और 1 11. का एक उपसर्ग है। एक उपसर्ग कोड वह है जहां कोई भी कुंजी किसी अन्य कुंजी से शुरू नहीं होती है। इसलिए, उदाहरण के लिए, यदि आपकी चाबियाँ हैं तो 0, 10, 11यह एक उपसर्ग कोड और विशिष्ट रूप से समझने योग्य है। 001एक वैध संदेश नहीं है, लेकिन 0011या 0010विशिष्ट रूप से निर्णायक हैं।

— DJMcMayhem

11

पायथ, 8 बाइट्स

.AxM.PQ2

परीक्षण सूट

इनपुट के सभी 2 तत्व क्रमचय लें, प्रत्येक को एक स्ट्रिंग के सूचकांक में मैप करें (दूसरे में एक उपसर्ग के लिए) और वापसी करें कि क्या सभी परिणाम सत्य (गैर-शून्य) हैं।

— isaacg
स्रोत

12

हास्केल, 37 बाइट्स

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

प्रत्येक तत्व xको प्रत्येक तत्व के लिए lएक बार दोहराया जाता है कि यह एक उपसर्ग है, जो मूल सूची को देते हुए उपसर्ग-मुक्त सूची के लिए एक बार है। उपसर्ग संपत्ति की जाँच दोनों सूचियों को जोड़कर की जाती है x, जो लंबाई से परे तत्वों को काटती है x।

— XNOR
स्रोत

यह एक सुरुचिपूर्ण समाधान है (+1)

— माइकल क्लेन

9

जावा, 128 127 126 125 124 124 बाइट्स

(साभार @ केनी लाऊ, @ मैलेटीन, @ पैट्रिक रॉबर्ट्स, @ जोबा)

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

— मार्व
स्रोत

1

आईडी मुक्केबाज़ जावा, लेकिन &इसके बजाय काम करेंगे &&?

— माल्टसेन

1

सही, एक और बाइट बचाता है। जावा में, बूलियन ऑपरेंड्स के साथ बिटवाइज़ ऑपरेटरों का उपयोग करना सामान्य तार्किक ऑपरेटरों की तरह ही व्यवहार करता है, सिवाय इसके कि वे शॉर्ट सर्किट नहीं करते हैं जो इस मामले में आवश्यक नहीं है।

— मार्व

क्या आप केवल फ़ंक्शन के रिटर्न प्रकार को बदलकर वापस नहीं कर सकते intहैं 0और 1? यह कई बाइट्स को बचाएगा। अगर यह जावा में मान्य है इसके अलावा, मैं भूल जाते हैं, लेकिन आप यह घोषणा करते हैं i, jऔर lबाहरी के अंदर forपाश है कि एक कम अर्धविराम से एक बाइट की बचत होगी।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts माल्टीसेन ने पहले भी यह सुझाव दिया था, लेकिन यह सत्य या फालसे की सबसे अधिक परिभाषा के अनुसार मान्य नहीं है । हालांकि घोषणाओं को लूप में लाना पूरी तरह से वैध और स्पष्ट है कि अब मैं इसके बारे में सोचता हूं। Thats जो आपको सुबह 4 बजे गोल्फिंग के लिए मिलता है: ^)

— Marv

3

@ जोबा को यकीन है कि इंडेक्सऑफ के बाद से यह मान्य नहीं है - जब स्ट्रिंग नहीं मिली है, तो रिटर्न -1 यह उस indexOf(a[i])==0स्थिति में होना चाहिए जब कोई बचत न हो।

— पोकचू 22

6

पायथन 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स्वयं है, इसलिए यह मूल सूची देता है।

— XNOR
स्रोत

4

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.

— मार्टिन एंडर
स्रोत

4

जावास्क्रिप्ट ईएस 6, 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>

स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत

3

हास्केल, 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)

यदि दो सूचियाँ समान हैं, तो एक तत्व केवल स्वयं का उपसर्ग है, और यह मान्य है।

— माइकल क्लेन
स्रोत

3

रेटिना , 19 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

इनपुट को पंक्तिबद्ध-अलग किया जाना चाहिए। उत्पादन 0मिथ्या के लिए और सत्य के 1लिए है।

इसे ऑनलाइन आज़माएं! (इसके बजाय कई स्थान-अलग-अलग परीक्षण मामलों का समर्थन करने के लिए थोड़ा संशोधित किया गया है।)

व्याख्या

O`.+

इनपुट में लाइनों को क्रमबद्ध करें। यदि उपसर्ग मौजूद है, तो यह सीधे एक स्ट्रिंग के सामने समाप्त हो जाएगा, जिसमें यह शामिल है।

Mm1`^(.+)¶\1

मिलान करने की कोशिश करें ( M) एक पूरी लाइन जो अगली पंक्ति की शुरुआत में भी पाई जाती है। mबहु मोड ऐसी है कि सक्रिय करता ^मैचों लाइन शुरुआत और 1दर्शाता है कि हम केवल ज्यादा से ज्यादा एक मैच गिनती ऐसी है कि उत्पादन होता है 0या 1।

स्वैप करने के लिए 0और 1परिणाम में, हम 0एस की संख्या गिनते हैं ।

— मार्टिन एंडर
स्रोत

3

जावा, 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;}

@ मार्व के उत्तर में पाए जाने वाले अधिकांश ट्रिक्स का उपयोग करता है , लेकिन फ़ॉरच लूप और स्ट्रिंग संदर्भ समानता का भी उपयोग करता है।

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

ध्यान दें, जैसा कि मैंने कहा, यह स्ट्रिंग संदर्भ समानता का उपयोग करता है। इसका मतलब है कि स्ट्रिंग स्ट्रिंग इंटर्निंग के कारण कोड अजीब व्यवहार कर सकता है । कमांड लाइन से पारित तर्कों का उपयोग करते समय कोड काम करता है, और कमांड लाइन से पढ़ी गई किसी चीज़ का उपयोग करते समय भी। यदि आप परीक्षण करने के लिए मानों को हार्डकोड करना चाहते हैं, हालांकि, आपको मैन्युअल रूप से स्ट्रिंग कंस्ट्रक्टर को कॉल करने की आवश्यकता होगी ताकि इंटर्न को ऐसा न हो सके:

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

— Pokechu22
स्रोत

@ जो राजा मेरे उत्तर का दूसरा भाग देखें; यह थोड़ा जटिल है और इस बात पर निर्भर करता है कि इनपुट कैसे निर्दिष्ट किया जाता है। मुझे याद नहीं है कि वास्तव में यह लिखना है, हालांकि

— Pokechu22

3

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 की आवश्यकता होती है।

यह काम किस प्रकार करता है:

संख्या के साथ स्ट्रिंग स्ट्रिंग विभाजित करें और इसे नाम दें y
सभी y प्राप्त करें
LEFT OUTER JOINउसी i(आईडी) के आधार पर एक ही व्युत्पन्न तालिका में , लेकिन अलग से oridinalजो उपसर्ग के साथ शुरू होती हैy.z LIKE u.z||'%'
समूह परिणाम 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

— lad2025
स्रोत

3

ब्रेकीलॉग , 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₀ᵈ¹)।

— असंबंधित स्ट्रिंग
स्रोत

यदि यह चुनौती "सत्य / मिथ्या" के बजाय "दो अलग और सुसंगत मूल्यों" का उपयोग करती है, तो यह केवल 5 बाइट्स लेगा।

— असंबंधित स्ट्रिंग

2

पर्ल 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)

— मजाक कर रहा है
स्रोत

मैंने 50 बाइट का उत्तर लिखा, लेकिन तुम्हारा सिर्फ पानी से बाहर निकाल दिया।

— बीबी 94

1

@ bb94 हाँ, मैंने एक ऐसे ही उत्तर के साथ शुरुआत की, लेकिन आपके साथ उसी समस्या में भाग गया जिसमें आपके पास डुप्लिकेट कीज़ के साथ सेट है जिसमें सच्चाई है। इस उत्तर को लिखना अविश्वसनीय रूप से संतोषजनक था

— जो किंग

1

रैकेट, 70 बाइट्स

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

— winny
स्रोत

1

पायथन, 58 55 बाइट्स

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

— DJMcMayhem
स्रोत

a.index(b)==0थोड़ा छोटा है। वैकल्पिक रूप से, आप कर सकते हैं 0**sum(a.index(b)for a in l for b in l)।

— Mego

@Mego जो काम नहीं करता क्योंकि indexकोई अपवाद bनहीं है जब नहीं मिला है। और क्योंकि यह होना चाहिए ==, नहीं >=। हालांकि, findकाम करता है। (और यह बहुत कम है!)

— DJMcMayhem

वूप्स, मेरा मतलब टाइप करना था find। नींद दिमाग की नींद है। दूसरे संस्करण के साथ भी काम करना चाहिए find।

— Mego

अगर मैं दूसरा संस्करण प्राप्त करूँ तो मुझे यकीन नहीं है। क्या वह हमेशा 0 नहीं लौटेगा?

— DJMcMayhem

@Mego केवल तभी काम करता है जब हर स्ट्रिंग समान हो। जिस कारण से हम इसकी तुलना करते हैं len(l), क्योंकि हम bप्रत्येक पर सभी एस के माध्यम से पुनरावृत्ति कर रहे हैं a, हमेशा प्रति मैच कम से कम एक मैच होगा a। इसलिए हम जांचते हैं कि मैचों की संख्या तत्वों की संख्या के समान है या नहीं।

— DJMcMayhem

1

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— edc65
स्रोत

!w.indexOf(v)?

— नील

@ नील सही, धन्यवाद

— edc65

1

गणितज्ञ 75 69 68 बाइट्स

हमेशा की तरह आकर्षक। लेकिन मार्टिन बी कोड को 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]

— DavidC
स्रोत

पूर्ववर्ती नियमों को a~Drop~{#}~StringStartsQ~a[[#]]काम करना चाहिए । इसके अलावा Arrayकुछ बाइट्स को बचाना चाहिए Length, विशेष रूप से क्योंकि यह आपको उपयोग Join@@करने की अनुमति देगा Flatten@(बशर्ते, आप Flattenकेवल एक स्तर के लिए उपयोग कर रहे हैं )।

— मार्टिन एंडर

सलाह के लिये धन्यवाद। मैं Arrayबाद में देखूंगा।

— डेविड

1

गणितज्ञ, 41 बाइट्स

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

— एक सीमन्स
स्रोत

1

एपीएल (Dyalog यूनिकोड) , 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

— voidhawk
स्रोत

~2∊+\⊃¨∘.⍷⍨⎕

— ngn

1

जे , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नोट: मैंने वास्तव में एपीएल के जवाब को देखने से पहले लिखा था, बिना पक्षपात के इसे देखने के लिए। दृष्टिकोण लगभग समान हैं, जो दिलचस्प है। मुझे लगता है कि यह प्राकृतिक "सरणी थिंकिग" समाधान है

बॉक्सिंग इनपुट लें क्योंकि स्ट्रिंग्स असमान लंबाई के हैं।

/~प्रत्येक तत्व के साथ जोड़े गए प्रत्येक तत्व का एक सेल्फ-फंक्शन टेबल बनाएं और देखें कि क्या शुरू में कोई मैच होता है {.@E.। यह 1-0 परिणामों का एक मैट्रिक्स का उत्पादन करेगा।

1#.1#.सिंगल नंबर "मैट्रिक्स में सभी" का प्रतिनिधित्व करने के लिए दो बार योग करें , और देखें कि क्या वह संख्या इनपुट की लंबाई के समान है #=। यदि यह है, तो केवल उपसर्ग मैच स्वयं मैच हैं, अर्थात, हमारे पास एक उपसर्ग कोड है।

सॉर्टिंग समाधान, 18 बाइट्स

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

अलग-अलग दृष्टिकोण से प्रयास करें। यह समाधान सॉर्ट करता है और आसन्न जोड़े को देखता है।

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत

1

आर , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: outer(s,s,startsWith)तार्किक s[i]उपसर्गों की जाँच करता है कि क्या उपसर्ग है s[j]। यदि sएक उपसर्ग कोड है, तो length(s)परिणाम में बिल्कुल TRUE तत्व हैं, जो विकर्ण तत्वों के अनुरूप है ( s[i]स्वयं का उपसर्ग है)।

— रॉबिन राइडर
स्रोत

1

मुझे अन्य 48 बाइट विकल्प का एक गुच्छा मिला है, जैसे function(s)all(colSums(outer(s,s,startsWith))<2)कि लेकिन यह startsWithएक ऐसा कार्य है जिसके बारे में मुझे नहीं पता था! अच्छा लगा।

— Giuseppe

1

@Giuseppe मैंने जाँचने के कई तरीके आज़माए कि क्या मैट्रिक्स एक आइडेंटिटी मैट्रिक्स है, लेकिन 48 बाइट्स के तहत भी नहीं मिल सकता। मुझे लगा कि इस तरह से समझना सबसे आसान था, लेकिन मुझे यकीन है कि कोई इसे नीचे गिरा देगा!

— रॉबिन राइडर

Inverting TRUEऔर द्वारा 47 बाइट्सFALSE ...

— Giuseppe

@Giuseppe क्या इसकी अनुमति है? जब इनपुट एक वैध उपसर्ग कोड होता है, तो नियम स्पष्ट रूप से सच्चाई पूछते हैं। (इसके अलावा आपका लिंक 48 बाइट संस्करण के लिए है, लेकिन मैं अनुमान लगा रहा हूं कि आपका सुझाव :-) के == साथ बदलने के लिए है >।)

— रॉबिन राइडर

0

पायथ - 13 12 बाइट्स

!ssmm}d._k-Q

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत

0

रूबी, 48 बाइट्स

आउटपुट के रूप में इनपुट और स्टडआउट के रूप में तर्कों का उपयोग करता है।

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

— ezrast
स्रोत

0

स्काला, 71 बाइट्स

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

— याकूब
स्रोत

0

रैकेट 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

— rnso
स्रोत

0

सी (जीसीसी) , 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 के लिए जाँच करने के लिए लूप के लिए सरल डबल । मुख्य रूप से जोड़ा गया है क्योंकि अभी तक सी जवाब नहीं लगता है।

— LambdaBeta
स्रोत

88 बाइट्स

— सीलिंगकैट

0

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)

— केविन क्रूज़सेन
स्रोत

0

जाप , 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)

— झबरा
स्रोत

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 70 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Innat3
स्रोत

0

स्टैक्स , 6 बाइट्स

å·↑↑¶Ω

इसे चलाएं और डीबग करें

यह सत्य के लिए गैर-शून्य पैदा करता है।

सामान्य विचार इनपुट में तार के प्रत्येक जोड़े पर विचार करना है। यदि एक में दूसरे का सबस्ट्रिंग इंडेक्स कभी शून्य है, तो यह एक मान्य उपसर्ग कोड नहीं है। स्टैक्स में, एक गैर-मौजूदा सबस्ट्रिंग पैदावार का सूचकांक -1। इस तरह, सभी जोड़ी-वार प्रतिस्थापन सूचकांकों को एक साथ गुणा किया जा सकता है।

यह isaacg के pyth समाधान के समान एल्गोरिथ्म है, लेकिन मैंने इसे स्वतंत्र रूप से विकसित किया।

— पुनरावर्ती
स्रोत

क्या यह उपसर्ग कोड है?

पायथ, 8 बाइट्स

हास्केल, 37 बाइट्स

जावा, 128 127 126 125 124 124 बाइट्स

(साभार @ केनी लाऊ, @ मैलेटीन, @ पैट्रिक रॉबर्ट्स, @ जोबा)

Ungolfed

उत्पादन

पायथन 2, 48 51 बाइट्स

CJam, 14 बाइट्स

व्याख्या

जावास्क्रिप्ट ईएस 6, 65 43 40 बाइट्स

परीक्षा

हास्केल, 49 बाइट्स

रेटिना , 19 बाइट्स

व्याख्या

जावा, 97 बाइट्स

PostgreSQL, 186 , 173 बाइट्स

ब्रेकीलॉग , 8 बाइट्स

पर्ल 6 , 24 बाइट्स

व्याख्या

रैकेट, 70 बाइट्स

पायथन, 58 55 बाइट्स

जावास्क्रिप्ट (ईएस 6), 52 54

गणितज्ञ 75 69 68 बाइट्स

विधि 1: एक में आउटपुट संग्रह Array

विधि 2: एक में स्टोरिंग आउटपुट List

गणितज्ञ, 41 बाइट्स

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स SBCS

जे , 17 बाइट्स

सॉर्टिंग समाधान, 18 बाइट्स

आर , 48 बाइट्स

पायथ - 13 12 बाइट्स

रूबी, 48 बाइट्स

स्काला, 71 बाइट्स

रैकेट 130 बाइट्स

सी (जीसीसी) , 93 बाइट्स

05AB1E , 13 बाइट्स

जाप , 8 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 70 बाइट्स

स्टैक्स , 6 बाइट्स

विधि 1: एक में आउटपुट संग्रह `Array`

विधि 2: एक में स्टोरिंग आउटपुट `List`

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स ^SBCS