Tout le monde connaît probablement la chanson suivante , qui est une tournée musicale :

Contexte

Moins de gens se souviendront d'avoir essayé de chanter la version à 4 personnes avec quelques amis et d'avoir échoué. Compenser les paroles d'une chanson avec des hauteurs harmonieuses différentes est connu comme chanter un "round" et c'est ce que nous sommes ici pour simuler aujourd'hui en utilisant une sortie statique. Voici un exemple de quelqu'un qui exécute réellement la pièce (lien vers audio / vidéo, aura du son) .

Le défi

Ce défi consiste à produire le texte comme suit exactement comme suit:

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.               

Règles

• Les espaces vides sont acceptables, mais pas obligatoires, cela inclut les retours à la ligne.
• Les tirets et les barres font partie de la sortie requise, oui.
• Des virgules, des points, des majuscules et tous les éléments syntaxiques liés à la grammaire sont requis.

C'est le code-golf , le code comptant le moins d'octets sans utiliser de failles standard est le gagnant.

05AB1E , 80 77 octets

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

Essayez-le en ligne!

Travail en cours.

V , 139 , 128 octets

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

Un one-liner! (sortof: P)

Essayez-le en ligne!

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|

Puis-je obtenir des points bonus pour avoir atterri exactement 2^7?

Cela a pris du temps à comprendre. J'espère pouvoir jouer des tonnes comme ma réponse d'art ASCII au clavier, mais je ne suis pas sûr. Nous verrons. Ce sont des défis très similaires (et tous deux très amusants: D)

À l'origine, j'ai essayé ceci (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

Essayez-le en ligne!

Ce qui insère ceci:

RDDD
GRDD
MGRD
LMGR
DLMG
DDLM
DDDL

puis fait la substitution pour l'étendre. Mais le construire en style ascii-art est beaucoup plus court (et plus amusant TBH)

Lot, 292 288 275 octets

@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%

Edit: économisé 13 octets en réécrivant le code pour utiliser une version de l'astuce de sous-chaîne que j'ai utilisée dans ma réponse Retina. Idéalement, je peux boucler six fois, puis tomber pour une septième itération du corps de la boucle, ce qui signifie que la citation nécessaire pour sortir |s ne devient pas trop onéreuse, mais je dois faire attention à prendre ^en compte les s lors de la sélection de la sous-chaîne .

Python 3, 252 235 208 206 205 205 octets

D'accord d'accord. Voici une réponse moins ennuyeuse:

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='|')

Ancienne réponse, 252 octets:

Réponse ennuyeuse, et l'autre réponse Python est plus courte, mais j'ai pensé essayer si cette approche était plus courte. Python 3 malgré les économies de différence d'octet / chaîne 2-3 car les deux gzipet base64sont plus timides en 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 octets

$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'|'}

Essayez-le en ligne! (la sortie est enveloppée si votre écran n'est pas assez large)

Bon sang, cette génération de tableaux est moche, mais elle a économisé 17 octets, alors ...

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

Nous bouclons de 0à 6. Chaque itération, nous indexons dans un tableau (0,1,2,3,4,4,4). L'indexation est basée sur le chiffre actuel, le chiffre actuel +6, cela -1, puis cela -1 . Chacun d' eux est ensuite alimenté à travers une boucle avec laquelle nous modulons %7. Par exemple, si nous sommes sur 0de la partie extérieure en 0..6boucle, puis ceux - ci seraient 0,6,5,4, chacun %7, donc 0,6,5,4. C'est indexé dans le (0,1,2,3,4,4,4)tableau, donc la sortie est 0,4,4,4. Pour l'entrée, 1nous obtenons 1,7,6,5alors 1,0,6,5ce qui donne 1,0,4,4. Etc. (les choses seraient tellement plus faciles si nous avions une .clampfonction)

Ce sont des crachats un à un dans une boucle |%{}. À chaque itération, nous indexons au bon endroit dans le tableau des paroles de chansons et laissons cette chaîne dans le pipeline. Ces chaînes sont ensuite -joinéditées avec |pour formater la ligne de sortie. Ces chaînes sont laissées sur le pipeline et la sortie est implicite.

Enregistré quelques octets grâce à Value Ink.

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

_=>"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)])

Économisé quelques octets en empruntant une astuce à la réponse d' Arnauld

Essayez-le

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 octets

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]);

Essayez-le en ligne!

Étendu

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 octets

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)))

Essayez-le en ligne!

Merci à @mathjunkie pour avoir économisé 14 octets

CJam , 128 122 octets

"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*

Essayez-le en ligne!

Explication

"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 octets

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

La 1ère partie ┌׀0ρMVxDrž|⁷ΨB≈π93|↑D~Νķ‰¤t╤▼ΣΗ⁶⅔¾№⁷Ζ÷│²╥Ν9°‘est une chaîne compressée résultant en

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

Ce sont les lignes inversées (puisqu'il s'agit de les imprimer ligne par ligne), la partie "gaiement" étant découpée pour être remplacée dans le programme.
Le reste du programme:

...‘                                        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 octets

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

Essayez-le en ligne!

Simple, utilise des occurrences courantes comme remplacements.

PHP, 179 octets:

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];

non golfé

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 octets

Enregistré 3 octets grâce à 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>

Serveur Microsoft SQL, 421 octets

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)

Vérifiez-le en ligne

C (GCC), 231230 octets

-1 octet grâce au plafond!

#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]);}

Assez simple. Tout d'abord, il construit le tableau de chaînes de 7 lignes, une partie via une macro pour factoriser la partie "joyeusement", puis les lignes de tirets sont remplies d'un memset. Ensuite, les lignes sont imprimées avec le décalage et les séparateurs adéquats.

Essayez-le en ligne!

MATLAB, 280 octets

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'indexation des tableaux de cellules est assez coûteuse, ce qui semble être l'endroit le plus simple pour supprimer certains octets (si possible).

Rétine , 153 150 octets

<-|>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}

Essayez-le en ligne!

J'ai essayé un encodage arbitraire mais $1$*$2je ne fais pas ce que je veux et la répétition des chaînes s'est avérée trop délicate. Edit: enregistré 2 octets en encodant errily,et 1 octet en supprimant un inutile ^.

Python 2, 225 octets

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)])

Essayez-le en ligne!

Perl 5 , 215 octets

$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

Essayez-le en ligne!

Swift , 416 406 405 380 372 307 octets

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:"|"))}}

Vous pouvez l'essayer ici .

Merci à @Mr. Xcoder pour m'avoir sauvé 65 octets!

T-SQL, 296 277 276 octets

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))

Les sauts de ligne au début font partie de la chaîne d'origine, les sauts de ligne près de la fin sont uniquement à des fins d'affichage et ne sont pas comptés dans le total d'octets.

Inspiré en grande partie par la réponse de Conrade SparklePony . Technique différente de la réponse SQL d' Andrei Odegov .

Multi-remplacement assez simple, mais quelques éléments qui permettent d'économiser des octets:

• SQL autorise les sauts de ligne dans la chaîne d'origine
• L'utilisation de chiffres au lieu de caractères me permet d'éliminer tout un tas de guillemets simples
• Remplacements imbriqués (5 et 6), économisez-moi encore plus d'octets (merci, @ t-clausen.dk)

Si seulement je pouvais REPLACEtous les REPLACEs avec quelque chose de plus court. Hmm ....

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

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

Essayez-le

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

Rubis, 162 octets

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 octets / 272 259 octets

avec des nouvelles lignes toutes les 4 colonnes (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();}}

Essayez-le en ligne

pas de nouvelle version (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]+'|');}

• Condensé 2 pour boucles en 1

Essayez-le en ligne

Japt , 158 157 bytes

='|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

Essayez-le en ligne!

Stax , 63 octets

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

Exécuter et déboguer

Perl 5 , 163 octets

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

Essayez-le en ligne!

Enchantements runiques , 292 octets

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

Essayez-le en ligne!

Je ne fais généralement pas de défis de complexité kolmogorov , mais la mise en page était celle avec laquelle je pouvais travailler sans trop de problèmes. Runic n'a pas de bons moyens pour compresser des chaînes arbitraires, donc tout ce que nous avons à faire, ce sont les parties répétitives.

Explication:

Décompresser légèrement:

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]]@

Les 5 premières lignes agissent comme des fonctions pour construire chaque partie du morceau (où la première ligne génère les 35 -pour l'espaceur en utilisant la valeur décimale de #pour enregistrer 2 octets 3X5+). L'instruction de retour est au début de la ligne pour s'assurer que toutes les adresses IP qui entrent dans une fonction quitteront également la fonction après le même nombre de cycles pour éviter la fusion des adresses IP (entraînant des lignes de sortie manquantes), car les programmes sont des cellules rectangulaires et vides. sont implicites.

Les quatre lignes suivantes sont responsables de l'impression des quatre premières lignes de la sortie

La cinquième ligne imprime ensuite les 3 dernières lignes de sortie. Étant donné que les trois lignes doivent commencer avec au moins un espaceur de strophe, il n'est pas possible d'utiliser 3 adresses IP distinctes (car elles auraient besoin de retards pour éviter la fusion). >, y, @, Et un coût plus d' octets de saut de ligne (4) à 0[...](3 octets) , où... est instructions arbitraires ( par exemple un autre. Ligne de sortie).

Inversement remplaçant >et@ utilisation d'une seule IP nécessitent plus d'octets.

Enfin, la fusion des cinq lignes d'entrée sur la 2e ligne permet d'économiser 5 octets de sauts de ligne. Nous devons juste nous assurer que l' B͍instruction de retour de ranch passe d'abord à la fin de sa ligne, préservant ainsi la fonctionnalité de la fonction.