Başarılı kod golf başvuruları, doğası gereği her yerde çılgın sembollerle doludur. Gönderilmelerinin anlaşılmasını kolaylaştırmak için, birçok kod golfçü kodlarının bir açıklamasını eklemeyi seçer. Açıklamalarında, kod satırı dikey olarak patlatılmış bir şemaya dönüştürülür.

Örneğin, eğer bu benim kodumsa:

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

Oluşturabileceğim olası diyagramlardan biri şöyle görünür:

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

Amaç

Bu zorlukla, bir kod satırı alan ve açıklayıcı metnin kolayca eklenebileceği bir şema oluşturan bir açıklama otomatik biçimlendirme aracı yazacaksınız.

Bunu daha yararlı bir zorluk haline getirmek için , kullanıcı bir format dizesi sağlayarak her bir satırın içeriğini belirleyebilecektir. Biçimlendirme dizesi, yalnızca harfleri içeren A-Za-z, programla aynı uzunlukta olan ikinci bir satır olacaktır . Harfler açıklamada program karakterlerinin basılacağı sırayı gösterir.

İşte herhangi bir parantez benzeri biçimlendirmeden G / Ç örneği :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

Parantez

Programdaki birden fazla karakter aynı öncelik seviyesine sahipse, bu karakter kümesi tek bir kod bloğu (bir grup oluştururlarsa) veya bir küme parantezi (aralarında başka karakterler içeriyorsa) görevi görür. Genel kurallar basit:

1. Karakterler, diyagramdaki bir çizgide görünmüyor, diğer tüm öncelikli karakterler zaten çizgideki çizgilerin üzerinde göründü.

2. Eşit öncelikli karakterler her zaman aynı satırlara yazdırılır. Bir satırda belirli bir karakter görünürse, satırda eşit önceliğe sahip diğer tüm karakterler görünür.

3. Her satırda, içine alınmış tüm diğer karakterler en az bir kez görünene kadar eşit öncelikli bir karakter kümesi görünmeye devam eder. Bu, "braket benzeri" yapılara izin verir. Eğer bceaböncelikler, o bkarakterleri (onlar ikinci en yüksek önceliktir) ikinci satırında görünecek ve tüm kadar görünmeye devam eder ceakarakterler ortaya çıkmıştır. Öncelik dizesi ise abcadeafga, bcdefgiçindeki her şeyin içinde bulunduğu kabul edilir, abelirene kadar 4 sn de görünmeye devam eder g.

Daha fazla biçimlendirme gereksinimi

Tüm çıktı çizgileri, aynı boşlukta olmalı (giriş çizgilerinin uzunluğu), boşluklarla doldurulmalıdır. Giriş program satırında boşluklar bulunabilir, ancak bu alanlara da öncelikli bir mektup verilecektir. Çıkış / giriş üzerindeki son satırlar isteğe bağlıdır.

puanlama

Bu kod golf, en az bayt kazanıyor.

Örnekler

İşte daha karmaşık biçimlendirmeli bir kod parçasının yorumlanmış bir örneği.

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

Perl'deki bir örnek:

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

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

Martin Büttner'in izniyle CJam'da birkaç örnek:

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$}*}/

İşte sadece seninle uğraşmak için çılgın bir örnek:

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

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

İşte parantez gibi üst üste geldiğinde ne olacağını daha açık bir örnek abab. (Normalde, açıklamanızı biçimlendirmeyi seçtiğiniz yol bu değildir.)

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.

Pyth, 33 40 bayt

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

Çevrimiçi deneyin: Pyth Compiler / Executor

Açıklama:

Dize ile oluşturulan 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

Yani ilk giriş satırı, zikinci giriş satırı J.

Döngü J, sıralı ve tüm kopyalar olmadan tüm karakterlerin üzerinde yinelenir . Mevcut karaktere denir H.

Sonra her biri için Ybir JI muhabir kömürü yazdırmak zaşağıdaki koşulların her ikisi de memnun eğer bağlı veya boşluk:

• Y <= H(satırda önce bir karakter belirir H)
• (parantez) d >= Hile başlayan ve biten bir blokta görünen bir karakter var Y.

Örnekler

Giriş dördüncü hattı ne kadar bu Şekil abcdaeb, abcdaebbasılır. Dördüncü satır, olası davaların çoğu gerçekleştiği için iyi bir temsildir:

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

Ve bir test vakasına dayanan başka bir örnek, @Optimizer verdi. (bu benim 33 çözümü mahvetti).

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

Eski versiyon: 58 57 52 bayt

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

Çevrimiçi deneyin: Pyth Compiler / Executor

Bu, her satırı yazdırmadan önce ve sonra değiştireceğim bir maske oluşturur. Daha fazla bilgi için düzenleme geçmişine bakın.

CJam, 82 bayt

Şu anda oldukça uzun ve sanırım bir kaç baytı daha tıraş edebilirim.

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

Algoritma

Temel algoritma aşağıdaki gibidir:

• leel:F]z::+ : Her karakterin kodunu, formatını ve dizinini birlikte gruplayın
• F$_&\f{{W=1$=},\;}: Yukarıdaki üçlüyü, biçimlendirme dizesini kullanarak yazdırma önceliğine göre gruplandırın. Bu kod aynı zamanda önceliklerin sıralanmasını sağlar.
• ]_{0f=_W=),\0=>Lf&Ra#)},: Her öncelikli üçlü grubu için sınırlayıcı indeks aralığını alın ve henüz indeks yazdırılmadığını kontrol edin. Baskısız bir dizin varsa, bu öncelik grubunu "bu adımda yazdırılacak" gruba ekleyin.
• F,S*\:+{~;1$L+:L;t}%oNo~}%: Bu adımda tüm grupların yazdırılmasını sağladıktan sonra, kodu bir boş alan dizesinin doğru dizinine doldurun ve sonra o dizeyi yazdırın. Ayrıca, basılı dizinlerin listesini içeren diziyi güncelleyin.

Bu golf oynamak bittiğinde izlenmesi gereken kod açıklaması.

Örnek

İşte kodun üzerinde çalışan kod:

Giriş:

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

Çıktı:

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

Burada çevrimiçi deneyin

CJam, 48 bayt

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

açıklama

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.

IDL 8.4, 316 318 304 bayt

Yeni sürüm, hala çok uzun, ama daha kısa! Ve, IDL'nin gerçek ruhu içinde, tamamen vektörleştirildi, bu da (döngü için olmadığından) şimdi bir satır olarak yapabileceğim ve kendi üzerinde çalıştırabileceğim anlamına gelir; sürümüm 8.4'e yükseltildikten sonra. Bu daha sonra düzenlenecek.

Bir satır versiyonu:

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

Satır sonları ile (aynı bayt sayısı, \ n vs & subbing) ve yorum yapıldı:

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

İşte satır 9 için algoritmik bir döküm:

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)

... ve 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. ve 10. satırlar gerçek işi yapar, geri kalanı ise ihtiyaç duyduğunuz değişkenleri ayarlar. Bunun alacağı kadar golf ile ilgili olduğunu düşünüyorum, daha iyisini yapacak başka bir yer bulamıyorum.

Eski versiyon (buradaki her şey güncel değil):

Bu kazanmak için yeterince kısa bir yer değil, çünkü bu korkunç bir golf dili, ancak IDL'de hiç kimse cevap vermiyor, bu yüzden sadece bunun için gideceğim.

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

Daha fazla kesebileceğim bir yol olup olmadığından emin değilim ... Aynı anda hem a hem de b için strmid çağırabilirim, ancak daha sonra d indeksleme için daha fazla bayt harcıyorum ve aynı şekilde çalışıyor. Yine de üzerinde çalışmaya devam edeceğim! (Ve yarın algoritmanın bir açıklamasını düzenleyeceğim.)