इस चुनौती के लिए, आपको रूबी के Abbrevमॉड्यूल को कम से कम कोड में लागू करना होगा ।

चुनौती

इनपुट वह होगा जो आपकी भाषा में स्ट्रिंग्स की एक सरणी (सरणी, सूची, अनुक्रम, आदि) के रूप में होगा। आप एक फ़ंक्शन लिख सकते हैं, या आप STDIN पर अल्पविराम से अलग किए गए शब्दों को स्वीकार कर सकते हैं।
फिर आपको उन तारों के लिए अस्पष्ट उपसर्गों के सेट की गणना करनी चाहिए। इसका मतलब है कि आपको अपने मूल तार के संक्षिप्त विवरण के हैश (या मानचित्र, ऑब्जेक्ट आदि) को वापस करना होगा।
- एक "उपसर्ग" स्ट्रिंग की शुरुआत में मूल स्ट्रिंग का एक विकल्प है। उदाहरण के लिए, "उपसर्ग" शब्द "उपसर्ग" का एक उपसर्ग है।
- एक स्पष्ट उपसर्ग एक है कि केवल एक शब्द का मतलब कर सकते हैं। उदाहरण के लिए, यदि आपका इनपुट है car,cat, तो caएक अस्पष्ट उपसर्ग नहीं है क्योंकि इसका मतलब "कार" या "बिल्ली" हो सकता है।
- इस नियम का अपवाद यह है कि एक शब्द हमेशा स्वयं का एक उपसर्ग होता है। उदाहरण के लिए, यदि आपके पास इनपुट है जैसे कि car,carpet, car:carआपके आउटपुट में होना चाहिए।
फिर आप हैश / मैप / ऑब्जेक्ट / आदि वापस कर सकते हैं। अपने फ़ंक्शन से (या अपनी भाषा में समकक्ष करें), या इसे key:valueजोड़े में STDOUT में प्रिंट करें f:foo,fo:foo,...। (कुंजी-मूल्य जोड़े को व्हाट्सएप द्वारा अलग किया जा सकता है यदि यह आपके कोड को छोटा बनाता है।)

परीक्षण के मामलों

Input  code,golf,going
Output c:code,co:code,cod:code,code:code,gol:golf,golf:golf,goi:going,goin:going,going:going

Input  pie
Output p:pie,pi:pie,pie:pie

Input  pie,pier,pierre
Output pie:pie,pier:pier,pierr:pierre,pierre:pierre

Input  a,dog
Output a:a,d:dog,do:dog,dog:dog

नियम

इनपुट में डुप्लिकेट तत्व नहीं होंगे।
आपका आउटपुट किसी भी क्रम में हो सकता है; आपको इसे क्रमबद्ध नहीं करना है।
आप Abbrevरूबी की तरह एक अंतर्निहित मॉड्यूल / फ़ंक्शन / चीज़ का उपयोग नहीं कर सकते हैं ।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!

code-golf

— Doorknob
स्रोत

क्या stdout को वास्तव में उस प्रारूप में होना चाहिए? या मैं कर सकता हूँ key:value\nkey:value\nkey:value...?

— अंडरग्राउंडोरेल

4

शब्द के संक्षिप्त नाम को फिर से परिभाषित करने के बजाय आप इसके मानक अर्थ के साथ उपसर्ग का उपयोग कर सकते हैं । और मुझे लगता है कि असंदिग्ध रूप से अद्वितीय की तुलना में चाबियों की वांछित संपत्ति को अधिक प्रभावी ढंग से बताती है , जिसके लिए मेरा पहला अंतर्ज्ञान यह था कि आप प्रति इनपुट शब्द केवल एक उपसर्ग चाहते थे।

— पीटर टेलर

@PeterTaylor अच्छा विचार; संपादित।

— दरवाज़े

1

एक ही कुंजी को कई बार (एक ही मूल्य के साथ) प्रिंट किया जा सकता है?

— xnor

1

एपीएल (46)

(हां, एपीएल चारसेट एक बाइट में फिट होता है, जिसमें कमरे में अतिरिक्त सामान होता है।)

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}

यह एक फ़ंक्शन है जो स्ट्रिंग्स की एक सूची लेता है, और 2-बाय-एन मैट्रिक्स लौटाता है, जहां प्रत्येक पंक्ति में एक अस्पष्ट उपसर्ग होता है और यह शब्द इसके अंतर्गत आता है:

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}'code' 'golf' 'going'
 c      code  
 co     code  
 cod    code  
 code   code   
 gol    golf  
 golf   golf  
 goi    going 
 goin   going 
 going  going

स्पष्टीकरण:

∆←⍵: सही तर्क को स्टोर करें ∆।
{↑∘⍵¨⍳⍴⍵}¨∆: प्रत्येक तत्व के लिए ∆, उस तत्व के संभावित उपसर्ग प्राप्त करें:
- ⍳⍴⍵: 1की लंबाई से सूची प्राप्त करें⍵
- ↑∘⍵¨: उन संख्याओं में से प्रत्येक के लिए, उस कई तत्वों को प्राप्त करें ⍵।
∪⊃,/: सूचियों को एक साथ जोड़ना और अद्वितीय मान लेना।
{... }¨: प्रत्येक अद्वितीय उपसर्गों के लिए:
- ∆/⍨⊃¨⍵∘⍷¨∆: उस उपसर्ग के साथ शुरू होने वाले शब्दों का चयन करें
- (⊂⍵),: उपसर्ग और अवतल को भी मिलाते हैं
- ∆/⍨2=⍴∆←: केवल दो तत्व (उपसर्ग और एक मिलान शब्द) होने पर सूची वापस करें
↑: टुपल्स की सूची को एक मैट्रिक्स में बदल दें

— मारीनस
स्रोत

लिंक अब टूट गया है ...

— user202729

3

पायथन 2.7 - 146 141 बाइट्स

l=raw_input().split(',')
for w in l:
 for a in range(len(w)):
    e=w[:a+1]
    if e==w or len(filter(lambda b:b.startswith(e),l))==1:print e+':'+w

ध्यान दें कि लाइनों 4 और 5 पर इंडेंटेशन 4 स्थान नहीं है, यह एसई के मार्कडाउन दुभाषिया का एक साइड इफेक्ट है। यह एक शाब्दिक टैब वर्ण है, इसलिए केवल एक बाइट है।

यह तकनीकी रूप से कल्पना तक नहीं है, लेकिन अगर Doorknob स्पष्ट करता है तो मैं इसे बदल दूंगा। यह आउटपुट को अलग करने के लिए अल्पविरामों के बजाय नईलाइन्स का उपयोग करता है। उदाहरण के लिए:

$ python2 abbreviations.py <<< code,golf,golfing
c:code
co:code
cod:code
code:code
golf:golf
golfi:golfing
golfin:golfing
golfing:golfing

नया: मैं स्ट्रिंग को असाइन करके 5 वर्णों से छुटकारा पाने में सक्षम था जो मैं एक चर पर जाँच रहा हूं e। इसका मतलब है कि मुझे केवल तीन बार के eबजाय टाइप करना होगा w[:a]। इसका यह भी मतलब मैं कर के आधार पर पात्रों को बचाने e=w[:a+1]और बदलते ...range(1,len(w)+1)करने के लिए range(len(w))।

स्पष्टीकरण:

l=raw_input().split(',') # Gets a line of input from stdin and splits it at every ',' to make a list
for w in l: # For each word in that list...

 for a in range(1,len(w)+1): # For each number a from 1 to the length of that word...

    if (w[:a]==w # w[:a] gets the string w up to the ath index. For example, 'aeiou'[:3] == 'aei'.
                 # We're testing every possible w[:a] to see if it's a unique abbreviation.
                 # However, a word is always its own abbreviation, so we hardcode that in by testing
                 # if w[:a] is the same as w.

or len(filter( # filter takes a function and an iterable as an argument, and returns a list of every
               # element of that iterable where that_function(that_element) returns a True-y value

lambda b:b.startswith(w[:a]),l) # We define an anonymous function that returns True for any string
                                # that begins with our current w[:a]. We filter for words that return
                                # True.

)==1): # If exactly one word returns True for this, it's a unique abbreviation!

     print w[:a]+':'+w # Print the abbreviation, a colon, and the full word.

— undergroundmonorail
स्रोत

आप sum(b.startswith(e) for b in l)इसके बजाय का उपयोग कर सकते हैंlen(filter(lambda b:b.startswith(e),l))

— निकल्स बी।

तुम भी छोटा कर सकते हैं b.startswith(e)करने के लिए b.find(e)==0या b[:a+1]==e, और जाँच <2के बजाय गिनती पर ==1।

— xnor

इसके e=""\n for a in w:\n\te+=aबजाय ऐसा करें for a in range(len(w)):\n\te=w[:a+1]कि यह 10 वर्णों को बचाता है

— वर्ल्डसेंडर

मैंने यहाँ किसी के लिए एक अनगॉल्फ़ड संस्करण बनाया है, जिसे इसकी आवश्यकता है। gith.github.com/stuaxo/c371b2d410191a575b763b74719856c8

— स्टुअर्ट एक्सॉन

3

जे - 47 चार

(,.~~.@,~[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>)

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

   'code';'golf';'going'
+----+----+-----+
|code|golf|going|
+----+----+-----+

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

;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>)

विस्फोट से स्पष्टीकरण:

(,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) NB. unambiguous prefixes
                                    (     )&.>  NB. for each string:
                                     <\         NB.   take all prefixes
                                       ,.<      NB.   pair each with string
        [:                         ;            NB. gather up "partial" hashes
          (#~1-                  )@             NB. remove those rows where:
               1({.\        ){."1               NB.   each key
                    e."_1                       NB.   is an element of
               1(        ]\.){."1               NB.   the rest of the keys
 ,.~                                            NB. hash each word to itself
       ,                                        NB. add these rows to hash
    ~.@                                         NB. remove duplicate rows

उदाहरण:

   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) 'pie';'pier';'pierre'
+------+------+
|pie   |pie   |
+------+------+
|pier  |pier  |
+------+------+
|pierre|pierre|
+------+------+
|pierr |pierre|
+------+------+
   NB. 1-char words have to be made into lists with ,
   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) (,'a');'dog'
+---+---+
|a  |a  |
+---+---+
|dog|dog|
+---+---+
|d  |dog|
+---+---+
|do |dog|
+---+---+
   NB. "key:value," format, reversed order to save chars
   ;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>) 'code';'golf';'going'
goin:going,goi:going,gol:golf,cod:code,co:code,c:code,going:going,golf:golf,code:code,

— algorithmshark
स्रोत

2

हास्केल 96 87

import Data.List
i=inits
f a=a>>= \x->[(y,x)|y<-i x,y/="",y`notElem`(a>>=i)\\i x||y==x]

Ungolfed संस्करण:

 import Data.List
 f a = concatMap (\x ->
     [(y, x) |
      y <- inits x,
      y /= "",
      y `notElem` concatMap inits a \\ inits x || y == x]
     ) a

उदाहरण:

> f ["pi","pier","pierre"]
[("pi","pi"),("pier","pier"),("pierr","pierre"),("pierre","pierre")]

मैंने initsफ़ंक्शन का उपयोग किया , जो सूची / स्ट्रिंग के सभी उपसर्गों को ढूंढता है। क्या यह धोखा के रूप में गिना जाता है?

— lortabac
स्रोत

1

आप concatMapद्वारा प्रतिस्थापित कर सकते हैं (=<<), जो प्रस्तावना में है। आपको 10 अक्षर बचाता है।

— कविता

@Rhymoid धन्यवाद। मैंने हटा दिया concatMapलेकिन मैं 9 से अधिक पात्रों को नहीं बचा सकता।

— लॉर्टबाक

ओह रुको, तुम सही हो; हास्केल >>=\ को एक सिंगल लेक्सेम मानते हैं। इसके बारे में क्षमा करें ...

— Rhymoid

2

पायथन 3 (97)

c=','
S=c+input()
for w in S.split(c):
 e=w
 while e:e<w<w*S.count(c+e)or print(e+':'+w);e=e[:-1]

हम इनपुट में प्रत्येक शब्द के उपसर्गों पर पुनरावृत्ति करते हैं, संबंधित उपसर्ग / शब्द युग्म को मुद्रित करते हैं यदि यह या तो बिल्कुल एक बार दिखाई देता है या पूरे शब्द के लिए है। हम इनमें से किसी एक स्थिति के पूरा होने पर प्रिंट करने के लिए or(और printएक फ़ंक्शन होने के) शॉर्ट-सर्किट व्यवहार का लाभ उठाते हैं ।

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

हम सबस्ट्रिंग के लिए eमूल अल्पविराम से अलग इनपुट स्ट्रिंग की खोज करके इनपुट में उपसर्ग की घटनाओं को गिनते हैं । हम इनपुट स्ट्रिंग बीफ़हैंड के लिए एक अल्पविराम प्रस्तुत करते हैं। जब हम करते हैं तो यह अतिरिक्त खाली स्ट्रिंग तत्व का कारण बनता है , लेकिन इसका कोई प्रभाव नहीं होता है क्योंकि इसमें कोई गैर- रिक्त पदार्थ नहीं होता है।S','+esplit

मामले की जांच करने के लिए जब सबस्ट्रिंग eपूरा शब्द है w, हम स्ट्रिंग तुलना ऑपरेटर का उपयोग करके उनकी तुलना करते हैं। यह शाब्दिक रूप से तुलना करता है, इसलिए छोटे उपसर्ग छोटे होते हैं। e==wया तो दोहरी तुलना विफल हो जाती है या S.count(c+e)<2।

यदि फॉर्म में प्रिंटिंग आउटपुट e,wकी अनुमति थी, तो मैं e+c+wइसके बजाय एक चरित्र लिखकर बचा सकता हूं ।

जिसका जवाब मैं अपने समग्र कोड संरचना के आधार पर अंडरग्राउंडोरेल को देता हूं।

— XNOR
स्रोत

(e<w)*S.count(c+e)>1e<w<w*S.count(c+e)2 वर्णों को सहेजने के लिए रखा जा सकता है ।

— isaacg

@isaacg धन्यवाद! मैंने आपका अनुकूलन जोड़ दिया है।

— xnor

1

रूबी, 114

def f(l);h={};l.each{|w|w.size.times{|i|k=w[0..i];h[k]=h[k]&&0||w}};h.delete_if{|k,v|v==0};l.each{|w|h[w]=w};h end

Ungolfed:

def f(list)
  hash = {}
  list.each do |word|
    word.size.times do |i|
      key = word[0..i]
      h[key] = (hash[key] && 0) || word
    end
  end
  hash.delete_if{|key, value| v==0}
  list.each{|word| hash[word] = word}
  hash 
end

— dtldarek
स्रोत

1

k4 (70)

विशेष रूप से गोल्फ नहीं; मुझे यकीन है कि यह छोटा हो सकता है

जे प्रत्यारोपण के समान सुंदर। ऊपर, मुझे लगता है - मूल रूप से सभी (उचित) उपसर्गों को इकट्ठा करता है, शब्दों को फिर से उपसर्गों से हटाता है ( "car"/ "carpet"मामले को संभालने के लिए ), उन्हें समतुल्य वर्गों में समूह बनाता है, केवल एक तत्व के साथ कक्षाओं को चुनता है, उन्हें सूचियों से कम करता है। तार, और खुद को तार से नक्शे में जोड़ता है।

f:{(x!x),*:'{(&1=#:'x)#x}{x@=y@:&~y in x}.,/'+{1_'(c#,x;(!c:#x)#\:x)}'x}

कुछ परीक्षण मामले

ध्यान दें कि k/ में q, एक स्ट्रिंग वर्णों की सूची है, इसलिए एक स्ट्रिंग में केवल एक ही चरित्र को चिह्नित करने की आवश्यकता होती है जैसे कि एकांतर ,फ़ंक्शन का उपयोग करना; & केवल एक स्ट्रिंग वाले स्ट्रिंग्स की एक सूची mmmmt

इन उपयोग qके showसमारोह, जो में निर्मित कुछ डेटा संरचनाओं के लिए स्वरूपण, परिणाम अधिक पठनीय बनाने के लिए:

  .q.show f("code";"golf";"going")
"code" | "code"
"golf" | "golf"
"going"| "going"
,"c"   | "code"
"co"   | "code"
"cod"  | "code"
"gol"  | "golf"
"goi"  | "going"
"goin" | "going"
  .q.show f@,"pie"
"pie"| "pie"
,"p" | "pie"
"pi" | "pie"
  .q.show f("pie";"pier";"pierre")
"pie"   | "pie"
"pier"  | "pier"
"pierre"| "pierre"
"pierr" | "pierre"
  .q.show f(,"a";"dog")
,"a" | ,"a"
"dog"| "dog"
,"d" | "dog"
"do" | "dog"
  .q.show f("car";"carpet")
"car"   | "car"
"carpet"| "carpet"
"carp"  | "carpet"
"carpe" | "carpet"

— हारून डेविस
स्रोत

1

जावास्क्रिप्ट - 212

w=prompt(o=[]).split(",");w.map(function(k,l){for(i=0;++i<k.length;){p=k.slice(0,i);if(w.filter(function(r,t){return t!=l}).every(function(r){return r.indexOf(p)}))o.push(p+":"+k)}o.push(k+":"+k)});console.log(o)

प्रारंभिक गोल्फ।

इनपुट:

code,golf,going

आउटपुट:

["c:code", "co:code", "cod:code", "code:code", "gol:golf", "golf:golf", "goi:going", "goin:going", "going:going"]

— मैट
स्रोत

1

पर्ल, 93 77

पठनीयता के लिए नई सूचियों और मांगपत्र के साथ:

sub f{
    (map{
        $h{$x}=[($x=$`.$&,$_)x!$h{$x}]while/./g;
        $_,$_
    }@_),map@$_,values%h
}

थोड़ा बहुत देर से और बहुत लंबा है, लेकिन मुझे खुशी है कि यह अंत में 100 से नीचे है। फ़ंक्शन एक सूची देता है जिसे हैश वेरिएबल को सौंपा जा सकता है:

%h = f(qw/code golf going pie pier pierre/);
print "$_ $h{$_}\n" for sort keys %h;

तथा

perl prefix.pl
c code
co code
cod code
code code
goi going
goin going
going going
gol golf
golf golf
pie pie
pier pier
pierr pierre
pierre pierre

दरअसल, लौटी हुई सूची को अभी तक फिल्माया नहीं गया है - हैश निर्माण अपने कार्य के समय यानी बाहरी कार्य के पूरा होने पर। यदि यह पर्याप्त रूप से साफ / उचित नहीं है, तो 3 सामग्री को गिनने और फ़ंक्शन सामग्री को घुंघराले ब्रेसिज़ में डालकर, प्रीपेंड कर रहा है +- फिर 'सही' हैश संदर्भ देता है।

— user2846289
स्रोत

1

प्रश्न: 44 बाइट्स

{x!p@'(?0,&:)'p in\:&1=#:'=,/p:`$(-1_)\'$x}

टिप्पणियाँ

Q भाषा में आंतरिक रूप से K4 नाम का एक आंतरिक भाग है (इस उत्तर में प्रयुक्त और इस प्रश्न का एक अन्य पूर्व उत्तर)
कोड का परीक्षण करने के लिए, इंटरप्रेटर (kx.com) डाउनलोड करें, जो गैर-वाणिज्यिक उपयोग के लिए मुफ्त है, विंडोज, लिनक्स, मैक के लिए समर्थन)

दुभाषिया दो वाक्यविन्यास स्वीकार करता है:

क्रिया (अधिक पठनीय नाम, मूंड और डायड के लिए अलग नाम, अधिक पुस्तकालय, ...)। क्यू एक्सटेंशन, या इंटरएक्टिव दुभाषिया के साथ लोड स्रोत फ़ाइल
कॉम्पैक्ट (कार्यात्मक आंतरिक कोर, एक अक्षर ऑपरेटर, दोनों के लिए एक ही पत्र मोनड / डायड, ... का उपयोग करता है)। K एक्सटेंशन के साथ सोर्स फाइल लोड करें, या k मोड में इंटरएक्टिव इंटरप्रिटर (प्रॉम्प्ट पर राइट लिखें)। इस मोड में कोड का परीक्षण किया जाना चाहिए

कोड एक लैम्ब्डा (अनाम फ़ंक्शन) को परिभाषित करता है। फ़ंक्शन को नाम देने के लिए हमें उपसर्ग नाम की आवश्यकता है: (पूर्व f: {..}), इसलिए 46 बाइट्स की आवश्यकता है

परीक्षा

(नाम दिया गया फ़ंक्शन: कोड के लिए अन्यथा स्थानापन्न करें)

f `code`golf`going

`code`golf`going!(`code`cod`co`c;`golf`gol;`going`goin`goi)

एक शब्दकोश (वाक्यविन्यास कुंजी! मान) देता है। कुंजी प्रतीकों की एक सूची है (`सिम्बायम ..), और प्रतीकों की सूची की एक सूची को महत्व देता है। यदि हम संवादात्मक दुभाषिया पर सेंटेंट को निष्पादित करते हैं, तो हमारे पास एक अधिक सुविधाजनक प्रस्तुति है (प्रत्येक कुंजी और एक अलग रेखा पर सहयोगी मूल्य)

code | `code`cod`co`c
golf | `golf`gol
going| `going`goin`goi

व्याख्या

x मेमने के लिए निहित तर्क है

$x प्रतीक सूची को स्ट्रिंग सूची में बदलें

(-1_)\ प्रतीक सूची के प्रत्येक हाथ पर पुनरावृति

(प्रत्येक स्ट्रिंग के लिए के रूप में पढ़ता है उपसर्गों की गणना करता है (खाने पर स्ट्रिंग स्ट्रिंग के अंतिम चार खा जाता है) (-1_), खाली स्ट्रिंग तक)

$ फिर से एक प्रतीक सूची में तब्दील (सभी उपसर्गों की सूची)

p: और p को असाइन करता है

,/ सभी को विचलित करें (एक-स्तरीय संरचना बनाते हैं)

= वर्गीकृत -> प्रत्येक अद्वितीय उपसर्ग के लिए, संबंधित शब्दों को जोड़ता है

#:' लंबाई की गणना करता है (प्रत्येक उपसर्ग से जुड़े शब्दों की संख्या)

1= सच है अगर लंबाई = 1 (अस्पष्ट), गलत अन्यथा

& जहां -> सच्चे तत्वों का सूचकांक

p in\: सभी उपसर्ग के लिए निर्धारित करता है अगर वे असंदिग्ध उपसर्ग में हैं

(..)' लागू होता है (..) सही पर प्रत्येक मान (असंदिग्ध उपसर्ग)

?0,&: -> अलग 0 संक्षिप्त रूप में (जहां शब्दों को स्वयं के उपसर्ग के रूप में सामना करना पड़ता है)

p@ अनुक्रमणिका को प्रतीकों में बदलना

x!.. कुंजियों के रूप में x (शब्द) और शब्दकोश के रूप में एक शब्दकोश का निर्माण करें

इस प्रकार पढ़ें:

कुंजी और मान के रूप में शब्दों के साथ एक शब्दकोश का निर्माण और वापसी करता है ..
... अलग-अलग पदों पर अनुक्रमित के मान 0 (सभी शब्द) और जहां असंदिग्ध उपसर्ग
... उपसर्गों की गणना उपसर्गों के रूप में की जाती है जो केवल एक शब्द में दिखाई देते हैं (प्रत्येक प्रतीकों के लिए शब्दसूची सहयोगी लंबाई एक है)
... सूचियों के परिणामस्वरूप सभी अद्वितीय प्रतीकों को संबंधित शब्दों के साथ वर्गीकृत किया जाता है
... प्रत्येक शब्द के अंतिम चार्ट को दोहराते हुए उपसर्गों की गणना

— जे सेंदरा
स्रोत

1

PHP 7.0, 67 बाइट्स (चुनौती पोस्टडेट्स)

for(;a&$c=$s[++$k]??($s=$argv[++$i])[$k=+$t=!1];)echo$t.=$c,":$s,";

कमांड लाइन तर्कों से इनपुट लेता है; एक अनुगामी अल्पविराम छापता है; साथ चलाना -nr।

के लिए नए पीएचपी , एक बाइट जोड़ें: बदलें &aसाथ ""<।

पुराने PHP के लिए, इन 70 बाइट्स का उपयोग करें:

PHP, 70 बाइट्स

for(;a&$s=$argv[++$i];)for($k=+$t="";a&$c=$s[$k++];)echo$t.=$c,":$s,";

— टाइटस
स्रोत

1

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

∋Xa₀Y;?↔⟨∋a₀⟩ᶜ1∧Y;X|∋gj

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

इनपुट चर के माध्यम से एक सूची के रूप में इनपुट लेता है, और आउटपुट चर के माध्यम से जोड़े की एक सूची बनाता है [key, value]। कोई भी इनपुट स्ट्रिंग जो किसी अन्य इनपुट स्ट्रिंग का उपसर्ग नहीं है, दो बार स्वयं के उपसर्ग के रूप में उत्पन्न होगी, हालांकि TIO पर शीर्षक ᵘइसके बजाय पूरी सूची प्राप्त करने के लिए उपयोग करके छुपाता है ᶠ।

 X                         X
∋                          is an element of
                           the input variable
    Y                      and Y
  a₀                       is a prefix of
 X                         X.
             ᶜ             The number of ways in which
        ⟨∋  ⟩              an element can be selected from
     ;?↔⟨   ⟩              the input variable
    Y; ↔⟨ a₀⟩              such that it has Y as a prefix
              1            is equal to 1.
               ∧Y          Y is not necessarily 1,
                   |       and the output variable
                Y;X        is the list [Y, X].
                   |       If every choice from the first rule has been taken already,
                           the output variable is
                    ∋      an element of
                   |       the input variable
                     gj    paired with itself.

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

यदि आउटपुट में डुप्लिकेट को बर्दाश्त नहीं किया जाता है, तो पूरी चीज़ को लपेटने के लिए तीन बाइट्स जोड़ें {}ᵘ, जब तक कि कुछ छोटा तरीका न तो किसी रूप को स्वयं के उपसर्ग के रूप में बाहर करता है, या अतिरिक्त नियम के बिना हर आवश्यक आउटपुट जोड़ी उत्पन्न करता है ∋gj।

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

1

पर्ल 5 `-a` , 76 बाइट्स

map{say"$, $a"if($,=substr$a,0,$_)eq$a||2>grep/^$,/,@F}1..length($a=$_)for@F

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

— Xcali
स्रोत

1

APL (Dyalog Classic) , 38 बाइट्स

एक एकल बाइट चरित्र एन्कोडिंग का उपयोग करने के लिए मुझे याद दिलाने के लिए धन्यवाद एग्री द आउटग्रॉफ़र

{⊃,/⍵{b,¨⍨(⊂¨⍵~⊃,/a~⊂⍵)∪b←⊂⊂⍺}¨a←,\¨⍵}

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

— NGN
स्रोत

1

उम ... मुझे ऐसा कोई भी बुरा पात्र नहीं मिला जिसे आप अड्म के SBCS के साथ उपयोग नहीं कर सकते ...: P

— Eg the Outgolfer

ध्यान दिए बिना, मैंने फिर से गलत दुभाषिया संस्करण उठाया है ... मेरे बाइट की गिनती को आधा करने के लिए धन्यवाद :)

— 22'19

0

पायथन (127)

इसलिए मैं @undergroundmonorail पर टिप्पणी नहीं कर सकता था, लेकिन मैंने सोचा कि शब्दकोश का तरीका अपनाना बेहतर होगा? मुझे यकीन है कि कुछ सूची / शब्दकोश की समझ के साथ इसे जबरदस्त रूप से भी काटा जा सकता है, लेकिन इसे तानाशाह से पॉपिंग के साथ काम करने के लिए नहीं मिल सकता।

i=raw_input().split(",")
d = {}
for x in i:
    for c in range(1,len(x)+1):
        if x[:c] in d:
            del d[x[:c]]
        else:
            d[x[:c]]=x
print d

प्रिंट शब्दकोश को आउटपुट करेगा, अनऑर्डर किया गया।

संपादित करें: आह मैं कार से चूक गया: कार / कार: कालीन मानदंड। शायद एक लंबाई की जांच?

— jaybee3
स्रोत

हो सकता है कि मुझे कुछ याद आ रहा हो, लेकिन यह हर बार सामने आने वाली उपसर्ग प्रविष्टि को वैकल्पिक रूप से जोड़ने और हटाने के लिए लगता है, इसलिए यदि यह 3 शब्दों में होता है तो अस्पष्ट उपसर्ग प्रकट नहीं होगा?

— xnor

0

ग्रूवी - 212 वर्ण

golfed:

c="collectEntries";f="findAll";def g={def h=[:].withDefault{[]};it.each{def w->w.size().times{ h[w[0..it]] << w}};(h."$f"{k,v->v.size()==1}."$c"{k,v->[k,v[0]]}).plus(h."$f"{k,v->v.contains(k)}."$c"{k,v->[k,k]})}

उदाहरण आउटपुट:

println g(["code","golf","going"])

[c:code, co:code, cod:code, code:code, gol:golf, golf:golf, goi:going, goin:going, going:going]

Ungolfed:

def g = { def list ->
    def hash = [:].withDefault{[]}
    list.each {
        def word -> word.size().times{ hash[word[0..it]] << word }
    }

    def map = hash.findAll{ k,v -> v.size() == 1 }.collectEntries{ k,v -> [k,v[0]] }
    map.plus(hash.findAll{ k,v -> v.contains(k) }.collectEntries{ k,v -> [k,k] }
    map
}

— माइकल ईस्टर
स्रोत

0

जावास्क्रिप्ट (Node.js) , 88 बाइट्स

L=>L.map(s=>[...s].map(c=>L.filter(t=>t>S&t<S+'~',S+=c)[1]&&s>S||(R[S]=s),S=''),R={})&&R

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

— l4m2
स्रोत

0

Zsh , 95 बाइट्स

local -A m
for w;{m[$w]=$w;x=
for c (${(s::)w})x+=$c&&[ ${(M)@:#$x*} = $w ]&&m[$x]=$w
}
local m

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

बाश / ज़श में एक साहचर्य सरणी को "वापस" करने का एकमात्र तरीका यह है कि इसे बिना localकीवर्ड के घोषित किया जाए और फिर इसे अभिभावक के दायरे में पहुँचा दिया जाए। इससे एक बाइट बच जाती। हालांकि, चर के माध्यम से I / O आमतौर पर पर आधारित है, इसलिए हम इसके बजाय सरणी परिभाषा को प्रिंट करते हैं।

local -A m                          # declare m as associative
                                    # "local" is shorter than "typeset"/"declare"
for w;{                             # for each word
    m[$w]=$w                        # the word is a prefix of itself
    x=                              # ensure x is empty
    for c (${(s::)w})               # for each character in the word
        x+=$c &&                    # append to x (building a prefix
          [ ${(M)@:#$x*} = $w ] &&  # if the only match is the word itself:
          m[$x]=$w                  # ... then x is a prefix of w
}
local m                             # print m

— GammaFunction
स्रोत

0

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

बस वहाँ पहले से ही एक मौजूदा रूबी समाधान है, ओह अच्छी तरह से देखा। यह मूल रूप से एक बेहतर तरीके से उपसर्गों को उठाकर पुराने समाधान पर सुधार करता है (प्रत्येक शब्द को अंत में "उपसर्ग" के रूप में जोड़ने की आवश्यकता को समाप्त करता है) और उपसर्ग को जोड़ने के बजाय, हैश में जोड़ने से पहले विशिष्टता की जांच करने के लिए उपसर्गों की गिनती करें। डमी यदि कोई डुप्लिकेट है और फिर प्रविष्टि को मिटा रहा है।

->w{h={};w.map{|e|(1..e.size).map{|i|w.count{|d|d[0,i]==e[0,i]}<2?h[e[0,i]]=e:0}};h}

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

— मान स्याही
स्रोत

तार के एक सेट के सभी अस्पष्ट उपसर्गों का पता लगाएं

चुनौती

परीक्षण के मामलों

नियम

एपीएल (46)

पायथन 2.7 - 146 141 बाइट्स

जे - 47 चार

हास्केल 96 87

पायथन 3 (97)

रूबी, 114

k4 (70)

जावास्क्रिप्ट - 212

पर्ल, 93 77

प्रश्न: 44 बाइट्स

PHP, 70 बाइट्स

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

पर्ल 5 -a , 76 बाइट्स

APL (Dyalog Classic) , 38 बाइट्स

पायथन (127)

ग्रूवी - 212 वर्ण

जावास्क्रिप्ट (Node.js) , 88 बाइट्स

Zsh , 95 बाइट्स

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

पर्ल 5 `-a` , 76 बाइट्स