ओड गोल्फ - लेटर डिलीट

Question

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

उदाहरण के लिए, इनपुट

cat
cart
code
golf
ode
verify
versify

का आउटपुट देना चाहिए

ca(r)t
(c)ode
ver(s)ify

एक ही जोड़ी पाने के कई तरीके केवल एक बार प्रदर्शित होने चाहिए। आप आउटपुट कर सकते हैं scra(p)pedया scrap(p)edनहीं, लेकिन दोनों नहीं।

आउटपुट को लंबी प्रविष्टि द्वारा वर्णानुक्रम में आदेश दिया जाना चाहिए ;

mart
mar
mat
ma

का आउटपुट होना चाहिए

ma(r)
ma(t)
ma(r)t
mar(t)

और बाद के दो या तो क्रम में हो सकते हैं।

शब्दकोश फ़ाइल में पूंजीकरण, रिक्त स्थान, हाइफ़न या एपोस्ट्रोफ़ शामिल हो सकते हैं; इन पर ध्यान नहीं दिया जाना चाहिए। उदाहरण के लिए,

inlay 
in-play

उत्पादन करना चाहिए in(p)lay। आपका आउटपुट सभी एक ही मामले में होना चाहिए। अतिरिक्त व्हाट्सएप की अनुमति है।

इनपुट STDIN या फ़ाइल से हो सकता है; यह newlines द्वारा अलग किया गया है। आउटपुट किसी फ़ंक्शन या STDOUT का रिटर्न मान हो सकता है (या यदि आप चाहते हैं तो फ़ाइल में लिखा गया है)।

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

(पीपीसीजी पर यह मेरी पहली चुनौती है - मुझे बताएं कि क्या मैंने कुछ गलत किया है और मैं इसे ठीक करूंगा।)

Comments

के लिए आउटपुट क्या होना चाहिए mart mar mat ma? यह होगा mar(t) ma(r)t ma(r) ma(t)?

— Sp3000

@Sp: आदेश निर्दिष्ट करना भूल गए - स्पष्ट करने के लिए संपादित किया गया।

— देसुवि

पहले उदाहरण में गोल्फ शब्द आउटपुट में नहीं है। क्या इसलिए कि यह एक ऐसा शब्द है जिसमें अन्य संयोजन नहीं हैं?

— LukStorms

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

— देसोवि सिप

एक (बड़े) स्ट्रिंग पैरामीटर के साथ फ़ंक्शन की अनुमति देने के बारे में, एक स्ट्रिंग सरणी के रूप में अनुरोधित आउटपुट को कैसे लौटाया जाए? यह फ़ाइल I / O को प्रबंधित करने की आवश्यकता से बचने के लिए, एल्गोरिदम पर ध्यान केंद्रित करता है।

— edc65

Answer 1

पर्ल -an0, 101 + 3 बाइट्स

@F=sort{length$a<=>length$b}map{s/\W//g;lc}@F;map{$`.$'~~@F?print"$`($1)$'\n":$\while/(.)(?!\1)/g}@F;

कहाँ पे

• @Fएक शब्दकोष है, जो एक सरणी में संग्रहीत है, रनटाइम फ्लैग मैजिक द्वारा प्रदान किया गया है। (b-oost, BoO # @% @ # $% $ # @ T)
• map{s/\W//g;lc}@Fशब्दों से सभी प्रतीकों को निकालता है और सब कुछ को कम करता है। (बूस्ट, बूट)
• sort{length$b<=>length$a}लंबाई पर। (बूट, बढ़ावा)
• map{ (...) while/(.)(?!\1)/g}@Fसभी वर्णों का मिलान उसी वर्ण से नहीं किया जाता ([b] oot, bo [o] t, boo [t], ...)
• print"$`($1)$'\n"पूर्ववर्ती भागों को प्रिंट करता है, कोष्ठबद्ध करता है, और एक मैच को सफल करता है ... (boo (s) t)
• if $`.$'~~@F... अगर मैच से पहले और बाद की हर चीज का कॉन्सेप्ट डिक्शनरी में है। ([बढ़ावा])

Answer 2

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

स्ट्रिंग पैरामीटर के साथ एक फ़ंक्शन, फ़ाइल से कोई इनपुट नहीं। मैंने ओपी से पूछा कि क्या यह वैध हो सकता है।

एक एक्मास्क्रिप्ट 6 अनुरूप ब्राउज़र में स्निपेट का परीक्षण करना (एरो फ़ंक्शंस लागू करना, टेम्पलेट स्ट्रिंग, प्रसार ऑपरेटर - फ़ायरफ़ॉक्स, शायद सफारी या एमएस एज, क्रोम नहीं)

f=t=>t.split`
`.map(w=>(d[k=w.replace(/\W/g,'').toLowerCase()]={},k),d={},r=[]).map(w=>[...w].map((c,i,v)=>(d[v[i]='',x=v.join``]&&!d[x][w]&&r.push(d[x][w]=(v[i]=`(${c})`,v.join``)),v[i]=c)))&&r.sort((a,b)=>a.length-b.length)

// LESS GOLFED

Q=t=>{
  // convert to canonical form and put in a dictionary
  // each value in the dictionary is an hashtable tha will store the list
  // of words that can generate the current word, removing a letter
  d={},
  t=t.split`\n`.map(w=>(k=w.replace(/\W/g,'').toLowerCase(),d[k]={},k))
  r=[], // result array 
  t.forEach(w =>
    [...w].forEach((c,i,v)=>( // for each letter in word, try to remove
      v[i]='', x=v.join``, // build string with missing letter
      v[i]='('+c+')', y=v.join``, // and build string with brackets
      v[i]=c, // restore the current letter
      d[x] && // if the word with removed letter is present in the dictionary
      !d[x][w] && // and not already from the same generating word
         r.push(d[x][w]=y) // update dictionary and add word to result array
    ))
  )
  return r.sort((a,b)=>a.length-b.length) // sort result by length
}  

// TEST
function test() { R.innerHTML=f(I.value) }

textarea { height: 20em }

Test <button onclick="test()">-></button>
<span id=R></span>
<br><textarea id=I>cat
cart
code
golf
node
scraped
scrapped
verify
versify
mart
mar
mat
ma</textarea>

Comments

@ETHproductions सही, thx

— edc65

Answer 3

रूबी, 173

->d{o=[]
c={}
d=d.sort_by{|w|[w.size,w]}.map{|w|w=w.upcase.gsub /[^A-Z]/,''
c[w]=l=1
w.size.times{|i|p,x,s=w[0...i],w[i],w[i+1..-1]
c[p+s]&&l!=x&&o<<p+"(#{w[i]})"+s
l=x}}
o}

इसका परीक्षण यहां करें: http://ideone.com/86avbe

यहाँ पठनीय संस्करण: http://ideone.com/ynFItB

Comments

मोबाइल पर इसलिए मैं अभी परीक्षण नहीं कर सकता - क्या आप SCRAPPED / SCRAPED एक के लिए एक परीक्षण मामला जोड़ सकते हैं?

— देसुवि

@Deusovi यह मामला सही ढंग से काम नहीं करता है। मैं इसे अब ठीक कर रहा हूं ...

— क्रिस्टियन लुपस्कू

@Deusovi अपडेट किया गया!

— क्रिश्चियन लुपस्क्यू

यह उत्तर उदाहरण के लिए सही आउटपुट प्रदान नहीं करता है ['jacklantern','jackslantern','jack-o-lantern']।

— 14mRh4X0r

@ 14mRh4X0r प्रश्न में उस अनुरोध को नहीं पा सकता है The output should be ordered by the longer entry;...and the latter two could be in either order.

— edc65

Answer 4

रूबी, 211

मैंने तय किया कि मैं इसे हल करने के लिए एक अलग दृष्टिकोण लूंगा, रेगेक्स का उपयोग करके।

->d{o=[]
d.map{|x|x.upcase!.gsub! /[-' ]/,''}
d.map{|x|(x.size+1).times{|i|o+=d.map{|w|w.b.sub! /(#{x[0...i]})(.)(#{x[i..-1]})/,'\1(\2)\3'if w[i]!=w[i+1]}}}
o.compact.sort_by{|w|[w.size,w.gsub(/[()]/,'')]}.uniq}

Answer 5

पर्ल 5, 210

कोड एक सॉर्ट किए गए सरणी में इनपुट को लोड करता है, और उस सरणी के सभी मानों के विरुद्ध प्रत्येक मान की जांच करता है जो 1 बाइट लंबे समय तक हैं।

map{@W=split//,$w=$_;map{@X=split//,$x=$_;if(@W+1==@X){$i=0;while($W[$i]eq$X[$i]&&$i<@W){$i++}$c=$X[$i];$e=substr($w,$i);print substr($w,0,$i)."($c)$e\n",if substr($x,$i+1)eq$e}}@D}@D=sort(map{s/[^\w]//g;lc}<>)

परीक्षा

$ perl dictionairy_same_words.pl dictionairywords.txt
ca(r)t
in(p)lay
ma(r)
ma(t)
mar(t)
ma(r)t
(c)ode
ver(s)ify

Answer 6

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

import Data.List
import Data.Char
a#(b:c)=(a,b,c)
g a=[l++'(':m:')':n|x<-a,((l,m,n):_)<-[[o|o@(i,j,k)<-zipWith(#)(inits x)$init$tails x,elem(i++k)a]]]
f=sortOn length.g.map(filter isLetter.map toLower)

मुझे यकीन नहीं है कि इनपुट प्रारूप की अनुमति क्या है। fतार की एक सूची लेता है। केवल एक ही स्ट्रिंग (nl अलग शब्दों के साथ) की अनुमति दी है, जोड़ने .linesके लिए f(+6 बाइट्स)।

उपयोग उदाहरण:

f ["cat","cart","code","golf","od-e","verify","versify","on","s-o-n","Scrapped","scraped"]

["(s)on","ca(r)t","(c)ode","ver(s)ify","scra(p)ped"]

यह कैसे काम करता है: हर शब्द को लोअरकेस में बदल दें और केवल अक्षरों को रखें। प्रत्येक शब्द xको हर संभव स्थिति में दो भागों में विभाजित करें और त्रिकोणीय बनाएं (i,j,k)जहां iपहला भाग है, jदूसरे भाग का पहला चरित्र है और दूसरे भाग kकी पूंछ है। i++kशब्द सूची में दिखाई देने वाले त्रिगुणों को भी रखें । यदि यह सूची गैर-रिक्त है, तो पहला तत्व लें, इसे कॉल करें (l,m,n)। उन सभी सूची शीर्षों को आवश्यक आउटपुट स्वरूप में चारों ओर mसे ()घुमाएं lऔर उनके बीच रखें और n।