Imagine que uma grade retangular de |caracteres represente as cordas esticadas de um tear ( a urdidura ) em que outros fios ( a trama ), que iremos representar como -, podem ser tecidos.

Aqui está a urdidura não tecida de um tear 7 × 4:

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

Existem várias maneiras pelas quais a trama pode ser tecida na urdidura, sendo a mais simples a trama simples .

Na primeira linha de uma trama simples, a trama começa acima da primeira corda de urdidura, fica abaixo da segunda corda, depois acima da terceira corda, depois abaixo da quarta e assim por diante.

A segunda linha de trama é idêntica à primeira, mas deslocada para a direita por uma corda de distorção;

Em nosso tear 7 × 4, a trama simples é assim:

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

Podemos descrever a trama simples dizendo que a trama ultrapassa a dobra 1 vez e depois menos de 1 vez, e cada linha subseqüente é deslocada 1 corda para a direita.

Uma trama generalizada pode ser descrita fazendo a trama ultrapassar os tempos de urdidura v , depois os tempos u , com cada linha subsequente deslocada por s strings para a direita. (Todos os valores são inteiros, s pode ser 0 ou negativo, u e v devem não ser negativos.)

Um tear 7 × 4 com v = 1 , u = 2 , s = 2 , um tipo de tecido de sarja :

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

Desafio

Sua tarefa é escrever o programa mais curto (em bytes) que produz um padrão entrelaçado de barras e traços, dados v , u , s , a largura e altura do tear e o deslocamento inicial .

O deslocamento inicial é o número de strings que a primeira linha da trama é deslocada para a direita (0 nos exemplos acima). Cada linha subseqüente é deslocada por mais s strings.

Seu programa deve receber esses 6 números em um formato fácil de usar (stdin, uma chamada de função etc.) e gerar a grade de barras e retângulos entrelaçados para stdout. Você pode assumir que todas as entradas são válidas. (Todos os valores são números inteiros, a largura e a altura devem ser positivas, o deslocamento inicial pode ser qualquer coisa.)

Exemplos

largura = 5, altura = 4, deslocamento inicial = 0, v = 1, u = 3, s = -2:

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

largura = 5, altura = 4, deslocamento inicial = 3, v = 1, u = 3, s = -2:

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

largura = 5, altura = 4, deslocamento inicial = 1, v = 1, u = 1, s = 0:

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

largura = 5, altura = 4, deslocamento inicial = 0, v = 1, u = 0, s = 0:

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

Notas

• O padrão sempre começa com a trama sobre a urdidura no canto superior esquerdo da grade (a menos que seja inicialmente alterado).
• Todas as linhas da trama vêm da esquerda. Eles não espiral como este .
• u + v não é necessariamente um múltiplo da largura da grade.
• u e v podem não 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}

Não há muito a dizer sobre isso. Eu construo uma repetição de -e |, repito wvezes (apenas para ter certeza), e eu corto a seção apropriada para cada linha.

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

Teste

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 ... Tão tentado a aprender rubi agora.

Entrada atribuindo uma variável de cadeia de caracteres neste formato: "largura, altura, deslocamento inicial, v, u, s".
Cole antes do programa:

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

JavaScript (ES6), 111 bytes

Uma abordagem ES6 ligeiramente diferente, usando o Array.from funcional.

frecebe argumentos (w,h,i,v,u,s)e retorna uma string. Novas linhas adicionadas ao código e literal nova linha na string substituídas por \npara maior clareza; nem refletido na contagem 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)) /*

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

*/

Versão ungolfed com explicação

Eu salvei alguns bytes criando um alias para Array, que não é refletido na versão não destruída.

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

"É mais confortável do que parece." "Teria que ser." - Gia e Eidon (ninguém vai conseguir essa referência. Dica: "Tapete de tecer")

Então, eu estou trabalhando nisso há cerca de cinco horas e desisto. Não tenho ideia de como fazer esse código funcionar. Ele continua voltando para trás após a primeira linha e depois fica totalmente errado (7 4 0 2 2 1).

Aqui está a versão mais simples que você pode ler com mais facilidade. Tudo o que faço é recuperar a entrada, criar a matriz de modelos e imprimir nos loops.

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

Você pode testá-lo facilmente aqui: http://www.compileonline.com/compile_c_online.php usando "7 4 0 1 1 1" na caixa de entrada STDIN na parte inferior. Comece a editar os números e você verá os problemas.

Desculpe, não consegui encontrar uma solução funcional; Eu estou me odiando por isso. Gastei muito tempo para não enviá-lo para que alguém conserte.

Eu uso este printf há algum tempo para separar ainda mais a linha superior (fácil) do restante deles (as linhas com problema): 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]))