Le but de ce défi est de produire une version ASCII de la couverture de ce superbe album du groupe de rock Pink Floyd.

Les jonctions de briques sont composées de caractères _et |. Les briques ont des caractères de largeur 7 et de hauteur 2, à l'exclusion des jonctions. Donc, l'unité de base, y compris les jonctions, est:

_________
|       |
|       |
_________

Chaque rangée de briques est décalée d'une demi-largeur de brique (4 caractères) par rapport à la rangée précédente:

________________________________________
  |       |       |       |       |     
  |       |       |       |       |     
________________________________________
      |       |       |       |       | 
      |       |       |       |       | 
________________________________________
  |       |       |       |       |     
  |       |       |       |       |     

Le mur est paramétré comme suit. Tous les paramètres sont mesurés en caractères, jonctions comprises:

1. Décalage horizontal de la première rangée, F. C'est la distance entre la marge gauche et la première jonction verticale de la rangée la plus haute. (Rappelez-vous également le décalage relatif de demi-brique entre les lignes). Ses valeurs possibles sont 0, 1, ..., 7.
2. Totale largeur , W. Cela inclut les jonctions. Sa valeur est un entier positif.
3. Totale hauteur , H. Cela inclut les jonctions. Sa valeur est un entier positif.

Le sommet du mur coïncide toujours avec le haut d'une rangée. Le fond peut être déchiqueté (si la hauteur totale n’est pas un multiple de 3). Par exemple, voici la sortie pour 6, 44, 11:

____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     
  |       |       |       |       |       |     
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     

et une explication visuelle des paramètres:

          F=6
         ......   
     .   ____________________________________________
     .         |       |       |       |       |    
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       | 
H=11 .     |       |       |       |       |       |      
     .   ____________________________________________
     .         |       |       |       |       |     
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       |      

         ............................................
                             W=44

Règles supplémentaires

Vous pouvez fournir un programme ou une fonction.

Le format d'entrée est flexible comme d'habitude. La sortie peut être via STDOUT ou un argument renvoyé par une fonction. Dans ce cas, il peut s'agir d'une chaîne avec des nouvelles lignes ou d'un tableau de chaînes.

Les espaces de fin ou les nouvelles lignes sont autorisés.

Le code le plus court en octets gagne.

Cas de test

Les entrées sont dans l'ordre indiqué ci-dessus, à savoir: décalage horizontal de la première ligne, largeur totale, hauteur totale.

6, 44, 11:
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     


2, 20, 10:
____________________
  |       |       | 
  |       |       | 
____________________
      |       |     
      |       |     
____________________
  |       |       | 
  |       |       | 
____________________


1, 1, 1:
_


1, 2, 3:
__
 |
 |


3, 80, 21:
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    

Pyth, 43 à 27 octets

J'ai besoin de jouer beaucoup au golf ... le score est trop honteux.

AQVE<*H?%N3X*8d+G*4/N3\|\_H

Essayez-le déjà en ligne.

Format d'entrée

6,44
11

Format de sortie

____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 

Explication

AQVE<*H?%N3X*8d+G*4/N3\|\_H   First two inputs as list in Q,
                              third input as E.

AQ                            Assign G to the first item in Q
                              and H to the second item in Q.
  VE                          For N from 0 to E-1:
                   /N3            N floor-div 3.
                                    if N gives a remainder of 3 or 4 or 5
                                    when divided by 6, this will be odd;
                                    otherwise, this will be even.
                 *4               Multiply by 4.
                                    if the above is odd, this will leave
                                    a remainder of 4 when divided by 8;
                                    otherwise, the remainder would be 0.
               +G                 Add G (as an offset).
           X*8d       \|          In the string "        " (*8d),
                                  replace (X) the character with the
                                  index above with "|" (modular indexing,
                                  hence the manipulation above).
       ?%N3             \_        If N%3 is non-zero, use the above;
                                  otherwise, use "_".
     *H                           The above repeated H times.
    <                     H       Take the first H characters of above.
                                  Implicitly print with newline.

C, 86 85 83 82 octets

3 octets sauvés grâce à Lynn.
1 octet sauvegardé grâce à charlie.

i;f(o,w,h){++w;for(i=0;++i<w*h;)putchar(i%w?i/w%3?i%w+i/w/3*4+~o&7?32:124:95:10);}

C, 92 octets

b(f,w,h,y,x){for(y=0;y<h;y++,puts(""))for(x=0;x<w;x++)putchar(y%3?(x+y/3*4-f)%8?32:124:95);}

Invoquer comme b(F, W, H).

Perl, 63 octets

#!perl -nl
$y+=print+map$y%3?$_++-$`&7?$":'|':_,($y%6&4)x$&for/ \d+/..$'

En comptant le shebang comme 2, l'entrée est prise à partir de stdin, espace séparé.

Exemple d'utilisation

$ echo 2 20 10 | perl bricks.pl
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________

Haskell, 83 octets

q s="_":[s,s]
(f!w)h=take h$cycle$take w.drop(7-f).cycle<$>q"       |"++q"   |    "

Ceci définit une fonction infixe ternaire !qui renvoie une liste de chaînes. Exemple d'utilisation:

*Main> putStrLn $ unlines $ (3!14) 7
______________
   |       |  
   |       |  
______________
       |      
       |      
______________

Comment ça fonctionne:

            q"       |"++q"   |    "  -- build a list of 6 strings
                                      --   1:     "_"
                                      --   2:     "       |"
                                      --   3:     "       |"
                                      --   4:     "_"
                                      --   5:     "   |    "
                                      --   6:     "   |    "
         <$>                          -- for each of the strings
     take w.drop(7-f).cycle           -- repeat infinitely, drop the first 7-f chars
                                      --    and take the next w chars
  cycle                               -- infinitely repeat the resulting list
take h                                -- and take the first h elements

JavaScript (ES6), 96 95 octets

g=
(f,w,h)=>[...Array(h)].map((_,i)=>(i%3?`       |`:`_`).repeat(w+7).substr(f^7^i%6&4,w)).join`
`
;

<div onchange=o.textContent=g(f.value,w.value,+h.value)><input id=f type=number min=0 max=7 placeholder=Offset><input id=w type=number min=0 placeholder=Width><input id=h type=number min=0 placeholder=Height></div><pre id=o>

Explanation: Crée une chaîne composée du |motif répétitif de 7 espaces ou plus ou de _s répétés , mais au moins suffisamment longue pour pouvoir extraire les wcaractères requis pour chaque ligne. Les trois premières lignes commencent à la position f^7, puis les trois lignes suivantes à la position f^3. Pour ce faire, je permute le bit 2 de ftoutes les trois lignes en utilisant le bit 2 opposé sur les deux dernières lignes de chaque bloc de 6 pour une économie de 1. octet.

MATL, 42 36 33 octets

:-Q'_ | |'[DClCl]Y"8et4YShwi:3$)!

Format d'entrée est: nCols, offset,nRows

Essayez-le en ligne

L’approche consiste ici à créer un "modèle" dans lequel nous indexons en utilisant les index de ligne ( [1 2 ... nRows]) et les index de colonne décalés de la première entrée ( [1 2 ... nCols] - shift). Grâce à l'indexation modulaire de MATL, il en résulte automatiquement une sortie en mosaïque. En passant, pour économiser de l’espace, techniquement, je travaille avec une version transposée du modèle, puis je prends une transpose ( !) à la fin.

Le modèle est le suivant:

________
       |
       |
________
  |     
  |     

Python 2, 93 88 octets

Le deuxième niveau d'indentation est un onglet Sauvegarde de quelques octets grâce à Leaky Nun et à quelques modifications propres, également le décalage correct:

def f(F,W,H):
 for h in range(H):print["_"*W,((("|"+7*" ")*W)[8-F+h%6/3*4:])[:W]][h%3>0]

code précédent:

def f(F,W,H,x="|"+7*" "):
 for h in range(H):
    print ["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]

Même longueur que lambda sans nom:

lambda F,W,H,x="|"+7*" ":"\n".join(["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]for h in range(H))

QBasic, 121 109 octets

(Testé sur QB64)

Merci à @DLosc pour avoir joué mon IFénoncé avec un équivalent mathématique. Cela valait 12 octets.

Méthode générale:

Boucle à travers chaque cellule une à la fois et de déterminer si elle doit être _, ou en |fonction de son emplacement. MODles instructions et la logique booléenne sont utilisées pour déterminer les limites des briques et leur degré d'échelonnement.

Code:

INPUT F,W,H
FOR y=0TO H-1:FOR x=0TO W-1
?CHR$((y MOD 3>0)*(((x-(y MOD 6>3)*4)MOD 8=F)*92+63)+95);
NEXT:?:NEXT

Note d'utilisation:

QBasic s'attend à ce que les entrées soient des nombres séparés par des virgules.

Java, 149 , 147 , 146 , 143 octets

Golfé:

String f(int o,int w,int h){String s="";for(int y=0,x;y<h;++y){for(x=0;x<w;++x){s+=y%3>0?(x-o+(y-1)/3%2*4)%8==0?'|':' ':'_';}s+='\n';}return s;}

Ungolfed:

public class AllInAllItsJustUhAnotherTrickInCodeGolf {

  public static void main(String[] args) {
    int offset = 6;
    int width = 44;
    int height = 11;
    System.out.println(new AllInAllItsJustUhAnotherTrickInCodeGolf()
        .f(offset, width, height));
  }

  // Begin golf
  String f(int o, int w, int h) {
    String s = "";
    for (int y = 0, x; y < h; ++y) {
      for (x = 0; x < w; ++x) {
        s += y % 3 > 0 ? (x - o + (y - 1) / 3 % 2 * 4) % 8 == 0 ? '|' : ' ' : '_';
      }
      s += '\n';
    }
    return s;
  }
  // End golf

}

Rubis, 72 66 octets

->f,w,h{h.times{|i|puts i%3<1??_*w:((?|+' '*7)*w)[8-f+i%6/4*4,w]}}

Merci @Value Ink pour 6 octets!

Multiplication et découpage de chaînes simples.

Fonctionne dans Ruby 2.3.0 (la version 2.1 d'Ideone renvoyait une erreur de syntaxe).

Julia: 150 128 116 108 107 octets

# in codegolf.jl
r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...)

courir avec des arguments: julia -e 'o=2;h=18;w=40;include("codegolf.jl")'

Si vous sentez que téléphoner depuis bash est une triche et que vous voulez une fonction dans l'interpréteur, la version de la fonction est de 117 octets :)

f(o,h,w)=(r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...))

démo

(Merci, @ glen-o pour le conseil supplémentaire permettant d'économiser des octets!)

JavaScript, 172 168 165 157 147 147 142 137 octets

(O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}

N = (O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}

let test_data = [[6,44,11],
                 [2,20,10],
                 [1,1,1],
                 [1,2,3],
                 [3,80,21]];

for (test of test_data)
    console.log(N(...test));

Dyalog APL, 29 octets

↑⎕⍴⎕⍴¨a,4⌽¨a←'_',2⍴⊂⌽⎕⌽¯8↑'|'

essais: 6 44 11, 2 20 10, 1 1 1, 1 2 3, 3 80 21

⎕est évalué l'entrée; comme l'expression exécute de droite à gauche, il demande F, Wet Hdans cet ordre

¯8↑'|' est ' |'

⎕⌽ est une rotation, elle coupe les caractères F de l'avant et les met à la fin de la chaîne

l'autre ⌽moyen inverse

'_',2⍴⊂ crée un 3-tuple de '_' suivi de deux copies séparées de la chaîne jusqu'à présent

a,4⌽¨a← ajouter les 4 rotations de tout jusqu'à présent, nous nous retrouvons avec un 6 tuple

⎕⍴¨ remodeler chaque élément à la largeur

⎕⍴ remodeler à la hauteur

↑ mélanger le vecteur de vecteurs dans une matrice

En fait , 44 43 40 octets

C'est un portage réel de l'algorithme dans la réponse JS de Neil . Les suggestions de golf sont les bienvenues. Essayez-le en ligne!

╗╝r⌠;6(%4&╜7^^╛'|7" "*+*t╛@H╛'_*3(%YI⌡Mi

Ungolfing:

          Takes implicit input in the order h, w, f.
╗╝        Save f to register 0. Save w to register 1.
r⌠...⌡M   Map over range [0..h-1]. Call this variable i.
  ;         Duplicate i
  6(%       i%6...
  4&        ...&4
  ╜7^^      ...^i^7. Call it c.
  ╛         Push w.
  '|7" "*+  The string "       |"
  *t╛@H     (("       |" * w)[c:])[:w]
  ╛'_*      Push "_" * w
  3(%       Push 3, move duplicate i to TOS, mod.
  YI        If not i%3, take "_"*w, else (("       |" * w)[c:])[:w]
            Function ends here.
i         Flatten the resulting list and print the bricks implicitly.

PowerShell , 101 88 octets

param($n,$w,$h)0..--$h|%{(('|       '*$w|% S*g(8-$n+4*($_%6-gt3))$w),('_'*$w))[!($_%3)]}

Essayez-le en ligne!

Octave 80 76 octets

% in file codegolf.m
c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;char(repmat(c+32,h,w)(1:h,o+1:o+w))

à partir du terminal: octave --eval "o=2;h=18;w=44; codegolf"

(alternativement, si vous pensez que l'appel du terminal est en train de tricher: p alors une implémentation de fonction anonyme prend 86 octets :)

c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;f=@(o,h,w)char(repmat(c+32,h,w)(1:h,o+1:o+w))

Appeler f(2,18,44)à l'interprète d'octave.

Bash + Sed, 411 395 381 370 octets:

F=`printf '_%.s' $(eval echo {1..$2})`;V="       |";(($[($2-$1)/8]>0))&&L=`printf "$V%.s" $(eval echo {1..$[($2-$1)/8]})`||L=;Z=`printf "%$1.s|%s\n" e "$L"`;I=$[($2-(${#Z}-4))/8];(($I>0))&&W=`printf "$V%.s" $(eval echo {1..$I})`||W=;J=${Z:4}$W;for i in `eval echo {1..$[$3/3+1]}`;{ (($[$i%2]<1))&&O+="$F\n$J\n$J\n"||O+="$F\n$Z\n$Z\n";};echo "`echo -e "$O"|sed -n 1,$3p`"

Eh bien, voici ma toute première réponse dans Bash, ou n'importe quel langage de script shell. C'est aussi de loin la réponse la plus longue ici. Prend une séquence d'arguments de ligne de commande séparés par des espaces dans le format Offset Width Height. Cela peut probablement être beaucoup plus court qu’il ne l’est actuellement, alors tous les trucs et astuces pour jouer au golf plus sont appréciés.

Delphi / Object Pascal, 305 , 302 , 292 octets

Programme console complet qui lit 3 paramètres.

uses SySutils,Math;var i,q,o,w,h:byte;begin o:=StrToInt(paramstr(1));w:=StrToInt(paramstr(2));h:=StrToInt(paramstr(3));for q:=0to h-1do begin for i:=1to w do if q mod 3=0then Write('_')else if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8))=1then Write('|')else Write(' ');Writeln('');end end.

non-golfé

uses
  SySutils,
  Math;
var
  i,q,o,w,h:byte;
begin
  o:=StrToInt(paramstr(1));
  w:=StrToInt(paramstr(2));
  h:=StrToInt(paramstr(3));

  for q := 0 to h-1 do
  begin
    for i := 1 to w do
      if q mod 3 = 0  then
        Write('_')
      else
        if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8)) = 1 then
          Write('|')
        else Write(' ');
    Writeln('');
  end
end.

Malheureusement, Delphi n’a pas d’opérateur ternaire et c’est un langage assez prolixe.

cas de test

D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 2 20 10
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________

D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 6 44 11
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |
  |       |       |       |       |       |
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |

Éditer: Pourrait supprimer 3 octets en utilisant octet comme type pour toutes les variables.

Edit 2: Et les applications de console n'ont pas besoin de la déclaration de programme, -10