Immagina che una griglia rettangolare di |caratteri rappresenti le corde tese su un telaio ( l'ordito ) su cui possono essere intessuti altri fili ( la trama ), che rappresenteremo come -.

Ecco l'ordito non tessuto di un telaio 7 × 4:

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

Esistono diversi modi in cui la trama può essere intessuta nell'ordito, la più semplice è la trama semplice .

Nella prima riga di una trama semplice la trama inizia sopra la prima stringa di ordito, passa sotto la seconda stringa, quindi sopra la terza stringa, quindi sotto la quarta e così via.

La seconda riga di trama è identica alla prima ma sfalsata a destra di una stringa di curvatura, quindi inizia sotto poi va oltre e così via.

Sul nostro telaio 7 × 4 la trama semplice si presenta così:

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

Possiamo descrivere la trama semplice dicendo che la trama supera 1 volta l'ordito , quindi meno di 1 volta, e ogni riga successiva viene spostata di 1 stringa verso destra.

Una trama generalizzata può essere descritta facendo in modo che la trama superi i tempi di curvatura v volte, quindi sotto i tempi u , con ogni riga successiva spostata dalle stringhe di s a destra. (Tutti i valori sono numeri interi, s può essere 0 o negativo, u e v devono essere non negativi.)

Un telaio 7 × 4 con v = 1 , u = 2 , s = 2 , un tipo di armatura a saia :

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

Sfida

Il tuo compito è quello di scrivere il programma più breve (in byte) che produca un modello di barre e trattini dato v , u , s , la larghezza e l'altezza del telaio e lo spostamento iniziale .

Lo spostamento iniziale è il numero di stringhe che la prima riga nella trama viene spostata verso destra (0 negli esempi sopra). Ogni riga successiva viene spostata di s più stringhe.

Il tuo programma dovrebbe prendere questi 6 numeri in un formato facile da usare (stdin, una chiamata di funzione, ecc.) E generare la griglia tessuta di barre e rettangoli su stdout. Si può presumere che tutti gli input siano validi. (Tutti i valori sono numeri interi, larghezza e altezza devono essere positivi, lo spostamento iniziale può essere qualsiasi cosa.)

Esempi

larghezza = 5, altezza = 4, spostamento iniziale = 0, v = 1, u = 3, s = -2:

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

larghezza = 5, altezza = 4, spostamento iniziale = 3, v = 1, u = 3, s = -2:

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

larghezza = 5, altezza = 4, spostamento iniziale = 1, v = 1, u = 1, s = 0:

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

larghezza = 5, altezza = 4, spostamento iniziale = 0, v = 1, u = 0, s = 0:

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

Appunti

• Il modello inizia sempre con la trama sopra l'ordito nell'angolo in alto a sinistra della griglia (a meno che non sia inizialmente spostata).
• Tutti i fili di trama arrivano da sinistra. Loro non lo fanno spirale come questo .
• u + v non è necessariamente un multiplo della larghezza della griglia.
• u e v potrebbero non essere entrambi 0

Rubino, 72 byte

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

Non c'è molto da dire al riguardo. Costruisco una ripetizione di -e |, lo ripeto wvolte (solo per essere sicuro), e taglio la sezione appropriata per ogni riga.

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

Test

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

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

Python, 92 byte

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 ... Così tentato di imparare il rubino ora.

Immettere assegnando una variabile stringa in questo formato: "larghezza, altezza, spostamento iniziale, v, u, s".
Incolla prima del programma:

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

JavaScript (ES6), 111 byte

Un approccio ES6 leggermente diverso, usando il funzionale Array.from.

faccetta argomenti (w,h,i,v,u,s)e restituisce una stringa. Newline aggiunti al codice e letterali newline nella stringa sostituiti da \nper chiarezza; nessuno dei due si riflette nel conteggio dei byte.

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

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

*/

Versione non golfata con spiegazione

Ho salvato alcuni byte creando un alias per Array, che non si riflette nella versione non modificata.

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

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

"È più comodo di quanto sembri." "Dovrebbe essere." - Gia ed Eidon (nessuno otterrà questo riferimento. Suggerimento: "Weave Mat")

Quindi ci sto lavorando da circa cinque ore, e mi arrendo. Non ho idea di come far funzionare questo codice. Continua a tornare indietro dopo la prima fila e poi si sbaglia completamente (7 4 0 2 2 1).

Ecco la versione più semplice che puoi leggere più facilmente. Tutto quello che faccio è recuperare input, creare l'array template e quindi stampare all'interno dei loop.

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

Puoi facilmente provarlo qui: http://www.compileonline.com/compile_c_online.php usando "7 4 0 1 1 1" nella casella di input STDIN in basso. Inizia a modificare i numeri e vedrai i problemi.

Mi dispiace non essere riuscito a trovare una soluzione funzionante; Mi sto odiando per questo. Ho passato troppo tempo a non caricarlo per far riparare qualcun altro.

Sto usando questo printf da un po 'di tempo per separare ulteriormente la riga superiore (facile) da tutte le altre (le righe del problema): printf("%c",g[i?abs(t+f+j)%l:abs(t+j)%l]);

Haskell, 126 byte

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