Le proposte di golf in codice di successo sono, per natura, piene di simboli pazzi in tutto il luogo. Per rendere più comprensibile la presentazione, molti golfisti del codice scelgono di includere una spiegazione del loro codice. Nella loro spiegazione, la linea di codice viene trasformata in un diagramma esploso verticalmente.

Ad esempio, se questo fosse il mio codice:

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

Uno dei tanti possibili diagrammi che potrei creare sarebbe simile al seguente:

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

L'obiettivo. il gol

In questa sfida, si scriverà uno strumento di formattazione automatica delle spiegazioni che accetta una riga di codice e crea un diagramma a cui è possibile aggiungere facilmente testo esplicativo.

Per rendere questa una sfida più utile , l'utente sarà in grado di specificare il contenuto di ogni riga, fornendo una stringa di formattazione. La stringa di formattazione sarà una seconda riga, contenente solo lettere A-Za-z, della stessa lunghezza del programma. Le lettere mostrano l'ordine in cui i caratteri del programma devono essere stampati nella spiegazione.

Ecco un esempio di I / O senza alcuna formattazione simile a parentesi :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

Parentesi

Se più di un carattere nel programma ha lo stesso livello di priorità, quell'insieme di caratteri agisce come un singolo blocco di codice (se formano un gruppo) o un insieme di parentesi (se contengono altri caratteri nel mezzo). Le regole generali sono semplici:

1. I caratteri non compaiono in una riga del diagramma fino a quando tutti gli altri caratteri con maggiore priorità non sono già comparsi sulle righe sopra di esso nel diagramma.

2. I caratteri di uguale priorità vengono sempre stampati sulle stesse linee. Se un certo personaggio appare su una linea, tutti gli altri personaggi di uguale priorità appaiono sulla linea.

3. Una serie di caratteri di uguale priorità continua ad apparire su ogni riga fino a quando tutti gli altri caratteri racchiusi da essa non sono comparsi almeno una volta. Ciò consente costruzioni "simili a parentesi". Se bceabsono le priorità, i bpersonaggi appariranno sulla seconda riga (sono la seconda priorità più alta) e continueranno ad apparire fino a quando tutti i ceapersonaggi non sono apparsi. Se la stringa di priorità è abcadeafga, allora tutti bcdefgsono considerati contenuti al suo interno, tutti i 4 as continueranno ad apparire fino a quando non gè apparso.

Ulteriori requisiti di formattazione

Tutte le linee di output devono avere la stessa lunghezza (la lunghezza delle linee di input), riempite con spazi necessari. La riga del programma di input può contenere spazi, anche se a questi spazi verrà assegnata una lettera prioritaria. Le nuove righe finali sull'output / input sono facoltative.

punteggio

Questo è il golf del codice, vince meno byte.

Esempi

Ecco un esempio commentato di un pezzo di codice con una formattazione più complessa.

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

Un esempio in Perl:

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

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

Ecco alcuni esempi in CJam, per gentile concessione di Martin Büttner:

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

Ecco un esempio folle solo per scherzare con te:

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

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

Ecco un esempio più esplicito di cosa succede quando le parentesi si sovrappongono abab. (Normalmente, questo non è il modo in cui sceglieresti di formattare la tua spiegazione.)

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 byte

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

Provalo online: Pyth Compiler / Executor

Spiegazione:

Generato con la stringa 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

Quindi la prima riga di input è z, la seconda riga di input è J.

Il ciclo scorre su tutti i caratteri Jin ordine e senza duplicati. Viene chiamato il carattere corrente H.

Quindi per ciascuna Ydi esse Jstampo il corrispondente carattere zo uno spazio bianco, a seconda che siano soddisfatte entrambe le seguenti condizioni:

• Y <= H(un carattere appare per primo nella riga H)
• c'è un carattere d >= H, che appare in un blocco che inizia e finisce con Y(parentesi).

Esempi

Questo dimostra come la quarta riga dell'ingresso abcdaeb, abcdaebviene stampato. La quarta riga è una buona rappresentazione, poiché la maggior parte dei casi possibili si verificano:

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

E un altro esempio basato su un test-case, mi ha dato @Optimizer. (che ha distrutto la mia soluzione 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

Vecchia versione: 58 57 52 byte

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

Provalo online: Pyth Compiler / Executor

Questo crea una maschera, che modificherò prima e dopo la stampa di ogni riga. Per ulteriori informazioni, consultare la cronologia delle modifiche.

CJam, 82 byte

Abbastanza a lungo attualmente e penso di potermi radere qualche byte in più.

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

Algoritmo

L'algoritmo di base è il seguente:

• leel:F]z::+ : Raggruppa il codice, la formattazione e l'indice di ciascun carattere insieme
• F$_&\f{{W=1$=},\;}: Raggruppa le terzine sopra in priorità di stampa usando la stringa di formattazione. Questo codice garantisce inoltre che le priorità siano ordinate.
• ]_{0f=_W=),\0=>Lf&Ra#)},: Per ciascun gruppo prioritario di terzine, ottenere l'intervallo dell'indice di delimitazione e vedere se non è stato ancora stampato alcun indice. Se è presente un indice non stampato, includere questo gruppo di priorità nel gruppo "da stampare in questo passaggio".
• F,S*\:+{~;1$L+:L;t}%oNo~}%: Dopo aver ottenuto la stampa di tutti i gruppi in questo passaggio, inserire il codice nell'indice corretto di una stringa di spazio vuota e quindi stampare quella stringa. Aggiornare anche l'array contenente l'elenco di indici stampati.

Spiegazione del codice da seguire quando ho finito di giocare a golf.

Esempio

Ecco il codice eseguito sul codice stesso:

Ingresso:

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

Produzione:

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

Provalo online qui

CJam, 48 byte

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

Spiegazione

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 byte

Nuova versione, ancora troppo lunga, ma più corta! E, nel vero spirito di IDL, completamente vettorializzato, il che significa (dal momento che non esiste un ciclo) che ora posso farlo come una riga ed eseguirlo su se stesso, una volta che la mia versione è stata completamente aggiornata a 8.4. Che verrà modificato in seguito.

Versione a una riga:

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

Con interruzioni di riga (stesso numero di byte, sottotitoli \ n vs &) e commentati:

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

Ecco una ripartizione algoritmica per la linea 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)

... e 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

Le righe 9 e 10 fanno il vero lavoro, il resto imposta le variabili necessarie per la fine. Penso che questo sia tanto golf quanto sta per arrivare, non riesco a trovare altrove per farlo meglio.

Vecchia versione (tutto qui sotto non è aggiornato):

Questo non è abbastanza vicino per vincere, perché questo è un linguaggio da golf terribile, ma nessuno risponde mai in IDL, quindi ci proverò.

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

Non sono sicuro che ci sia un modo per ridurlo di più ... Potrei chiamare strmid su aeb allo stesso tempo, ma poi spendo più byte indicizzando d e funziona allo stesso modo. Continuerò a lavorarci, però! (E domani modificherò in una spiegazione dell'algoritmo.)