Imagine que una cuadrícula rectangular de |caracteres representa las cuerdas tensas en un telar ( la urdimbre ) que otros hilos ( la trama ), que representaremos como -, se pueden entrelazar.

Aquí está la urdimbre no tejida de un telar de 7 × 4:

|||||||
|||||||
|||||||
|||||||

Hay varias formas en que la trama se puede tejer en la urdimbre, la más simple es la trama simple .

En la primera fila de un tejido plano, la trama comienza por encima de la primera cadena de urdimbre, va por debajo de la segunda cadena, luego por encima de la tercera cadena, luego por debajo de la cuarta, y así sucesivamente.

La segunda fila de trama es idéntica a la primera, pero desplazada a la derecha por una cadena de urdimbre, por lo que comienza debajo, luego pasa, y así sucesivamente.

En nuestro telar 7 × 4, el tejido liso se ve así:

-|-|-|-
|-|-|-|
-|-|-|-
|-|-|-|

Podemos describir el tejido liso diciendo que la trama pasa la urdimbre 1 vez, luego menos de 1 vez, y cada fila posterior se desplaza 1 cadena hacia la derecha.

Se puede describir un tejido generalizado haciendo que la trama pase por la urdimbre v veces, luego debajo de u veces, con cada fila posterior desplazada por s cadenas a la derecha. (Todos los valores son enteros, s puede ser 0 o negativo, u y v deben ser no negativos).

Un telar de 7 × 4 con v = 1 , u = 2 , s = 2 , un tipo de tejido de sarga :

-||-||-
||-||-|
|-||-||
-||-||-

Desafío

Su tarea es escribir el programa más corto (en bytes) que produce un patrón tejido de barras y guiones dados v , u , s , el ancho y la altura del telar y el desplazamiento inicial .

El cambio inicial es el número de cadenas que la primera fila de la trama se desplaza hacia la derecha (0 en los ejemplos anteriores). Cada fila posterior se desplaza por s más cadenas.

Su programa debe tomar estos 6 números en un formato fácil de usar (stdin, una llamada a función, etc.) y generar la cuadrícula tejida de barras y rectángulos en stdout. Puede suponer que todas las entradas son válidas. (Todos los valores son enteros, el ancho y la altura deben ser positivos, el desplazamiento inicial puede ser cualquier cosa).

Ejemplos

ancho = 5, altura = 4, desplazamiento inicial = 0, v = 1, u = 3, s = -2:

-|||-
||-||
-|||-
||-||

ancho = 5, altura = 4, desplazamiento inicial = 3, v = 1, u = 3, s = -2:

|||-|
|-|||
|||-|
|-|||

ancho = 5, altura = 4, desplazamiento inicial = 1, v = 1, u = 1, s = 0:

|-|-|
|-|-|
|-|-|
|-|-|

ancho = 5, altura = 4, desplazamiento inicial = 0, v = 1, u = 0, s = 0:

-----
-----
-----
-----

Notas

• El patrón siempre comienza con la trama sobre la urdimbre en la esquina superior izquierda de la cuadrícula (a menos que se cambie inicialmente).
• Todos los hilos de trama vienen desde la izquierda. No hacen espiral como este .
• u + v no es necesariamente un múltiplo del ancho de la cuadrícula.
• u y v pueden no ser ambos 0

Ruby, 72 bytes

w,h,v,u,s,i=$*.map &:to_i;h.times{puts ((?-*v+?|*u)*w)[-i%(u+v),w];i+=s}

No hay mucho que decir sobre esto. Construyo una repetición de -y |, la repito wveces (solo para estar seguro), y luego corto la sección apropiada para cada línea.

JavaScript (ES 6) 128

F=(w,h,i,v,u,s)=>{for(x=('-'[R='repeat'](v)+'|'[R](u))[R](w*h),l=v+u,i=-i%l+l,s=-s%l+l;h--;i+=s)console.log(x.substr(i,w)+'\n')}

Prueba

F(11,8,2,5,3,-2)

||-----|||-
-----|||---
---|||-----
-|||-----||
||-----|||-
-----|||---
---|||-----
-|||-----||

Python, 92 bytes

w,h,i,v,u,s=eval(A)
x=('|'*u+'-'*v)*w
while h:print(x[-i:]+x[:-i])[-w:];x=x[-s:]+x[:-s];h-=1

Hmm ... Tan tentado de aprender rubí ahora.

Ingrese asignando una variable de cadena en este formato: "ancho, alto, desplazamiento inicial, v, u, s".
Pegar antes del programa:

A="80,80,0,2,2,-9"

JavaScript (ES6), 111 bytes

Un enfoque ES6 ligeramente diferente, utilizando el Array.from funcional.

ftoma argumentos (w,h,i,v,u,s)y devuelve una cadena. Se agregaron nuevas líneas al código y una nueva línea literal en una cadena reemplazada por \nclaridad; ninguno se refleja en el recuento de bytes.

f=(w,h,i,v,u,s)=>(A=Array).from(A(h),(_,j)=>A.from(A(w),
(_,k)=>(j*((x=v+u)-s)+x+k-i)%x<v?'-':'|').join``).join`\n`

Uso

console.log(f(5,4,0,1,3,-2)) /*

-|||-
||-||
-|||-
||-||

*/

Versión sin golf con explicación

Ahorré algunos bytes al crear un alias para Array, que no se refleja en la versión sin golf.

// take input and create an array of length h (height):
f = (w,h,i,v,u,s) => Array.from( Array(h),

    // in each row position j, create an array of length w (width):
    (_,j) => Array.from( Array(w), 

        // in each cell, place - or | depending on the pattern (i,v,u,s)
        // and current position (j,k):
        (_,k) => ( j * ( ( x = v + u ) - s ) + x + k - i ) % x < v ? '-' : '|'

    // turn each row into a string:
    ).join``

// join rows with newlines:
).join`\n`

C, 357 bytes

#include<stdio.h>
int w,h,t,v,u,s,i,j,l,f;int main(){scanf("%d %d %d %d %d %d",&w,&h,&t,&v,&u,&s);l=v+u;char g[l];g[l]='\0';f=0;while(u--){g[v+u]='|';}while(v--){g[v]='-';}for(i=0;i<h;i++){for(j=0;j<w;j++){printf("%c",g[abs(t+f+j)%l]);}printf("\n");f-=s;}}

"Es más cómodo de lo que parece". "Tendría que ser así". - Gia y Eidon (Nadie va a obtener esta referencia. Sugerencia: "Weave Mat")

Así que he estado trabajando en esto durante unas cinco horas y me doy por vencido. No tengo idea de cómo hacer que este código funcione. Sigue retrocediendo después de la primera fila y luego se equivoca por completo (7 4 0 2 2 1).

Aquí está la versión más simple que puede leer más fácilmente. Todo lo que hago es recuperar la entrada, hacer la matriz de plantillas y luego imprimir dentro de los bucles.

#include<stdio.h>
int w,h,t,v,u,s,i,j,l,f;
int main(){
    scanf("%d %d %d %d %d %d",&w,&h,&t,&v,&u,&s);
    l=v+u;char g[l];g[l]='\0';f=0;
    while(u--){g[v+u]='|';}while(v--){g[v]='-';}
    for(i=0;i<h;i++){
        for(j=0;j<w;j++){
            printf("%c",g[abs(t+f+j)%l]); // THIS is the line that needs help.
        }
        printf("\n");
        f-=s;
    }
}

Puede probarlo fácilmente aquí: http://www.compileonline.com/compile_c_online.php usando "7 4 0 1 1 1" en el cuadro de entrada STDIN en la parte inferior. Comience a editar los números y verá los problemas.

Lo siento, no pude encontrar una solución que funcione; Me estoy odiando por esto. He pasado demasiado tiempo para no subirlo para que alguien más lo arregle.

He estado usando este printf durante un tiempo para separar aún más la fila superior (fácil) del resto de ellas (las filas problemáticas): printf("%c",g[i?abs(t+f+j)%l:abs(t+j)%l]);

Haskell, 126 bytes

f w h i v u s=putStr.unlines$take h$take w<$>(iterate(drop(mod s(u+v)))$drop(mod(-i)(u+v)).cycle$('-'<$[1..v])++('|'<$[1..u]))