Lo scopo di questa sfida è quello di produrre una versione ASCII della copertina di questo grande album della rock band Pink Floyd.

Le giunzioni in mattoni sono fatte di personaggi _e |. I mattoni hanno una larghezza di 7 e un'altezza di 2 caratteri, esclusi gli incroci. Quindi l'unità di base, comprese le giunzioni, è:

_________
|       |
|       |
_________

Ogni fila di mattoni è sfalsata di mezza larghezza di mattone (4 caratteri) rispetto alla riga precedente:

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

Il muro è parametrizzato come segue. Tutti i parametri sono misurati in caratteri compresi gli incroci:

1. Spostamento orizzontale della prima fila, F. Questa è la distanza tra il margine sinistro e la prima giunzione verticale della riga più in alto. (Ricorda anche l'offset relativo del mezzo mattone tra le file). I suoi valori possibili sono 0, 1, ..., 7.
2. Total larghezza , W. Questo include giunzioni. Il suo valore è un numero intero positivo.
3. Totale altezza , H. Questo include giunzioni. Il suo valore è un numero intero positivo.

La cima del muro coincide sempre con la cima di una fila. Il fondo può essere sfilacciato (se l'altezza totale non è un multiplo di 3). Ad esempio, ecco l'output per 6, 44, 11:

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

e una spiegazione visiva dei parametri:

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

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

Regole aggiuntive

È possibile fornire un programma o una funzione.

Il formato di input è flessibile come al solito. L'output può essere tramite STDOUT o un argomento restituito da una funzione. In questo caso può essere una stringa con newline o una matrice di stringhe.

Sono consentiti spazi finali o newline.

Vince il codice più breve in byte.

Casi test

Gli input sono nell'ordine sopra indicato, ovvero: offset orizzontale della prima riga, larghezza totale, altezza totale.

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


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


1, 1, 1:
_


1, 2, 3:
__
 |
 |


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

Pyth, 43 27 byte

Ho bisogno di giocare a golf pesantemente ... il punteggio è troppo vergognoso.

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

Provalo già online.

Formato di input

6,44
11

Formato di output

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

Spiegazione

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 byte

3 byte salvati grazie a Lynn.
1 byte salvato grazie a 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 byte

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

Invoke as b(F, W, H).

Perl, 63 byte

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

Contando lo shebang come 2, l'input viene preso dallo stdin, gli spazi separati.

Esempio di utilizzo

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

Haskell, 83 byte

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

Questo definisce una funzione di infusione ternaria !che restituisce un elenco di stringhe. Esempio di utilizzo:

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

Come funziona:

            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 byte

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>

Spiegazione: Crea una stringa di 7 spazi ripetuti più un |motivo o solo _s ripetuti , ma almeno abbastanza a lungo da poter estrarre i wcaratteri richiesti per ogni riga. Le prime tre righe iniziano in posizione f^7e poi le tre successive iniziano in posizione f^3, quindi ottengo questo alternando il bit 2 fsu ogni terza riga usando il bit 2 opposto sulle ultime due file di ciascun blocco di 6 per un salvataggio di 1 byte.

MATL, 42 36 33 byte

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

Formato di input è: nCols, offset,nRows

Provalo online

L'approccio qui è che impostiamo un "modello" che poi indicizziamo usando gli indici di riga ( [1 2 ... nRows]) e gli indici di colonna spostati dal primo input ( [1 2 ... nCols] - shift). Grazie all'indicizzazione modulare di MATL, si tradurrà automaticamente in un risultato affiancato. Come nota a margine, per risparmiare un po 'di spazio, tecnicamente lavoro con una versione trasposta del modello e poi prendo un transpose ( !) alla fine.

Il modello è questo:

________
       |
       |
________
  |     
  |     

Python 2, 93 88 byte

Il secondo livello di rientro è nella scheda Salvataggio di alcuni byte grazie a Leaky Nun e ad alcune proprie modifiche, anche ora offset corretto:

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

codice precedente:

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]

Stessa lunghezza del lambda senza nome:

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 byte

(Testato su QB64)

Grazie a @DLosc per aver giocato a golf la mia IFaffermazione con un equivalente matematico. Valeva 12 byte.

Metodo generale:

Ciclo attraverso ogni cella, uno alla volta e determinare se debba essere _, o |seconda della sua posizione. MODle dichiarazioni e la logica booleana sono usate per determinare i confini del mattone e quanto scaglionare i mattoni.

Codice:

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

Nota d'uso:

QBasic prevede che l'input sia un numero separato da virgole.

Java, 149 , 147 , 146 , 143 byte

golfed:

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

}

Rubino, 72 66 byte

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

Grazie @Value Ink per 6 byte!

Moltiplicazione e divisione semplici delle stringhe.

Funziona in Ruby 2.3.0 (la versione 2.1 di Ideone ha generato un errore di sintassi).

Julia: 150 128 116 108 107 byte

# 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'...)

per funzionare con argomenti: julia -e 'o=2;h=18;w=40;include("codegolf.jl")'

Se ritieni che chiamare da bash stia tradendo e desideri una funzione all'interno dell'interprete, la versione della funzione è di 117 byte :)

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

dimostrazione

(Grazie, @ glen-o per il suggerimento aggiuntivo per il risparmio di byte!)

JavaScript, 172 168 165 157 147 142 137 byte

(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 byte

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

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

⎕viene valutato l'input; come l'espressione viene eseguito da destra a sinistra, esso richiede F, We Hin questo ordine

¯8↑'|' è ' |'

⎕⌽ viene ruotato, taglia i caratteri F dalla parte anteriore e li mette alla fine della stringa

l'altro ⌽significa inversione

'_',2⍴⊂ crea una 3 tupla di '_' seguita da due copie separate della stringa finora

a,4⌽¨a← aggiungere la 4 rotazione di tutto finora, finiamo con una 6 tupla

⎕⍴¨ rimodellare ogni elemento alla larghezza

⎕⍴ rimodellare all'altezza

↑ mescola vettore di vettori in una matrice

In realtà , 44 43 40 byte

Questa è in realtà una porta dell'algoritmo nella risposta JS di Neil . Suggerimenti di golf benvenuti. Provalo online!

╗╝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 byte

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

Provalo online!

Ottava 80 76 byte

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

per eseguire dal terminale: octave --eval "o=2;h=18;w=44; codegolf"

(in alternativa, se si pensa che la chiamata terminale stia tradendo: p, un'implementazione della funzione anonima richiede 86 byte :)

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

Chiama f(2,18,44)all'interprete di ottava.

Bash + Sed, 411 395 381 370 byte:

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

Bene, ecco la mia prima risposta in Bash, o in qualsiasi linguaggio di scripting della shell per quella materia. Questa è anche di gran lunga la risposta più lunga qui. Accetta una sequenza di argomenti della riga di comando separati da spazio nel formato Offset Width Height. Questo può probabilmente essere molto più breve di quello che è attualmente, quindi sono apprezzati tutti i suggerimenti e / o trucchi per giocare a golf più in basso.

Delphi / Object Pascal, 305 , 302 , 292 byte

Programma console completo che legge 3 parametri.

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.

ungolfed

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.

Purtroppo, Delphi non ha un operatore ternario ed è un linguaggio piuttosto prolisso.

caso di prova

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

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

Modifica: potrebbe radere di 3 byte usando byte come tipo per tutte le variabili.

Modifica 2: E le applicazioni console non richiedono la dichiarazione del programma, -10