Probabilmente tutti hanno familiarità con la seguente canzone , che è un round musicale :

sfondo

Sempre meno persone potrebbero ricordare di aver provato a cantare la versione per 4 persone con alcuni amici e senza riuscirci. Compensare i testi di una canzone con tonalità diverse e armoniose è noto come cantare un "round" ed è quello che siamo qui per simulare oggi usando l'output statico. Ecco un esempio di qualcuno che sta effettivamente eseguendo il pezzo (il collegamento ad audio / video, avrà un suono) .

La sfida

Questa sfida consiste nell'output del testo esattamente come segue:

Row, row, row your boat,           |-----------------------------------|-----------------------------------|-----------------------------------
Gently down the stream.            |Row, row, row your boat,           |-----------------------------------|-----------------------------------
Merrily, merrily, merrily, merrily,|Gently down the stream.            |Row, row, row your boat,           |-----------------------------------
Life is but a dream.               |Merrily, merrily, merrily, merrily,|Gently down the stream.            |Row, row, row your boat,           
-----------------------------------|Life is but a dream.               |Merrily, merrily, merrily, merrily,|Gently down the stream.            
-----------------------------------|-----------------------------------|Life is but a dream.               |Merrily, merrily, merrily, merrily,
-----------------------------------|-----------------------------------|-----------------------------------|Life is but a dream.               

Regole

• Gli spazi bianchi finali sono accettabili, ma non richiesti, questo include le nuove righe.
• I trattini e le barre fanno parte dell'output richiesto, sì.
• Sono richiesti virgole, punti, maiuscole e tutti gli elementi sintattici relativi alla grammatica.

Questo è code-golf , il codice conteggio dei byte più basso senza usare scappatoie standard è il vincitore.

05AB1E , 80 77 byte

“¢ã,¢ã,¢ã€žžÄ,““èî„‹€€šæ.“"merrily, "4ר“‚쀈€³€…žâ.“'-35×Ð)€ª.B3FDÁ})øvy'|ý,

Provalo online!

Lavori in corso.

V , 139 , 128 byte

iLife is but a dream ±µ |4amerrily, x7b~A|Gently down the stream.±² |3arow, X5b~Ayour boat,±± |3I³µ-|3AòÄó.û-}|ò5DÎ4f|C|

Una fodera! (ordinamento: P)

Provalo online!

hexdump:

00000000: 694c 6966 6520 6973 2062 7574 2061 2064  iLife is but a d
00000010: 7265 616d 20b1 b520 7c1b 3461 6d65 7272  ream .. |.4amerr
00000020: 696c 792c 201b 7837 627e 417c 4765 6e74  ily, .x7b~A|Gent
00000030: 6c79 2064 6f77 6e20 7468 6520 7374 7265  ly down the stre
00000040: 616d 2eb1 b220 7c1b 3361 726f 772c 201b  am... |.3arow, .
00000050: 5835 627e 4179 6f75 7220 626f 6174 2cb1  X5b~Ayour boat,.
00000060: b120 7c1b 3349 b3b5 2d7c 1b33 4101 1bf2  . |.3I..-|.3A...
00000070: c4f3 2efb 2d7d 7cf2 3544 ce34 667c 437c  ....-}|.5D.4f|C|

Ricevo punti bonus per l'atterraggio esattamente su 2^7?

Ci è voluto del tempo per capire. Spero di poter giocare a tonnellate come la mia risposta ASCII sulla tastiera, ma non ne sono sicuro. Vedremo. Sono sfide molto simili (ed entrambe molto divertenti: D)

Inizialmente ho provato questo (180):

3irow, ch your boat,±± ||"rCLife is but a dream.±µ ||"lD4imerrily, r||"mCGently down the stream.±² ||"gC³µ-|B"dCR³D
GRDD
MGRD
LMGR
DLMG
DDLM
³DLÍR/r
ÍG/g
ÍM/m
ÍL/l
ÍD/d

Provalo online!

Che inserisce questo:

RDDD
GRDD
MGRD
LMGR
DLMG
DDLM
DDDL

e quindi sostituisce per espanderlo. Ma costruirlo in stile ascii-art è molto più breve (e più divertente TBH)

Batch 292 288 275 byte

@set d=-------
@set "d=%d%%d%%d%%d%%d%^|
@set "m=M_ m_ m_ m_^|
@set "s=           ^|
@set "s=Life is but a dream.    %s%%m:_=errily,%Gently down the stream. %s%Row, row, row your boat,%s%%d%%d%%d%"
@for /l %%i in (1,1,6)do @call:c
:c
@echo %s:~111,146%
@set "s=%d%%s%

Modifica: salvato 13 byte riscrivendo il codice per utilizzare una versione del trucco di sottostringa che ho usato nella mia risposta Retina. Convenientemente posso ripetere il ciclo sei volte e poi passare per una settima iterazione del corpo del loop, il che significa che la quotazione necessaria per l'output di |s non diventa troppo onerosa, tuttavia devo fare attenzione a prendere ^in considerazione s durante la selezione della sottostringa .

Python 3, 252 235 208 206 205 byte

Va bene, va bene. Ecco una risposta meno noiosa:

w=' '*11
t=["Row, row, row your boat,"+w,"Gently down the stream. "+w,"Merrily,"+" merrily,"*3,"Life is but a dream.    "+w,*['-'*35]*3]
for a in zip(*[t[z:]+t[:z]for z in range(7,3,-1)]):print(*a,sep='|')

Vecchia risposta, 252 byte:

Risposta noiosa e l'altra risposta di Python è più breve, ma ho pensato di provare se questo approccio fosse più breve. Python 3 nonostante i risparmi nella differenza byte / stringa 2-3 perché entrambi gzipe base64sono più shitti in Python 2.

from base64 import*
from gzip import*
print(decompress(b85decode('ABzY8Fgf~I0{;ujFV|5hf)Waq`K3h)N%@H-ItmC-qe~c2OAVKMYF<fBr9w)6d7eT^Myf(_Nl|KIuATz2dxGfaW-i~<qN2>4N*#q<oQxVex|z!-Gc8pivsfXiv_v6MAqB%CkU6w=GZ!&|OJj#}Q7chW$(>wu%p_Rd3;?AKH=M}>000')).decode())

PowerShell , 224 207 202 byte

$a=' '*11;0..6|%{((0..4+4+4)[($_,($_+=6),--$_,--$_|%{$_%7})]|%{("Row, row, row your boat,$a","Gently down the stream.$a ","Merrily,$(' merrily,'*3)","Life is but a dream.$a    ",('-'*35))[$_]})-join'|'}

Provalo online! (l'output viene interrotto se lo schermo non è abbastanza largo)

Buon dolore, questa cosa di generazione di array è brutta, ma ha salvato 17 byte, quindi ...

0..6|%{((0..4+4+4)[($_,($_+=6),--$_,--$_|%{$_%7})]

Passiamo da 0a 6. Ogni iterazione, stiamo indicizzando in un array (0,1,2,3,4,4,4). L'indicizzazione si basa sulla cifra corrente, sulla cifra corrente +6, su quella -1e poi su quella -1 . Ognuno di questi viene quindi alimentato attraverso un ciclo in cui si inserisce il modulo %7. Ad esempio, se siamo sul circuito 0esterno 0..6, allora questi sarebbero 0,6,5,4, quindi ciascuno %7, quindi0,6,5,4 . È indicizzato nella (0,1,2,3,4,4,4)matrice, quindi l'output è 0,4,4,4. Per input 1otteniamo 1,7,6,5quindi 1,0,6,5quali rendimenti 1,0,4,4. E così via. (le cose sarebbero molto più facili se avessimo una .clampfunzione)

Quelli sono uno sputo alla volta in un ciclo |%{}. Ogni iterazione, ci indicizziamo nel punto giusto nella matrice di testi di canzoni e lasciamo quella stringa sulla pipeline. Queste stringhe vengono quindi -joineditate insieme |per formattare la linea di output. Tali stringhe vengono lasciate sulla pipeline e l'output è implicito.

Risparmio di alcuni byte grazie a Value Ink.

JavaScript (ES8), 285 256 240 231 229 217 214 213 211 210 byte

_=>"0444104421043210432144324443".replace(/./g,(x,y)=>a[x].padEnd(35)+`
|||`[++y&3],a=["Row, row, row your boat,","Gently down the stream.","Merrily,"+(m=" merrily,")+m+m,"Life is but a dream.","-".repeat(35)])

Hai salvato qualche byte prendendo in prestito un trucco dalla risposta di Arnauld

Provalo

f=

_=>"0444104421043210432144324443".replace(/./g,(x,y)=>a[x].padEnd(35)+`
|||`[++y&3],a=["Row, row, row your boat,","Gently down the stream.","Merrily,"+(m=" merrily,")+m+m,"Life is but a dream.","-".repeat(35)])

o.innerText=f()

<pre id=o>

PHP, 191 byte

for(;$n<7;$n++)for($m=0;$m<4;)echo $m?"|":"\n",str_pad($i=["Row, row, row your boat,","Gently down the stream.",M.($t="errily,")." m$t m$t m$t","Life is but a dream."][$n-$m++],35," -"[!$i]);

Provalo online!

allargato

for(;$n<7;$n++)
  for($m=0;$m<4;)
    echo $m?"|":"\n"
     ,str_pad($i=["Row, row, row your boat,","Gently down the stream."
       ,M.($t="errily,")." m$t m$t m$t","Life is but a dream."][$n-$m++]
       ,35," -"[!$i]);

Python 2 , 199 byte

w=' '
s=['-'*35]
t=['Row, row, row your boat,'+w*11,'Gently down the stream.'+w*12,'Merrily,'+' merrily,'*3,'Life is but a dream.'+w*15]
print'\n'.join(map('|'.join,zip(t+s*3,s+t+s+s,s+s+t+s,s*3+t)))

Provalo online!

Grazie a @mathjunkie per aver salvato 14 byte

CJam , 128 122 byte

"Row, row, row your boat,""gently down the stream."'M" merrily,"4*2>+"Life is but a dream."'-35*__]{35Se]}%a4*4,.m>z'|f*N*

Provalo online!

Spiegazione

"Row, row, row your boat,"  e# Push this string.
"gently down the stream."   e# Push this string.
'M                          e# Push the character 'M'.
" merrily,"4*               e# Push the string " merrily, merrily, merrily, merrily,".
2>+                         e# Remove the first two letters of it, and append it to 'M',
                            e#   fixing the capitalization.
"Life is but a dream."      e# Push this string.
'-35*__                     e# Push a string containing 35 hyphens and make two copies of it.
]                           e# Collect all these strings in an array.
{35Se]}%                    e# Pad each of them to length 35 by adding spaces to the right.
a4*                         e# Repeat the array 4 times.
4,                          e# The range [0 1 2 3].
.m>                         e# Rotate each subarray of strings rightward by the corresponding
                            e#   number in the range.
z                           e# Transpose the array.
'|f*                        e# Join the strings on each row with '|' characters.
N*                          e# Join the rows together with newlines.

SOGL , 83 byte

┌׀0ρMVxDrž|⁷ΨB≈π93|↑D~Νķ‰¤t╤▼ΣΗ⁶⅔¾№⁷Ζ÷│²╥Ν9°‘-”)0ΔH«‘4*jŗ"ΣΨ¬¹‘4*;+7{’⁄{»}⁽:’∞n1wpX

La prima parte ┌׀0ρMVxDrž|⁷ΨB≈π93|↑D~Νķ‰¤t╤▼ΣΗ⁶⅔¾№⁷Ζ÷│²╥Ν9°‘è una stringa compressa risultante

`life is but a dream.               |-|gently down the stream.            |row, row, row your boat,           |`

Queste sono le linee invertite (poiché le sta stampando riga per riga), con la parte "allegra" ritagliata per essere sostituita nel programma.
Il resto del programma:

...‘                                        Push the compressed string
      )0ΔH«‘                                push "merrily, "
            4*                              repeat it 4 times
              j                             take the last letter off
    -”         ŗ                            replace "-" with the merrily line
                "ΣΨ¬¹‘                      push 35 dashes with an appending "|"
                      4*                    repeat it 4 times
                        ;+                  add inverted ("---|---..."+"Life is but a dream  ...")
                                            The resulting string of above is "-----------------------------------|-----------------------------------|-----------------------------------|-----------------------------------|life is but a dream.               |merrily, merrily, merrily, merrily,|gently down the stream.            |row, row, row your boat,           |"
                          7{                repeat 7 times
                            ’⁄{»}            rotate right 35 times
                                 ⁽           uppercase the 1st letter
                                  :          duplicate
                                   ’∞n       split into parts of length 135
                                      1w     get the 1st one
                                        p    output that
                                         X   delete the splat array

/// , 200 byte

/_/     //&/errily,//*/ m&//+/-------//@/Row, row, row your boat, __//#/Gently down the stream.  __//$/M&***//%/Life is but a dream.___//~/+++++/@|~|~|~
#|@|~|~
$|#|@|~
%|$|#|@
~|%|$|#
~|~|%|$
~|~|~|%

Provalo online!

Semplice, utilizza le ricorrenze comuni come sostituzioni.

PHP, 179 byte:

for($m="errily,";$i<28;)echo str_pad($s=["Row, row, row your boat,","Gently down the stream.","M$m m$m m$m m$m","Life is but a dream."][($i>>2)-$i%4],35," -"[!$s]),"
|||"[++$i%4];

ungolfed

for($i=0;$i<28;$i++)
{
    $x=$i%4;
    $y=$i>>2;

    $s=["Row, row, row your boat,",
        "Gently down the stream.",
        M.($m="errily,")." m$m m$m m$m",
        "Life is but a dream."
    ][$y-$x];

    $pad_string = $s ? " ":"-";
    $postfix = $x<3 ? "|" : "\n";
    echo str_pad($s,35,$pad_string),$postfix;
}

JavaScript (ECMAScript 2017), 191 187 182 byte

Salvato 3 byte grazie a Shaggy

f=(i=27,s=['Life is but a dream.','Merrily,'+(m=' merrily,')+m+m,'Gently down the stream.','Row, row, row your boat,'][(i>>2)-i%4]||'')=>i?s.padEnd(35,' -'[+!s])+`
|||`[i&3]+f(i-1):s

o.innerHTML = f();

<pre id=o style="font-size:10px"></pre>

Microsoft SQL Server, 421 byte

with v as(select left(s+space(35),35)s,n from(values('Row, row, row your boat,',1),('Gently down the stream.',2),('Merrily, merrily, merrily, merrily,',3),('Life is but a dream.',4))t(s,n))select isnull(v.s,s.s)+'|'+isnull(b.s,s.s)+'|'+isnull(c.s,s.s)+'|'+isnull(d.s,s.s)from v full join v b on v.n=b.n+1 full join v c on b.n=c.n+1 full join v d on c.n=d.n+1 cross apply(select replicate('-',35)s)s order by isnull(v.n,9)

Controllalo online

C (GCC), 231 230 byte

-1 byte grazie a ceilingcat!

#define m"errily, "
char s[7][35]={"Life is but a dream.","M"m"m"m"m"m"m"m,"Gently down the stream.","Row, row, row your boat,"};f(l,c){memset(s[4],45,'k');for(l=7;l--;)for(c=0;c<4;)printf("%-35.35s%c",s[(4+l+c++)%7],"|||\n"[c]);}

Abbastanza diretto. In primo luogo crea l'array di stringhe a 7 righe, parte tramite una macro per scomporre la parte "allegramente", quindi le linee di trattini vengono riempite con a memset. Quindi le linee vengono stampate con offset e separatori adeguati.

Provalo online!

MATLAB, 280 byte

a='errily,';
z={'Row, row, row your boat,';'Gently down the stream.';['M',a,' m',a,' m',a,' m',a];'Life is but a dream.'};
z{5}(1:35)='-';
y=5*ones(7,4);
for j=1:4;z{j}(end+1:35)=' ';y(j:j+3,j)=(1:4)';end
x=z(y);
for j=1:7;fprintf('%s|%s|%s|%s\n',x{j,1},x{j,2},x{j,3},x{j,4});end

L'indicizzazione dell'array di celle è piuttosto costosa, sembra il posto più semplice per scartare alcuni byte (se possibile).

Retina , 153 150 byte

<-|>Life is but a dream.15|M!< m!>|Gently down the stream.12|Row, row, row your boat,11<|->
<(.*?)>
$1$1$1
!
errily,
-
35$*-
\d+
$* 
r!&`.{71}\|.{71}

Provalo online!

Ho provato la codifica arbitraria di lunghezza di esecuzione ma $1$*$2non fa quello che voglio e ripetere le stringhe si è rivelato troppo complicato. Modifica: salvato 2 byte mediante codifica errily,e 1 byte rimuovendo un inutile ^.

Python 2, 225 byte

w=[["-"*35]*7for _ in[0]*4]
for i in [0]*4:w[i][i:i+4]=[a.ljust(35)for a in["Row, row, row your boat,","Gently down the stream.","Merrily,"+" merrily,"*3,"Life is but a dream."]]
print "\n".join(["|".join(i)for i in zip(*w)])

Provalo online!

Perl 5 , 215 byte

$m='merrily,';$s=' 'x11;$l='-'x35;
@t=@s=("Row, row, row your boat,$s","Gently down the stream. $s",
       "\u$m $m $m $m","Life is but a dream.    $s",$l,$l,$l);
map{$i--;map$t[$_].="|".$s[$i++%7],0..6}1..3;print"$_\n"for@t

Provalo online!

Swift , 416 406 405 380 372 307 byte

var f=String.init(repeating:count:);_={[[0,4,4,4],[1,0,4,4],[2,1,0,4],[3,2,1,0],[4,3,2,1],[4,4,3,2],[4,4,4,3]].forEach{print($0.map{["Row, row, row your boat,"+f(" ",11),"Gently down the stream."+f(" ",12),"Merrily,"+f(" merrily,",3),"Life is but a dream."+f(" ",15),f("-",35)][$0]}.joined(separator:"|"))}}

Puoi provarlo qui .

Grazie a @Mr. Xcoder per avermi salvato 65 byte!

T-SQL, 296 277 276 byte

PRINT REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE('1|0|0|0
2|1|0|0
3|2|1|0
4|3|2|1
0|4|3|2
0|0|4|3
0|0|0|4',0,REPLICATE('-',35))
        ,1,'Row, row, row your boat,6')
        ,2,'Gently down the stream. 6')
        ,3,'M5 m5 m5 m5')
        ,4,'Life is but a dream.    6')
        ,5,'errily,')
        ,6,SPACE(11))

Le interruzioni di riga all'inizio fanno parte della stringa originale, le interruzioni di riga vicino alla fine sono solo a scopo di visualizzazione e non vengono conteggiate per il totale dei byte.

Ispirato in gran parte dalla risposta di Conrade SparklePony . Tecnica diversa dalla risposta SQL di Andrei Odegov .

Multi-sostituzione piuttosto semplice, ma alcune cose che aiutano a salvare i byte:

• SQL consente le interruzioni di riga nella stringa originale
• L'uso di numeri anziché di caratteri mi consente di eliminare un intero gruppo di virgolette singole
• Sostituzioni nidificate (5 e 6), salvami ancora più byte (grazie, @ t-clausen.dk)

Se solo potessi REPLACEtutte le REPLACEcose con qualcosa di più corto. Hmm ....

Japt -R , 99 95 94 92 90 89 87 byte

R³i`Life  ¿t a Ým.
M{34î`Îk, m`}
Gt§ ܵ e Ðpam.
Row, w, w yr ¾,`ú)·ú-
£éY Ťq|

Provalo

R³i`L...{34î`...`}...,`ú)·ú-
R                                :Newline
 ³                               :Repeat 3 times
  i                              :Prepend
   `                             :  Decompress
    L...                         :    "Life is but a dream.\nM"
        {                        :    Interpolate
         34î                     :      Repeat & slice to length 34
            `...`                :        The compressed string "errily, m"
                 }               :    End interpolation
                  ...,           :    "\nGently down the stream.\nRow, row, row your boat,"
                      `          :  End decompression
                       ú         :  Right pad each line with spaces to the length of the longest
                        )        :End prepend
                         ·       :Split on newlines
                          ú-     :Right pad each element with "-" to the length of the longest
£éY Ťq|                         :Assign the above to U
£                                :Map each element at 0-based index Y
 éY                              :  Rotate U right Y times
    Å                            :  Slice off the first element
     ¤                           :  Slice off the first two elements
      q|                         :  Join with "|"
                                 :Implicit output, joined with newlines

Rubino, 162 byte

7.times{|i|puts (~i..~i+3).map{|j|[*[?-*35]*3,"Life is but a dream.",?M+['errily,']*4*" m","Gently down the stream.","Row, row, row your boat,"][j].ljust(35)}*?|}

Java, 295 byte / 272 259 byte

con righe ogni 4 colonne (295b)

void r(){String m=" merrily,",t="-------",s="     ",e=t+t+t+t+t;String[]v={"Gently down the stream.  "+s+s, "Merrily,"+m+m+m, "Life is but a dream."+s+s+s, e, e, e, "Row, row, row your boat, "+s+s};for(int i=0;i<7;i++){for(int j=6+i;j>2+i;j--)System.out.print(v[j%7]+'|');System.out.println();}}

Provalo online

nessuna versione newline (259b):

void r(){String m=" merrily,",t="-------",s="     ",e=t+t+t+t+t;String[]v={"Gently down the stream.  "+s+s, "Merrily,"+m+m+m, "Life is but a dream."+s+s+s, e, e, e, "Row, row, row your boat, "+s+s};for(int i=0;i<28;i++)System.out.print(v[(6-i%4+i/4)%7]+'|');}

• Condensato 2 per loop in 1

Provalo online

Japt , 158 157 byte

='|L=`Row, žw, žw yŒr ¾…,`+Sp11 +UV=`Gt§ ܵ e Ðpam.`+S³²²+UW=`M€Îk,`+` ´rÎk,`³+UJ=W+VX=`Life ‰ ¿t a Ý„m.`+Sp15 +UZ='-p35 +U[LZ³RVLZ²RJLZRXJLRZXJRZ²XWRZ³X]q

Provalo online!

Stax , 63 byte

∞╖]ÇàI╨‼Çö¼fi╩╨╛Aóß╟uƒ←37qÄô.Z╛Θ6►Mûj╚#Å[░]Oá0"y╧o╙)5;V╞♥╬F¼♫t~

Esegui ed esegui il debug

Perl 5 , 163 byte

say join'|',(('-'x26)x3,"Life is but a dream".$"x7,ucfirst(join$",("merrily,")x3),"Gently down the stream    ",ucfirst "row, "x3 ."your boat  ")[-$_..3-$_]for 1..7

Provalo online!

Incantesimi runici , 292 byte

B͍"-"'#*"|"3s
"Row, row, row your boat,"b" "S*q"|"3sB͍>01B10B3*1-akr@>12B01B10B2*1-akr@>13B12B01B10B1-akr@>14B13B12B01B1-akr@>10B3*14B1-r0[10B2*14B13B1-akr0[10B14B13B12B1-akr]]@
B͍"Gently down the stream."c" "S*q"|"3s
B͍"Merrily,"3" merrily,"S*q"|"3s
B͍"Life is but a dream."f" "S*q"|"3s

Provalo online!

In genere non faccio complessità kolmogorov sfide per la , ma il layout era uno con cui potevo lavorare senza troppi problemi. Runic non ha buoni modi per comprimere stringhe arbitrarie, quindi tutto ciò con cui dobbiamo lavorare sono le parti ripetitive.

Spiegazione:

Non comprimere leggermente:

B͍"-"'#*"|"3s
B͍"Row, row, row your boat,"b" "S*q"|"3s
B͍"Gently down the stream."c" "S*q"|"3s
B͍"Merrily,"3" merrily,"S*q"|"3s
B͍"Life is but a dream."f" "S*q"|"3s
>11B10B3*1-akr@
>12B11B10B2*1-akr@
>13B12B11B10B1-akr@
>14B13B12B11B1-akr@
>10B3*14B1-r0[10B2*14B13B1-akr0[10B14B13B12B1-akr]]@

Le prime 5 linee fungono da funzioni per costruire ogni porzione della canzone (dove la prima riga genera 35 -per il distanziatore usando il valore decimale di #per salvare 2 byte 3X5+). L'istruzione di ritorno è all'inizio della riga per assicurare che anche tutti gli IP che entrano in una funzione lascino la funzione dopo lo stesso numero di cicli per evitare l'unione degli IP (risultante in righe mancanti di output), poiché i programmi sono celle rettangolari e vuote sono impliciti.

Le successive quattro righe sono responsabili della stampa delle prime quattro righe dell'output

La quinta riga stampa quindi le ultime 3 righe di output. A causa di tutte e tre le linee che devono iniziare con almeno un distanziatore, non è possibile utilizzare 3 IP separati (poiché avrebbero bisogno di ritardi per evitare l'unione). >, y, @, E un costo nuova riga più byte (4) di 0[...](3 byte) dove ...è istruzioni arbitrarie (es. Un'altra linea di uscita).

Al contrario, la sostituzione >e @l'utilizzo di un singolo IP richiedono più byte.

Infine, l'unione di tutte e cinque le righe del punto di ingresso sulla seconda riga consente di risparmiare 5 byte di newline. Non ci resta che assicurare che l' B͍istruzione ranch-return si sposta prima alla fine della sua linea, preservando la funzionalità della funzione.