अल्फबेट्री बनाएं

Question

निम्नलिखित वर्णमाला को शब्दों की क्रमबद्ध सूची पर विचार करें:

balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom

सभी शब्दों के साथ शुरू होता है b, और पहले 5 के साथ शुरू होता है bal। अगर हम पहले 2 शब्दों को देखें:

balderdash
ballet

हम इसके बजाय लिख सकते हैं:

balderdash
  +let

जहाँ ' 'एक शब्द का प्रयोग किया जाता है जहाँ एक शब्द पिछले शब्द के साथ एक उपसर्ग वर्ण साझा करता है; '+'चरित्र को छोड़कर जो कि LAST वर्ण को इंगित करता है जहां दूसरा शब्द पिछले शब्द के साथ एक उपसर्ग साझा करता है।

यह एक प्रकार का 'ट्राइ' विज़ुअलाइज़ेशन है: अभिभावक ' bal' है, और इसके 2 वंशज हैं: 'derdash'और 'let'।

एक लंबी सूची के साथ, जैसे:

balderdash
ballet
brooding

हम इसके अतिरिक्त पाइप चरित्र '|'का उपयोग यह स्पष्ट करने के लिए कर सकते हैं कि साझा उपसर्ग कहाँ समाप्त होता है:

balderdash
| +let
+rooding

और समतुल्य वृक्ष के 'b'दो बच्चे होने की एक जड़ होगी : उप-मूल जड़ 'al'और उसके दो बच्चे 'derdash'और 'let'; और 'rooding'।

यदि हम इस रणनीति को अपनी मूल सूची में लागू करते हैं,

balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom

हमें ऐसा आउटपुट मिलता है जो दिखता है:

balderdash    
| +let     
|  +oonfish
|   | +ist 
|   +t     
+rooding   
   +m 

यदि सूची में लगातार दो शब्दों का कोई साझा उपसर्ग नहीं है, तो कोई विशेष वर्ण प्रतिस्थापित नहीं किए जाते हैं; सूची के लिए उदाहरण:

broom
brood
crude
crumb

हम उत्पादन चाहते हैं:

broom
   +d
crude
  +mb

इनपुट

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

उत्पादन

आपके आउटपुट में प्रति पंक्ति या कुल मिलाकर व्हॉट्सएप हो सकता है, लेकिन कोई भी प्रमुख व्हाट्सएप नहीं है। तार या समान की एक सूची भी स्वीकार्य होगी।

यह कोड-गोल्फ है ; प्रत्येक भाषा में सबसे छोटा कोड डींग मारने का अधिकार रखता है। खामियों के खिलाफ सामान्य निषेध लागू होते हैं।

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

Input:
apogee
apology
app
apple
applique
apply
apt

Output:
apogee     
 |+logy    
 +p        
 |+le      
 | +ique   
 | +y      
 +t        

Input:
balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom
donald
donatella
donna
dont
dumb

Output:
balderdash 
| +let     
|  +oonfish
|   | +ist 
|   +t     
+rooding   
   +m      
donald     
| |+tella  
| +na      
| +t       
+umb 

Comments

क्या इस मामले में जहां मैं शब्द के बारे में ballके बाद balloon। हमें किस आउटपुट की उम्मीद करनी चाहिए?

— डॉन थाउजेंड

@RushabhMehta मैं अनुमान लगा रहा हूं कि आपके पास बस +पहले से कम होगा o, लेकिन मैंने चुनौती नहीं लिखी, इसलिए मुझे यकीन नहीं है।

— थियो

@RushabhMehta शब्द वर्णानुक्रम में क्रमबद्ध हैं, इसलिए ऐसा नहीं होगा।

— नील

@ नील ओह अच्छा बिंदु

— डॉन थाउजेंड

इनपुट में शब्द केवल अल्फ़ान्यूमेरिक्स से बने होंगे : क्या इसमें वास्तव में अंक शामिल हैं, या क्या आपका मतलब अल्फ़ाबेटिक है?

— अरनौलड

Answer 1

रेटिना 0.8.2 , 58 57 बाइट्स

^((.*).)(?<=\b\1.*¶\1)
$.2$* +
m)+`^(.*) (.*¶\1[+|])
$1|$2

इसे ऑनलाइन आज़माएं! लिंक में एक परीक्षण मामला शामिल है। संपादित करें: @FryAmTheEggman के लिए सहेजी गई 1 बाइट धन्यवाद उनका कहना है कि मैं से एक स्विच की अनदेखी \bकरने के लिए ^द्वारा ही संभव बनाया m)। स्पष्टीकरण:

m)

^पूरे कार्यक्रम के लिए प्रति-पंक्ति चालू करें ।

^((.*).)(?<=^\1.*¶\1)
$.2$* +

प्रत्येक शब्द के लिए, पिछले शब्द की शुरुआत से यथासंभव मिलान करने का प्रयास करें। अंतिम वर्ण को छोड़कर, मैच को रिक्त स्थान में बदलें, जो कि एक बन जाता है +।

+`^(.*) (.*¶\1[+|])
$1|$2

बार-बार +एस या |एस के ऊपर के सभी रिक्त स्थान को तुरंत बदल दें |।

Comments

@FryAmTheEggman वास्तव में, मैंने m)विशेष रूप से इसे करने में सक्षम होने के लिए जोड़ा , इसलिए मैं नाराज हूं कि मैं एक उदाहरण से चूक गया।

— नील

उह, अगर मैं लोगों को सिर्फ हटाने जा रहा हूं तो मैं टिप्पणियों का जवाब देने से भी क्यों कतराता हूं ...

— नील

Answer 2

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

पात्रों की सूची की अपेक्षा करता है और उनकी वापसी करता है।

a=>a.map((w,y)=>a[~y]=w.map(m=(c,x)=>(p=a[y-1]||0,m|=c!=p[x])?c:p[x+1]==w[x+1]?' ':(g=y=>a[y][x]<1?g(y+1,a[y][x]='|'):'+')(-y)))

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

कैसे?

+क्रम में पहले से अंतिम शब्द तक घूमकर स्पेस और डाला जा सकता है, लेकिन एक बार पहचाने जाने के बाद| केवल पोस्टीरियर डाला जा सकता है +। यह दो अलग-अलग पास करके प्राप्त किया जा सकता है, लेकिन इसके बजाय हम प्रत्येक संशोधित प्रविष्टि के लिए एक पॉइंटर को सहेजते हैं a[~y]ताकि बाद में उसी map()लूप के भीतर इसे फिर से अपडेट किया जा सके ।

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

a =>                           // a[] = input array
  a.map((w, y) =>              // for each word w at position y in a[]:
    a[~y] =                    //   save a pointer to the current entry in a[~y]
    w.map(m =                  //   initialize m to a non-numeric value
      (c, x) => (              //   for each character c at position x in w:
        p = a[y - 1] || 0,     //     p = previous word or a dummy object
        m |= c != p[x]         //     set m = 1 as soon as w differs from p at this position
      ) ?                      //     if w is no longer equal to p:
        c                      //       append c
      :                        //     else:
        p[x + 1] == w[x + 1] ? //       if the next characters are still matching:
          ' '                  //         append a space
        : (                    //       else:
            g = y =>           //         g() = recursive function to insert pipes
            a[y][x] < 1 ?      //           if a[y][x] is a space:
              g(               //             do a recursive call to g()
                y + 1,         //               with y + 1
                a[y][x] = '|'  //               and overwrite a[y][x] with a pipe
              )                //             end of recursive call
            :                  //           else:
              '+'              //             make the whole recursion chain return a '+'
                               //             which will be appended in the current entry
          )(-y)                //         initial call to g() with -y (this is ~y + 1)
    )                          //   end of map() over the characters
  )                            // end of map() over the words

Comments

क्या आप मेरे समाधान को देखेंगे, मैं स्वयं इसे लेकर आया था लेकिन यह आपके समाधान की याद दिलाता है। तो अगर इसके बहुत करीब आप इसे अपने (या नहीं) के रूप में प्रस्तुत कर सकते हैं और इसे हटा सकते हैं :)

— डैनियलइंडाइ

@DanielIndie कोई चिंता नहीं। यह काफी अलग है।

— अरनौलड

Answer 3

जावास्क्रिप्ट (Node.js) , 125 122 118 117 बाइट्स

a=>a.map((w,i)=>a[i]=w.map((T,k)=>+i&&l[k]==T?l[-~k]<w[-~k]?(g=_=>a[--i][k]<"+"?g(a[i][k]="|"):"+")():" ":(i=l=w,T)))

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

• tio परीक्षण के लिए @Arnauld को धन्यवाद :)

Answer 4

पायथन, 263 260 बाइट्स

- 3 बाइट जोनाथन फ्रेच को धन्यवाद

कोड:

p=lambda t,f,g:"\n".join([(f[:-1]+"+"if(a!=min(t))*g else"")+a+p(t[a],(f+" "if len(t[a])>1or a==max(t)else f[:-1]+"| "),1)for a in t])if t else""
def a(t,x):
 if x:c=x[0];t[c]=c in t and t[c]or{};a(t[c],x[1:])
def f(*s):t={};[a(t,i)for i in s];return p(t,"",0)

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

स्पष्टीकरण:

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

{'b': {'a': {'l': {'d': {'e': {'r': {'d': {'a': {'s': {'h': {}}}}}}}, 'l': {'e': {'t': {}}, 'o': {'o': {'n': {'f': {'i': {'s': {'h': {}}}}, 'i': {'s': {'t': {}}}}}, 't': {}}}}}, 'r': {'o': {'o': {'d': {'i': {'n': {'g': {}}}}, 'm': {}}}}}}

पी फ़ंक्शन इस संरचना के माध्यम से पुनरावृत्ति करता है और चुनौती द्वारा अपेक्षित त्रिक के स्ट्रिंग प्रतिनिधित्व को उत्पन्न करता है। F फ़ंक्शन तर्कों के रूप में स्ट्रिंग्स का एक गुच्छा लेता है, उन सभी को a के साथ trie में जोड़ता है, फिर trie पर कॉलिंग p का परिणाम देता है।

Comments

252 बाइट्स संभव ।

— जोनाथन फ्रैच

Answer 5

सी (जीसीसी) , 165 155 बाइट्स

तीन तर्क देते हैं:

• char** a : शून्य-समाप्त शब्दों की एक सरणी
• char* m : प्रत्येक शब्द की लंबाई का एक सरणी
• int n : सरणी में शब्दों की संख्या

f(a,m,n,i,j)char**a,*m;{for(i=n;--i;)for(j=0;j<m[i]&j<m[i-1]&a[i][j]==a[i-1][j];j++)a[i][j]=a[i][j+1]^a[i-1][j+1]?43:++i<n&j<m[i]&a[i--][j]%81==43?124:32;}

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

Comments

कुछ त्वरित जीत

— अरनौलड

@ अरनुलद बेशक! हालांकि ++i<n&j<m[i]&a[i--]अपरिभाषित व्यवहार नहीं है? क्या मैं जीसीसी पर इसका सही मूल्यांकन कर सकता हूं?

— कर्टिस बेचटेल

यह अपरिभाषित व्यवहार होने की बहुत संभावना है। लेकिन हम भाषाओं को उनके कार्यान्वयन से परिभाषित करते हैं, इसलिए जब तक यह gcc के इस संस्करण के साथ लगातार काम करता है, मुझे लगता है कि यह ठीक है।

— अरनौलद

Answer 6

पर्ल 6 , 149 144 142 बाइट्स

{1 while s/(\n.*)\s(.*)$0(\+|\|)/$0|$1$0$2/;$_}o{$=({.[1].subst(/^(.+)<?{.[0].index($0)eq 0}>/,{' 'x$0.ords-1~'+'})}for '',|$_ Z$_).join("
")}

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

मुझे यकीन है कि यह एक और अधिक हो सकता है, खासकर जब मैं regexes पर एक विशेषज्ञ नहीं हूँ। यह नील की रेटिना जवाब के रूप में एक ही प्रक्रिया का उपयोग करता है ।

Answer 7

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

def f(w,r=['']):
 for b,c in zip(w[1:],w)[::-1]:
	s='';d=0
	for x,y,z in zip(r[0]+b,b,c+b):t=s[-1:];s=s[:-1]+[['+'*(s>'')+y,t+' |'[x in'+|']][y==z],t+y][d];d=d|(y!=z)
	r=[s]+r
 return[w[0]]+r

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

Answer 8

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

->a{i=1;a.map{s="";a[i+=j=-1].chars{|c|a[i][j+=1]=i<0&&a[i-1][/^#{s+=c}/]?a[i+1][j]=~/[|+]/??|:?\s:c}[/[| ]\b/]&&=?+}}

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

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

व्याख्या

मूल स्ट्रिंग परिवर्तन बहुत जटिल नहीं है, लेकिन ऊर्ध्वाधर पाइपों को ठीक से सम्मिलित करने के लिए, हमें रिवर्स ऑर्डर में पुनरावृति करने की आवश्यकता है, और चूंकि reverseविधि काफी क्रियात्मक है, हम इसे एक पेचीदा तरीके से करेंगे। यहाँ, हम mapकेवल लूप को चलाने के लिए उपयोग करते हैं, पहले शब्द को अकेला छोड़ देते हैं, और फिर नकारात्मक सूचकांकों का उपयोग करके अंत से पुनरावृति करते हैं:

->a{
 i=1;                   #Initialize word indexer
 a.map{                 #Loop
  s="";                 #Initialize lookup string
  a[i+=j=-1]            #Initialize char indexer and decrement i
  .chars{|c|            #Loop through each char c of current word
   a[i][j+=1]=          #Mofify current word at position j 
    i<0&&               #If it's not the first word and
    a[i-1][/^#{s+=c}/]? #Word above matches current one from start to j
     a[i+1][j]=~/[|+]/? #Then if char below is | or +
      ?|:?\s:c          #Then set current char to | Else to Space Else leave as is
  }[/[| ]\b/]&&=?+      #Finally, replace Space or | at word boundary with +
 }
}