স্ট্রিংয়ের সেটগুলির সমস্ত দ্ব্যর্থহীন উপসর্গ সন্ধান করুন

12

এই চ্যালেঞ্জের জন্য, আপনাকে 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 
— ডোরকনব
সূত্র
স্টাডাউট কি ঠিক সেই বিন্যাসে থাকতে হবে? বা আমি কি করতে পারি key:value\nkey:value\nkey:value...?
— আন্ডারগ্রাউন্ডোমোনাইল
4
সংক্ষিপ্ত শব্দ শব্দের নতুন সংজ্ঞা দেওয়ার পরিবর্তে আপনি কেবলমাত্র এর মানক অর্থ সহ উপসর্গ ব্যবহার করতে পারেন । এবং আমি মনে করি দ্ব্যর্থহীন conveys চেয়ে আরো কার্যকরভাবে কী পছন্দসই সম্পত্তি অনন্য , যার জন্য আমার প্রথম অনুভূতি ছিল যে আপনি ইনপুট শব্দ প্রতি শুধুমাত্র একটি উপসর্গ চেয়েছিলেন।
— পিটার টেলর
@ পিটারটেলর ভাল ধারণা; সম্পাদনা করা হয়েছে।
— ডুরকনব
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=⍴∆←: কেবলমাত্র দুটি উপাদান রয়েছে (তালিকার উপসর্গ এবং একটি মিলের শব্দ) থাকলে তালিকাটি ফিরিয়ে দিন
  • ↑: টিপলগুলির তালিকাটিকে ম্যাট্রিক্সে পরিণত করুন
— সামুদ্রিক
সূত্র
লিঙ্কটি এখন ভেঙে গেছে ...
— ব্যবহারকারী 202729
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 স্পেস নয়, এটি এসই এর মার্কডাউন ইন্টারপ্রেটারের একটি পার্শ্ব প্রতিক্রিয়া। এটি একটি আক্ষরিক ট্যাব চরিত্র, তাই কেবল একটি বাইট।

এটি প্রযুক্তিগতভাবে অনুমান করার মতো নয়, তবে ডোরকনব ব্যাখ্যা দিলে আমি এটিকে পরিবর্তন করব। এটি আউটপুট আলাদা করতে কমাগুলির পরিবর্তে নিউলাইনগুলি ব্যবহার করে। উদাহরণ স্বরূপ:

$ 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 অক্ষর সংরক্ষণ
— WorldSEnder
আমি যার যার প্রয়োজন এটির জন্য এখানে একটি অবিরাম সংস্করণ তৈরি করেছি gist.github.com/stuaxo/c371b2d410191a575b763b74719856c8
— স্টুয়ার্ট
3

জে - 47 চর

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

জে স্ট্রিংকে কেবল অক্ষরের ভেক্টর হিসাবে দেখেন, যার অর্থ এটি যখন স্ট্রিংগুলির একটি তালিকা তৈরি করার চেষ্টা করে এটি আসলে অক্ষরের একটি সারণী তৈরি করে শেষ হয়, তাই প্রান্তটি ফাঁকা স্থান দিয়ে প্যাড করে। জে এর সমাধানটিকে বাক্স বলা হয় , সুতরাং এই ফাংশনটি স্ট্রিংগুলির একটি বাক্সযুক্ত তালিকা হিসাবে যুক্তি হিসাবে গ্রহণ করে যাতে দৈর্ঘ্য সংরক্ষণ করা যায়।

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

এছাড়াও, জে হ্যাশের ধরণের অভাব রয়েছে, সুতরাং এটির নিকটতমতম আইটেমগুলির একটি দুটি কলামের টেবিল, উদাহরণস্বরূপ বাক্সযুক্ত স্ট্রিংগুলি বলুন। যদি তা অগ্রহণযোগ্য হয় এবং আমাকে কী-মান ফর্মটিতে ডিফল্ট করতে হয়, আমি এই ফর্মটিতে আউটপুটটি মোট 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

Haskell, 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]

অবরুদ্ধ সংস্করণ:

 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 টি অক্ষর বাঁচায়।
— রাইময়েড
@ রাইময়েড আপনাকে ধন্যবাদ আমি সরিয়েছি concatMapতবে আমি 9 টিরও বেশি অক্ষর সংরক্ষণ করতে পারি না।
— lortabac
ওহ অপেক্ষা করুন, আপনি ঠিক বলেছেন; হাস্কেল >>=\ একক লেক্সেম হিসাবে বিবেচনা করে । সে সম্পর্কে দুঃখিত ...
— রাইময়েড
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পরিবর্তে লেখার মাধ্যমে একটি অক্ষর সংরক্ষণ করব ।

যার উত্তর থেকে আমি আমার সামগ্রিক কোড কাঠামো ভিত্তি করে আন্ডারগ্রাউন্ডোমোরাইলকে Credit ণ

— xnor
সূত্র
(e<w)*S.count(c+e)>1e<w<w*S.count(c+e)2 টি অক্ষর সংরক্ষণ করতে গল্ফ করা যেতে পারে।
— 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

কে 4 (70)

বিশেষত গল্ফড নয়; আমি নিশ্চিত যে এটি আরও কম হতে পারে

জে ইমপ্লের সাথে বেশ মিল similar উপরে, আমি মনে করি - মূলত সমস্ত (যথাযথ) উপসর্গ সংগ্রহ করে, উপসর্গগুলি থেকে আবার শব্দগুলি সরিয়ে দেয় ( "car"/ "carpet"কেস পরিচালনা করতে ), সমান শ্রেণিতে বিভক্ত করে, কেবলমাত্র একটি উপাদান দিয়ে ক্লাসগুলি বেছে নেয়, তালিকা থেকে কমিয়ে দেয় স্ট্রিংগুলি এবং মানচিত্রে স্ট্রিংগুলি থেকে নিজের মধ্যে যুক্ত করে adds

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

কিছু পরীক্ষার ক্ষেত্রে

মনে রাখবেন k/ এ q, একটি স্ট্রিং অক্ষরগুলির তালিকা, সুতরাং কেবলমাত্র একটি একক অক্ষরযুক্ত একটি স্ট্রিং যেমন ইউনারি ,ফাংশন ব্যবহার করে চিহ্নিত করা দরকার ; & কেবলমাত্র একটি একক স্ট্রিংযুক্ত স্ট্রিংগুলির একটি তালিকা মিমিওয়্রুট করে

এই ব্যবহার 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 এর নিচে নেমে গেছে Fun ফাংশনটি একটি তালিকা দেয় যা হ্যাশ ভেরিয়েবলের জন্য নির্ধারিত হতে পারে:

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

মন্তব্য

  • প্রশ্ন ভাষার অভ্যন্তরীণ কে 4 নামে একটি অভ্যন্তরীণ কোর রয়েছে (এই উত্তরটিতে ব্যবহৃত হয় এবং এই প্রশ্নের আরও আগের উত্তর)

  • কোড পরীক্ষা করার জন্য, দোভাষী ডাউনলোড করুন (kx.com, অ-বাণিজ্যিক ব্যবহারের জন্য বিনামূল্যে, উইন্ডোজ, লিনাক্স, ম্যাকের জন্য সমর্থন)

দোভাষী দুটো সিনট্যাক্স স্বীকার করেছেন:

  • ভার্বোস (আরও পঠনযোগ্য নাম, মোন্দ এবং হায়াদের আলাদা স্বতন্ত্র নাম, আরও গ্রন্থাগার, ...)। Q এক্সটেনশন, বা ইন্টারেক্টিভ ইন্টারপ্রেটার সহ উত্স ফাইলটি লোড করুন

  • কমপ্যাক্ট (ক্রিয়ামূলক অভ্যন্তরীণ কোর, একটি অক্ষর অপারেটর, উভয়ের জন্য একই চিঠিটি মোনাদ / ডায়াড ব্যবহার করে ...)। কে এক্সটেনশান সহ সোর্স ফাইল লোড করুন, বা কে মোডে ইন্টারেক্টিভ ইন্টারপ্রিটার (প্রম্পটে write লিখুন)। কোডটি অবশ্যই এই মোডে পরীক্ষা করা উচিত

কোডটি একটি ল্যাম্বডা (বেনামে ফাংশন) সংজ্ঞায়িত করে। ফাংশনটির নাম দেওয়ার জন্য আমাদের উপসর্গের নাম প্রয়োজন: (প্রাক্তন চ: {..}), সুতরাং 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: এবং পি

,/ সমস্ত raze (সম্মিলন এবং একটি এক স্তরের কাঠামো তৈরি করে)

= শ্রেণিবদ্ধ -> প্রতিটি অনন্য উপসর্গের জন্য, সংশ্লিষ্ট শব্দগুলিকে যুক্ত করে

#:' দৈর্ঘ্য গণনা করে (প্রতিটি উপসর্গের সাথে যুক্ত শব্দের সংখ্যা)

1= দৈর্ঘ্য = 1 (দ্ব্যর্থহীন), অন্যথায় মিথ্যা true

& যেখানে -> সত্য উপাদানগুলির সূচক

p in\: সমস্ত উপসর্গের জন্য নির্ধারণ করে যদি তারা অস্পষ্ট উপসর্গে থাকে

(..)' ডানদিকের প্রতিটি মানগুলিতে (..) প্রযোজ্য (দ্ব্যর্থহীন উপসর্গ)

?0,&: -> স্বতন্ত্র 0 সংযুক্ত যেখানে (নিজের উপসর্গ হিসাবে শব্দ মোকাবেলা করতে)

p@ সূচকে প্রতীকগুলিতে রূপান্তর করুন

x!.. কী (x) শব্দ এবং কী হিসাবে মান হিসাবে একটি অভিধান তৈরি করুন

হিসাবে পড়ুন:

  • কী এবং মান হিসাবে শব্দের সাথে একটি অভিধান তৈরি এবং প্রদান করে ..

  • ... স্বতন্ত্র অবস্থান 0 তে সমস্ত সূচকের মান (সমস্ত শব্দ) এবং যেখানে দ্ব্যর্থহীন উপসর্গ

  • ... দ্বিধাহীন উপসর্গ হিসাবে গণনা করা হয় যা কেবলমাত্র একটি শব্দের সাথে উপস্থিত হয় (প্রতিটি চিহ্নের সাথে ওয়ার্ডলিস্ট সহযোগীদের দৈর্ঘ্যের দৈর্ঘ্য থাকে)

  • ... সম্পর্কিত শব্দের সাথে সমস্ত অনন্য প্রতীককে শ্রেণিবদ্ধ করার ফলে তালিকাগুলি

  • ... প্রতিটি শব্দের শেষের চরটি পুনরাবৃত্তি করে গণনা করা উপসর্গ

— জে সেন্দ্রা
সূত্র
1

পিএইচপি 7.0, 67 বাইট (চ্যালেঞ্জ পোস্টডেট)

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

কমান্ড লাইন আর্গুমেন্ট থেকে ইনপুট নেয়; একটি পিছনে কমা প্রিন্ট; সাথে চালানো -nr।

জন্য নতুন পিএইচপি , এক বাইট যোগ করুন: প্রতিস্থাপন &aসঙ্গে ""<।

পুরানো পিএইচপি জন্য, এই 70 বাইট ব্যবহার করুন:

পিএইচপি, 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] করে। যে কোনও ইনপুট স্ট্রিং যা অন্য ইনপুট স্ট্রিংয়ের উপসর্গ নয়, এটি নিজের উপসর্গ হিসাবে দু'বার উত্পন্ন হবে, যদিও টিআইও-র শিরোনামটি ᵘসম্পূর্ণ তালিকাটি ব্যবহারের পরিবর্তে এটি আড়াল করে ᶠ।

 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

এপিএল (ডায়ালগ ক্লাসিক) , 38 বাইট

একক-বাইট চরিত্রের এনকোডিং ব্যবহারের জন্য আমাকে স্মরণ করিয়ে দেওয়ার জন্য এরিক আউটগলফারকে ধন্যবাদ জানাই

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

এটি অনলাইন চেষ্টা করুন!

— ngn
সূত্র
1
উম ... আমি এখানে এমন কোনও খারাপ চরিত্র দেখতে পাচ্ছি না যা আপনি এখানে অ্যাডামের এসবিসিএস দিয়ে ব্যবহার করতে পারবেন না ...: পি
— এরিক দ্য আউটগলফার
লক্ষ্য না করেই আমি আবার ভুল দোভাষী অনুবাদটি বেছে নিয়েছি ... আমার বাইট গণনা অর্ধেক করার জন্য ধন্যবাদ :)
— এনজিএন
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

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}

এটি অনলাইন চেষ্টা করুন!

— মান কালি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.