কোড ব্যাখ্যার বিন্যাস


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মধ্যে সমস্তগুলি এর মধ্যে রয়েছে বলে মনে করা হয়, সমস্ত aপ্রদর্শিত 4 টি প্রদর্শিত না হওয়া পর্যন্ত উপস্থিত থাকবে g

আরও ফর্ম্যাটিং প্রয়োজনীয়তা

আউটপুটটির সমস্ত লাইন একই দৈর্ঘ্য (ইনপুট লাইনের দৈর্ঘ্য) হওয়া উচিত, প্রয়োজনীয় স্থানগুলির সাথে প্যাড করা। ইনপুট প্রোগ্রাম লাইনে স্পেস থাকতে পারে, যদিও এই স্পেসগুলিকে একটি অগ্রাধিকার চিঠিও দেওয়া হবে। আউটপুট / ইনপুট নেভিগেশন ট্রেলিং নিউলাইনগুলি areচ্ছিক।

স্কোরিং

এটি কোড গল্ফ, সবচেয়ে কম বাইট জেতা।


উদাহরণ

আরও জটিল ফর্ম্যাটিং সহ কোডের একটি অংশের মন্তব্য করা উদাহরণ এখানে।

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

মার্টিন বাটনার সৌজন্যে সিজেমে কয়েকটি উদাহরণ এখানে রইল:

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

এবং একটি পরীক্ষা-মামলার উপর ভিত্তি করে অন্য একটি উদাহরণ, @ অপ্টিমাইজার আমাকে দিয়েছেন। (যা আমার ৩৩ টি সমাধান ধ্বংস করে দিয়েছে)।

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~}%];

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


oNoসঙ্গে প্রতিস্থাপিত হতে পারে nমধ্যে Tio
এএসওলিং ফল 19

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 বাইট

নতুন সংস্করণ, এখনও অনেক দীর্ঘ, তবে খাটো! এবং, আইডিএলের সত্যিকারের চেতনায়, সম্পূর্ণরূপে ভেক্টরাইজড, যার অর্থ (যেহেতু লুপের জন্য কিছুই নেই) যে আমি এখন এটি একটি লাইন হিসাবে করতে পারি এবং নিজেই চালাতে পারি, একবার আমার সংস্করণটি সম্পূর্ণরূপে 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

আমি এটিকে আরও কেটে ফেলার কোনও উপায় নেই কিনা তা নিশ্চিত নই ... আমি একই সাথে ক এবং বি উভয়কেই স্ট্রিমিড কল ​​করতে পারি তবে আমি আরও বাইট ইনডেক্সিং ব্যয় করি এবং এটি একইরকম কার্যকর হয়। যদিও আমি এর উপর কাজ চালিয়ে যাব! (এবং আগামীকাল আমি অ্যালগরিদমের ব্যাখ্যাতে সম্পাদনা করব))

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