कोड स्पष्टीकरण फ़ॉर्मेटर


32

सफल कोड गोल्फ प्रस्तुतियाँ, स्वभाव से, सभी जगह पागल प्रतीकों से भरी हैं। उनके प्रस्तुतिकरण को समझने में आसान बनाने के लिए, कई कोड-गोल्फर अपने कोड की व्याख्या शामिल करना चुनते हैं। उनके स्पष्टीकरण में, कोड की रेखा एक ऊर्ध्वाधर विस्फोटित आरेख में बदल जाती है।

उदाहरण के लिए, यदि यह मेरा कोड था:

1_'[3:~2@+]`

मेरे द्वारा बनाए जा सकने वाले कई संभावित आरेखों में से एक इस तरह दिखाई देगा:

1           
 _'         
   [      ] 
   [3:    ] 
   [  ~   ] 
   [   2@ ] 
   [     +] 
           `

लक्ष्य

इस चुनौती में, आप एक स्पष्टीकरण ऑटो-स्वरूपण उपकरण लिखेंगे जो कोड की एक पंक्ति लेता है और एक आरेख बनाता है जिसमें व्याख्यात्मक पाठ आसानी से जोड़ा जा सकता है।

इसे और अधिक उपयोगी चुनौती बनाने के लिए, उपयोगकर्ता एक प्रारूपण स्ट्रिंग प्रदान करके, प्रत्येक पंक्ति की सामग्री को निर्दिष्ट करने में सक्षम होगा। स्वरूपण स्ट्रिंग एक दूसरी पंक्ति होगी, जिसमें केवल अक्षर होंगे A-Za-z, जो कि प्रोग्राम की समान लंबाई है। पत्र उस क्रम को दिखाते हैं जिसमें कार्यक्रम के पात्रों को स्पष्टीकरण में मुद्रित किया जाना चाहिए।

यहाँ I / O का उदाहरण बिना किसी ब्रैकेट के स्वरूपण के बिना दिया गया है :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

कोष्ठक

यदि कार्यक्रम में एक से अधिक वर्णों का समान प्राथमिकता स्तर है, तो वर्णों का वह समूह कोड के एकल खंड (यदि वे एक समूह बनाते हैं) या कोष्ठक का एक समूह (यदि उनके बीच में अन्य वर्ण हों) के रूप में कार्य करता है। सामान्य नियम सरल हैं:

  1. वर्ण आरेख की एक पंक्ति में दिखाई नहीं देते हैं जब तक कि अधिक प्राथमिकता के अन्य सभी वर्ण पहले से ही रेखा के ऊपर आरेख में दिखाई नहीं देते हैं।

  2. समान प्राथमिकता के वर्ण हमेशा एक ही तर्ज पर मुद्रित होते हैं। यदि एक निश्चित वर्ण एक रेखा पर दिखाई देता है, तो समान प्राथमिकता के अन्य सभी वर्ण रेखा पर दिखाई देते हैं।

  3. समान प्राथमिकता वाले वर्णों का एक सेट प्रत्येक पंक्ति पर तब तक प्रदर्शित होता रहता है जब तक कि उसके द्वारा संलग्न अन्य सभी अक्षर कम से कम एक बार प्रकट न हो जाएं। यह "ब्रैकेट-जैसे" निर्माणों के लिए अनुमति देता है। यदि bceabप्राथमिकताएं हैं, तो bवर्ण दूसरी पंक्ति में दिखाई देंगे (वे दूसरी-सर्वोच्च प्राथमिकता हैं) और तब तक दिखाई देते रहेंगे जब तक कि सभी ceaवर्ण प्रकट नहीं हो जाते। यदि प्राथमिकता स्ट्रिंग है abcadeafga, तो सभी को bcdefgइसके भीतर समाहित माना जाता है, सभी 4 as तब तक दिखाई देते रहेंगे जब तक कि gयह दिखाई न दे।

अधिक स्वरूपण आवश्यकताओं

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

स्कोरिंग

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


उदाहरण

यहां अधिक जटिल प्रारूपण के साथ कोड के एक टुकड़े का एक उदाहरण दिया गया है।

1_'[3:~2@+]`
abbcddeffgch

1            #highest priority is denoted by the lowercase letter a
 _'          #priority b
   [      ]  #all characters with priority c
   [3:    ]  #priority d, but priority c still printed because it encloses more
   [  ~   ]  #priority e
   [   2@ ]  #priority f
   [     +]  #priority g, last line of c because all enclosed characters have appeared
           ` #priority h

पर्ल में एक उदाहरण:

$_=<>;s/[^aeiou\W]/$&o$&/gi;print
aaaaaabbccccccccccbdddddbbbbeeeee

$_=<>;                           
      s/          /     /gi;     
      s/[^aeiou\W]/     /gi;     
      s/          /$&o$&/gi;     
                            print

मार्टिन बुर्टनर के सौजन्य से CJam में कुछ उदाहरण दिए गए हैं:

l~2*{_2%{3*)}{2/}?_p_(}g;
aabbcdddefffeeggeehhiiccj

l~                       
  2*                     
    {                 }g 
    {_2%              }g 
    {   {   }{  }?    }g 
    {   {3*)}{  }?    }g 
    {   {   }{2/}?    }g 
    {             _p  }g 
    {               _(}g 
                        ;

q{_eu'[,66>"EIOU"-#)g{'o1$}*}/
abcccddddddeeeeeeefgghiijjhhbb

q                             
 {                          }/
 {_eu                       }/
 {   '[,66>                 }/
 {         "EIOU"-          }/
 {                #         }/
 {                 )g       }/
 {                   {    }*}/
 {                   {'o  }*}/
 {                   {  1$}*}/

यहाँ आपके साथ खिलवाड़ करने का एक पागल उदाहरण है:

1_'[3:~2@+]`
azTABACBDCAT

   [ :    ] 
   [3: 2  ] 
   [3:~2 +] 
   [ :~ @+] 
  '        `
1           
 _          

जब ब्रैकेट ओवरलैप होता है तो क्या होता है, इसका अधिक स्पष्ट उदाहरण यहां दिया गया है abab। (आम तौर पर, यह वह तरीका नहीं है जिससे आप अपने विवरण को प्रारूपित करना चुनेंगे।)

aabbccddaaeebb
aabbccddaaeebb

aa      aa    
aabb    aa  bb
aabbcc  aa  bb
aabb  ddaa  bb
  bb      eebb #"aa" no longer appears because all of "bbccdd" have already appeared.

जवाबों:


14

पायथ, 33 40 बाइट्स

JwFHS{Js.e?@zk&gHYsm&gdH}d>_>JxJYx_JYJdJ

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

स्पष्टीकरण:

स्ट्रिंग के साथ उत्पन्न aabbbbbzccdeeegfffqhjiiikkpnmmllloooohec:

                                          implicit: z = first input line
Jw                                        J = second input line
  FHS{J                                   for H in sorted(set(J)):
        .e                             J    map each k,Y of enumerate(J) to:
        .e?                            J      .... if ... else ...
        .e @zk                        dJ      z[k] if ... else " "
                                              condition: 
        .e @zk gHY                    dJ        H >= Y
        .e @zk&                       dJ        and
        .e @zk     m                 JdJ        map each d of J to:
        .e @zk     m gdH             JdJ          d >= H
        .e @zk     m&                JdJ          and
        .e @zk     m    }d           JdJ          d in ...
        .e @zk     m          xJY    JdJ          index of Y in J
        .e @zk     m        >J       JdJ          substring of J (from index to end)
        .e @zk     m       _         JdJ          reverse substring
        .e @zk     m             x_JYJdJ          index of Y in reversed J
        .e @zk     m      >          JdJ          substring of reversed (from index to end)
        .e @zk    s                   dJ       sum up the booleans (acts as any)
       s                                    sum up the chars and print

तो पहली इनपुट लाइन है z, दूसरी इनपुट लाइन है J

लूप Jक्रमबद्ध क्रम में और डुप्लिकेट के बिना सभी वर्णों पर प्रसारित होता है । वर्तमान वर्ण कहा जाता है H

इसके बाद, जब मैं निम्नलिखित स्थितियों में से दोनों संतुष्ट हो जाता है, पर निर्भर करता है, तो प्रत्येक Yके लिए Jमैं zएक व्हाट्सएप के संवाददाता चार्ट को प्रिंट करता हूं :

  • Y <= H(एक लाइन में पहली बार दिखाई देता है H)
  • एक चार है d >= H, जो Y(कोष्ठक) के साथ शुरू और समाप्त होने वाले ब्लॉक में दिखाई देता है ।

उदाहरण

यह दिखाता है कि इनपुट के आगे लाइन abcdaeb, abcdaebछपा है। चौथी पंक्ति एक अच्छा प्रतिनिधित्व है, क्योंकि अधिकांश संभावित मामले होते हैं:

code input:  "abcdaeb"
order input: "abcdaeb"

printing the fourth line, H = "d":

   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")
   "c" are not printed, because neither "d" nor "e" (chars >= "d") are not in "c"
   "d" is printed, because "d" <= "d" and ("d" >= "d" and "d" is in "d")
   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "e" is not printed, because "e" > "d"
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")

therefore the fourth line is: aabb__ddaa__bb

और एक अन्य उदाहरण एक टेस्ट-केस के आधार पर, @ ऑप्टिमाइज़र ने मुझे दिया। (जो मेरे 33 समाधान को नष्ट कर दिया)।

code input:  "acab"
order input: "acab"

printing the second line, H = "b":

   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "c" is not printed, because "c" > "b"
   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "b" is printed, because "b" <= "b" and ("b" >= "b" and "b" is in "b")

therefore the second line is: a_ab

पुराना संस्करण: 58 57 52 बाइट्स

JwKNFHS{J=K.e?eS>_>JxJHx_JHqYH@KkJs.e?@zknYNdK=KXKHN

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

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


8

सीजेएम, 82 बाइट्स

वर्तमान में बहुत लंबा है और मुझे लगता है कि मैं कुछ और बाइट्स को हटा सकता हूं।

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];

कलन विधि

बुनियादी एल्गोरिथ्म निम्नलिखित है:

  • leel:F]z::+ : कोड, स्वरूपण और प्रत्येक वर्ण के सूचकांक को एक साथ समूहित करें
  • F$_&\f{{W=1$=},\;}: स्वरूपण स्ट्रिंग का उपयोग करके मुद्रण के प्राथमिकता में उपरोक्त तीन गुटों को समूहित करें। यह कोड यह भी सुनिश्चित करता है कि प्राथमिकताएँ क्रमबद्ध हैं।
  • ]_{0f=_W=),\0=>Lf&Ra#)},: प्रत्येक प्राथमिकता समूह के ट्रिपल के लिए, बाउंडिंग इंडेक्स रेंज प्राप्त करें और देखें कि क्या कोई इंडेक्स अभी तक प्रिंट नहीं हुआ है। यदि कोई अनएन्डरेड इंडेक्स है, तो इस प्राथमिकता समूह को "इस चरण में मुद्रित होने के लिए" समूह में शामिल करें।
  • F,S*\:+{~;1$L+:L;t}%oNo~}%: सभी समूहों को इस चरण में मुद्रित होने के बाद, कोड को एक खाली स्थान स्ट्रिंग के सही सूचकांक में भरें और फिर उस स्ट्रिंग को प्रिंट करें। इसके अलावा मुद्रित अनुक्रमित की सूची वाले सरणी को अपडेट करें।

कोड स्पष्टीकरण का पालन तब किया जाता है जब मैं इसे गोल्फ कर रहा हूं।

उदाहरण

यहाँ कोड पर ही कोड चलाया जाता है:

इनपुट:

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];
aaabbbcccccdddddeefgghhiffggejkklmmmnoooopppqrrrssssllttttuuuvwwxxxxxxxyvvzzzzjjjj

आउटपुट:

lee                                                                               
   l:F                                                                            
      ]z::+                                                                       
           F$_&\                                                                  
                f{          }                                                     
                f{{     },  }                                                     
                f{{W=   },\;}                                                     
                f{{W=1$ },\;}                                                     
                f{{W=  =},\;}                                                     
                             {                                                }%];
                             {]_                                              }%];
                             {  {                   },                        }%];
                             {  {0f=                },                        }%];
                             {  {   _               },                        }%];
                             {  {    W=),           },                        }%];
                             {  {        \0=        },                        }%];
                             {  {           >       },                        }%];
                             {  {            Lf&    },                        }%];
                             {  {               Ra#)},                        }%];
                             {                        F,S*                    }%];
                             {                            \:+                 }%];
                             {                               {          }%    }%];
                             {                               {~;        }%    }%];
                             {                               {  1$L+:L; }%    }%];
                             {                               {         t}%    }%];
                             {                                            oNo~}%];

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


oNoTIOn में प्रतिस्थापित किया जा सकता है ।
फल

8

सीजेएम, 48 बाइट्स

ll:i:T.{___T#TW%@#~T<>+:e>)1$-@*123Se]m>}z_|(;N*

व्याख्या

l                                                Code.
 l                                               Priority.
  :i                                             Convert priority to integer.
    :T                                           Save to T.
      .{                                }        For corresponding items:
      .{___                             }        Copy the current priority 3 times.
      .{   T#                           }        First position with this priority.
      .{     TW%                        }        Reverse T.
      .{        @#                      }        First (last) position with this priority.
      .{          ~T<                   }        Cut T at the end of this priority.
      .{             >                  }        Cut at the beginning of this priority.
      .{              +                 }        Insert the current priority to
                                                 prevent the array being empty.
      .{               :e>              }        Array maximum.
      .{                  )1$-          }        Count of integers between the current
                                                 priority and the maximum, inclusive.
      .{                      @*        }        That number of the current character.
      .{                        123Se]  }        Fill irrelevant priorities with spaces.
      .{                              m>}        Rotate the array to make non-spaces
                                                 starting at the current priority.
                                                 Returns a column containing 123 items.
                                         z       Zip to get the rows from columns.
                                          _|     Remove duplicate rows, including
                                                 unused priorities and all-space rows.
                                            (;   Remove the first row (an all-space row).
                                              N* Insert newlines.

6

आईडीएल 8.4, 316 318 304 बाइट्स

नया संस्करण, अभी भी बहुत लंबा है, लेकिन छोटा है! और, IDL की सच्ची भावना में, पूरी तरह से सदिश, जिसका अर्थ है (क्योंकि लूप के लिए कोई नहीं है) जो कि अब मैं इसे एक पंक्ति के रूप में कर सकता हूं, और इसे अपने आप चला सकता हूं, एक बार जब मुझे अपना संस्करण पूरी तरह से 8.4 में अपग्रेड हो जाता है। इसे बाद में संपादित किया जाएगा।

एक पंक्ति संस्करण:

c=(f='')&read,c,f&l=[0:strlen(f)-1]&c=strmid(c,l,1)&s=strmid(f,l,1)&u=s.uniq()&k=value_locate(u,s)&n=[0:max(k)]&d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))&print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)&end

पंक्ति विराम के साथ (बाइट्स की एक ही संख्या, सबबिंग \ n बनाम), और टिप्पणी की:

c=(f='') ;initialize code and format as strings
read,c,f ;read two lines of input from the prompt
l=[0:strlen(f)-1] ;index array for the strings
c=strmid(c,l,1) ;split the code string into an array, via substrings of length 1
s=strmid(f,l,1) ;same for the format string, saving f for regex later
u=s.uniq() ;get the sorted unique values in the format string (sorts A->a)
k=value_locate(u,s) ;assign layer values to the format characters
n=[0:max(k)] ;index array for the unique format characters
d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))
print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)
end ;end the script

यहाँ लाइन 9 के लिए एक एल्गोरिदम का टूटना है:

r=stregex(y,'('+x+'(.*))?'+x,len=w) ; r, w = starting position & length of substring in y {format string} bracketed by x {character} (inclusive)
z[(r=...):r+w-1] ; grab a slice of z {layer array} from r to r+w-1 -> layer values for each character in the substring
max(z[...]) ; max layer (depth) of any characters in that slice
u.map(lambda(x,y,z:max(...)),f,k) ;map an inline function of the above to every element of the unique-formatting-character array
d=hash(n,u.map(...)) ; create a hash using the unique indices, the result is a hash of (character:max_substring_depth)

... और 10:

x+(d[l[i]]ge n?c[i]:' ')) ; ternary concatenation: if maxdepth for this character >= current depth, add the character, otherwise add ' '
i.reduce(lambda(x,i,c,d,l,n:...)),,l,c,d,n) ;accumulate elements of i {code/format index array} by passing them through the inline ternary concatenation function
print,n.map(lambda(n,l,c,d,i:i.reduce(...)),k,c,d,l) ;map the depth index through the reduction, ending up with a string for each depth layer, then print it

लाइन्स 9 और 10 असली काम करते हैं, बाकी यह उन चर को सेट करता है जिनकी आपको अंत में आवश्यकता होती है। मुझे लगता है कि यह गोल्फ के बारे में है क्योंकि यह मिलने वाला है, मैं इसे बेहतर करने के लिए कहीं और नहीं मिल सकता।

पुराना संस्करण (नीचे सब कुछ पुराना है):

यह जीतने के लिए काफी कम है, क्योंकि यह एक भयानक गोल्फ भाषा है, लेकिन कोई भी आईडीएल में कभी जवाब नहीं देता है इसलिए मैं बस इसके लिए जाने वाला हूं।

a=(b='')
read,a,b
c=[0:strlen(b)-1]
d=strmid(b,c,1)
a=strmid(a,c,1)
e=d[uniq(d,sort(d))]
f=list(value_locate(e,d),/e)
s=hash()
for i=0,max(f)do begin
g=stregex(b,'('+e[i]+'(.*))?'+e[i],l=l)
s[i]=max(f[g:g+l-1])
print,f.reduce(lambda(x,y,z:x+(s.haskey(y)?z[y]:' '),s,a)
s=s.filter(lambda(x,y:x[1]gt y),i)
endfor
end

मुझे यकीन नहीं है कि अगर कोई रास्ता है तो मैं इसे और अधिक कटौती कर सकता हूं ... मैं एक ही समय में बी और बी दोनों पर स्ट्रैमिड कह सकता हूं, लेकिन फिर मैं डी को अनुक्रमित करने के लिए अधिक बाइट्स खर्च करता हूं और यह समान काम करता है। मैं उस पर काम करता रहूँगा, हालाँकि! (और कल मैं एल्गोरिथ्म के स्पष्टीकरण में संपादित करूँगा।)

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.