Ziel dieser Herausforderung ist es, eine ASCII-Version des Covers dieses großartigen Albums der Rockband Pink Floyd zu produzieren.

Die Ziegelknoten bestehen aus Zeichen _und |. Steine ​​haben eine Breite von 7 und eine Höhe von 2 Zeichen, ausgenommen Kreuzungen. Die Basiseinheit, einschließlich der Verbindungsstellen, ist also:

_________
|       |
|       |
_________

Jede Ziegelreihe ist gegenüber der vorherigen um eine halbe Ziegelbreite (4 Zeichen) versetzt:

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

Die Wand wird wie folgt parametriert . Alle Parameter werden in Zeichen einschließlich Übergängen gemessen:

1. Horizontal - Offset der ersten Zeile F. Dies ist der Abstand zwischen dem linken Rand und der ersten vertikalen Verbindung der obersten Reihe. (Denken Sie auch an den relativen Versatz von Ziegeln zwischen den Zeilen). Seine Werte sind möglich 0, 1..., 7.
2. Gesamtbreite , W. Dies schließt Knotenpunkte ein. Sein Wert ist eine positive ganze Zahl.
3. Gesamthöhe , H. Dies schließt Knotenpunkte ein. Sein Wert ist eine positive ganze Zahl.

Die Oberseite der Wand fällt immer mit der Oberseite einer Reihe zusammen. Der Boden kann zerlumpt sein (wenn die Gesamthöhe nicht ein Vielfaches von ist 3). Zum Beispiel ist hier der Ausgang für 6, 44, 11:

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

und eine visuelle Erklärung der Parameter:

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

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

Zusätzliche Regeln

Sie können ein Programm oder eine Funktion bereitstellen.

Das Eingabeformat ist wie gewohnt flexibel. Die Ausgabe kann über STDOUT oder ein von einer Funktion zurückgegebenes Argument erfolgen. In diesem Fall kann es sich um eine Zeichenfolge mit Zeilenumbrüchen oder ein Array von Zeichenfolgen handeln.

Leerzeichen oder Zeilenumbrüche sind erlaubt.

Kürzester Code in Bytes gewinnt.

Testfälle

Die Eingaben erfolgen in der oben angegebenen Reihenfolge, dh horizontaler Versatz der ersten Reihe, Gesamtbreite, Gesamthöhe.

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


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


1, 1, 1:
_


1, 2, 3:
__
 |
 |


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

Pyth, 43 27 Bytes

Ich muss heftig Golf spielen ... der Score ist zu beschämend.

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

Probieren Sie es schon online aus.

Eingabeformat

6,44
11

Ausgabeformat

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

Erläuterung

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 Bytes

3 Bytes gespart dank Lynn.
1 Byte gespart dank 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 Bytes

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

Aufrufen als b(F, W, H).

Perl, 63 Bytes

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

Wenn Sie den Shebang als 2 zählen, wird die Eingabe von stdin mit Leerzeichen getrennt vorgenommen.

Beispielnutzung

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

Haskell, 83 Bytes

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

Dies definiert eine ternäre Infix-Funktion, !die eine Liste von Zeichenfolgen zurückgibt. Anwendungsbeispiel:

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

Wie es funktioniert:

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

Erläuterung: Erstellt eine Zeichenfolge aus den sich wiederholenden 7 Leerzeichen plus |Muster oder nur aus den wiederholten _s, die jedoch mindestens so lang ist, dass wdie für jede Zeile erforderlichen Zeichen extrahiert werden können . Die ersten drei Zeilen beginnen an der Position f^7und die nächsten drei Zeilen beginnen an der Position f^3. Dies erreiche ich, indem ich Bit 2 fin jeder dritten Zeile umschalte und das gegenüberliegende Bit 2 in den letzten beiden Zeilen jedes 6er-Blocks zum Speichern von 1 verwende Byte.

MATL, 42 36 33 Bytes

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

Eingabeformat ist: nCols, offset,nRows

Probieren Sie es online

Der Ansatz hier ist, dass wir eine "Vorlage" einrichten, in die wir dann mithilfe der Zeilenindizes ( [1 2 ... nRows]) und Spaltenindizes, die um die erste Eingabe ( [1 2 ... nCols] - shift) verschoben wurden, indexieren . Dank der modularen Indizierung von MATL wird automatisch eine gekachelte Ausgabe erstellt. Als Randnotiz, um etwas Platz zu sparen, arbeite ich technisch mit einer transponierten Version der Vorlage und nehme dann einfach eine transponierte ( !) am Ende.

Die Vorlage lautet wie folgt:

________
       |
       |
________
  |     
  |     

Python 2, 93 88 Bytes

Die zweite Einrückungsebene ist die Registerkarte. Ein paar Bytes sparen dank Leaky Nun und einigen eigenen Änderungen, auch jetzt korrekter Versatz:

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

vorheriger Code:

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]

Gleiche Länge wie unbenanntes Lambda:

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 Bytes

(Getestet auf QB64)

Vielen Dank an @DLosc, dass Sie meine IFAussage mit einem mathematischen Äquivalent bewertet haben . Das war 12 Bytes wert.

Allgemeine Methode:

Schleife durch jede Zelle einer nach dem anderen und bestimmen , ob es eine sein sollte _, oder |auf dessen Lage abhängig. MODAnweisungen und Boolesche Logik werden verwendet, um die Ziegelgrenzen zu bestimmen und um wie viel die Ziegel versetzt werden sollen.

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

Anwendungshinweis:

QBasic erwartet, dass Eingaben durch Kommas getrennte Zahlen sind.

Java, 149 , 147 , 146 , 143 Bytes

Golf gespielt:

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

}

Rubin, 72 66 Bytes

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

Danke @Value Ink für 6 Bytes!

Einfache String-Multiplikation und -Aufteilung.

Funktioniert in Ruby 2.3.0 (Ideones Version 2.1 warf einen Syntaxfehler).

Julia: 150 128 116 108 107 Bytes

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

mit Argumenten laufen: julia -e 'o=2;h=18;w=40;include("codegolf.jl")'

Wenn Sie das Gefühl haben, dass der Aufruf von bash betrügt und Sie eine Funktion innerhalb des Interpreters möchten, dann ist die Funktionsversion 117 Bytes :)

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

Demo

(Danke, @ glen-o für den zusätzlichen Byte-Spartipp!)

JavaScript, 172 168 165 157 147 142 137 Bytes

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

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

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

⎕wird Eingabe ausgewertet; als Ausdruck von rechts nach links ausführt, fordert es F, Wund Hin dieser Reihenfolge

¯8↑'|' ist ' |'

⎕⌽ rotiert, schneidet F-Zeichen von vorne und setzt sie am Ende der Zeichenkette

das andere ⌽bedeutet umgekehrt

'_',2⍴⊂ Erstellt ein 3-Tupel von '_', gefolgt von zwei separaten Kopien der Zeichenfolge

a,4⌽¨a← Füge die 4-Rotation von allem hinzu, bis dahin erhalten wir ein 6-Tupel

⎕⍴¨ Verändern Sie die Breite jedes Elements

⎕⍴ auf die Höhe umformen

↑ Vektor von Vektoren in eine Matrix mischen

Eigentlich , 44 43 40 Bytes

Dies ist ein tatsächlicher Port des Algorithmus in Neils JS-Antwort . Golfvorschläge sind willkommen. Probieren Sie es 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)]}

Probieren Sie es online!

Oktave 80 76 Bytes

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

vom Terminal aus laufen: octave --eval "o=2;h=18;w=44; codegolf"

(alternativ, wenn Sie glauben, dass der Terminal-Aufruf schummelt: p, dann benötigt eine anonyme Funktionsimplementierung 86 Bytes :)

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

Rufen Sie f(2,18,44)den Oktav-Interpreter an.

Bash + Sed, 411 395 381 370 Bytes:

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

Hier ist meine allererste Antwort in Bash oder einer anderen Shell-Skriptsprache. Dies ist auch bei weitem die längste Antwort hier. Übernimmt eine Folge von durch Leerzeichen getrennten Befehlszeilenargumenten im Format Offset Width Height. Dies kann wahrscheinlich viel kürzer sein als es derzeit ist, so dass alle Tipps und / oder Tricks zum Golfspielen mehr geschätzt werden.

Delphi / Object Pascal, 305 , 302 , 292 Bytes

Volles Konsolenprogramm, das 3 Parameter liest.

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.

Leider hat Delphi keinen ternären Operator und es ist eine ziemlich ausführliche Sprache.

Testfall

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

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

Bearbeiten: Konnte 3 Bytes sparen, indem Byte als Typ für alle Variablen verwendet wurde.

Bearbeiten 2: Und Konsolenanwendungen nicht brauchen die Programmdeklaration, -10