El propósito de este desafío es producir una versión ASCII de la portada de este gran álbum de la banda de rock Pink Floyd.

Las uniones de ladrillo están hechas de caracteres _y |. Los ladrillos tienen caracteres de ancho 7 y alto 2, excluyendo las uniones. Entonces, la unidad básica, incluidas las uniones, es:

_________
|       |
|       |
_________

Cada fila de ladrillos está compensada por medio ancho de ladrillo (4 caracteres) con respecto a la fila anterior:

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

El muro se parametriza de la siguiente manera. Todos los parámetros se miden en caracteres, incluidas las uniones:

1. Desplazamiento horizontal de la primera fila, F. Esta es la distancia entre el margen izquierdo y la primera unión vertical de la fila superior. (Recuerde también el desplazamiento relativo de medio ladrillo entre filas). Sus valores posibles son 0, 1, ..., 7.
2. Total anchura , W. Esto incluye cruces. Su valor es un entero positivo.
3. Total de altura , H. Esto incluye cruces. Su valor es un entero positivo.

La parte superior de la pared siempre coincide con la parte superior de una fila. El fondo puede ser irregular (si la altura total no es un múltiplo de 3). Por ejemplo, aquí está la salida para 6, 44, 11:

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

y una explicación visual de los parámetros:

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

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

Reglas adicionales

Puede proporcionar un programa o una función.

El formato de entrada es flexible como de costumbre. La salida puede ser a través de STDOUT o un argumento devuelto por una función. En este caso, puede ser una cadena con nuevas líneas o una serie de cadenas.

Se permiten espacios finales o líneas nuevas.

El código más corto en bytes gana.

Casos de prueba

Las entradas están en el orden indicado anteriormente, es decir: desplazamiento horizontal de la primera fila, ancho total, altura total.

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


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


1, 1, 1:
_


1, 2, 3:
__
 |
 |


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

Pyth, 43 27 bytes

Yo necesito al golf que en gran medida el resultado ... es demasiado vergonzoso.

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

Pruébalo en línea ya.

Formato de entrada

6,44
11

Formato de salida

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

Explicación

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 guardados gracias a Lynn.
1 byte guardado gracias 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 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);}

Invocar como b(F, W, H).

Perl, 63 bytes

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

Contando el shebang como 2, la entrada se toma de stdin, con espacios en blanco separados.

Uso de muestra

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

Esto define una función infija ternaria !que devuelve una lista de cadenas. Ejemplo de uso:

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

Cómo funciona:

            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 bytes

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>

Explicación: Crea una cadena de los 7 espacios repetitivos más el |patrón o simplemente _s repetidos , pero al menos lo suficiente como para poder extraer los wcaracteres necesarios para cada fila. Las primeras tres filas comienzan en la posición f^7y luego las siguientes tres filas comienzan en la posición f^3, así que lo logro alternando el bit 2 de fcada tercera fila usando el bit opuesto 2 en las últimas dos filas de cada bloque de 6 para ahorrar 1 byte.

MATL, 42 36 33 bytes

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

El formato de entrada es: nCols, offset,nRows

Pruébalo en línea

El enfoque aquí es que configuramos una "plantilla" que luego indexamos usando los índices de fila ( [1 2 ... nRows]) y los índices de columna desplazados por la primera entrada ( [1 2 ... nCols] - shift). Gracias a la indexación modular de MATL, automáticamente dará como resultado una salida en mosaico. Como nota al margen, para ahorrar algo de espacio, técnicamente trabajo con una versión transpuesta de la plantilla y luego tomo una transposición ( !) al final.

La plantilla es esta:

________
       |
       |
________
  |     
  |     

Python 2, 93 88 bytes

El segundo nivel de sangría es la pestaña Guardar algunos bytes gracias a Leaky Nun y algunas modificaciones propias, ahora también el desplazamiento correcto:

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

código anterior:

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]

Misma longitud que lambda sin nombre:

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, 121109 bytes

(Probado en QB64)

Gracias a @DLosc por jugar golf con mi IFdeclaración con un equivalente matemático. Eso valía 12 bytes.

Método general

Bucle a través de cada célula de uno en uno y determinar si debe ser una _, o |dependiendo de su ubicación. MODLas declaraciones y la lógica booleana se utilizan para determinar los límites de los ladrillos y cuánto escalonarlos.

Código:

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 de uso:

QBasic espera que las entradas sean números separados por comas.

Java, 149 , 147 , 146 , 143 bytes

Golfizado:

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

Sin golf:

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

}

Rubí, 72 66 bytes

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

¡Gracias @Value Ink por 6 bytes!

Simple multiplicación de cuerda y corte.

Funciona en Ruby 2.3.0 (la versión 2.1 de Ideone arrojó un error de sintaxis).

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

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

Si crees que llamar desde bash es una trampa y quieres una función dentro del intérprete, entonces la versión de la función es de 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'...))

manifestación

(¡Gracias, @ glen-o por el consejo adicional para guardar bytes!)

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

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

⎕se evalúa la entrada; como la expresión ejecuta de derecha a izquierda, se solicita F, Wy Hen ese orden

¯8↑'|' es ' |'

⎕⌽ gira, corta los caracteres F desde el frente y los coloca al final de la cuerda

el otro ⌽significa revertir

'_',2⍴⊂ crea una tupla de 3 de '_' seguida de dos copias separadas de la cadena hasta el momento

a,4⌽¨a← agregue la 4 rotación de todo hasta ahora, terminamos con una tupla de 6

⎕⍴¨ remodelar cada elemento al ancho

⎕⍴ remodelar a la altura

↑ mezclar vectores de vectores en una matriz

En realidad , 44 43 40 bytes

Este es un puerto real del algoritmo en la respuesta JS de Neil . Sugerencias de golf bienvenidas. Pruébalo en línea!

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

No golfista:

          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 bytes

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

Pruébalo en línea!

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

para correr desde la terminal: octave --eval "o=2;h=18;w=44; codegolf"

(alternativamente, si cree que la llamada de terminal está haciendo trampa: p, entonces una implementación de función anónima toma 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))

Llame f(2,18,44)al intérprete de octava.

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

Bueno, aquí está mi primera respuesta en Bash, o cualquier lenguaje de script de shell para el caso. Esta es también, con mucho, la respuesta más larga aquí. Toma una secuencia de argumentos de línea de comandos separados por espacios en el formato Offset Width Height. Esto probablemente puede ser mucho más corto de lo que es actualmente, por lo que se agradece cualquier consejo y / o truco para jugar golf más abajo.

Delphi / Object Pascal, 305 , 302 , 292 bytes

Programa de consola completa que lee 3 parámetros.

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.

sin 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.

Lamentablemente, Delphi no tiene un operador ternario y es un lenguaje bastante detallado.

caso de prueba

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

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

Editar: podría reducir 3 bytes utilizando byte como tipo para todas las variables.

Edición 2: y las aplicaciones de consola no necesitan la declaración del programa, -10