Imaginez une grille rectangulaire de |caractères représentant les chaînes tendues d'un métier à tisser ( la chaîne ) sur lesquelles d'autres fils ( la trame ), que nous représenterons -, peuvent être tissés.

Voici la chaîne non tissée d'un métier à tisser 7 × 4:

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

Il existe un certain nombre de façons dont la trame peut être tissée dans la chaîne, la plus simple étant l' armure toile .

Dans la première rangée d'une armure toile, la trame commence au-dessus de la première chaîne de chaîne, descend en dessous de la deuxième chaîne, puis au-dessus de la troisième chaîne, puis en dessous de la quatrième, etc.

La deuxième ligne de trame est identique à la première mais décalée vers la droite d'une chaîne de chaîne, elle commence donc sous puis passe, et ainsi de suite.

Sur notre métier à tisser 7 × 4, le tissage uni ressemble à ceci:

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

Nous pouvons décrire le tissage simple en disant que la trame passe sur la chaîne 1 fois, puis sous 1 fois, et chaque ligne suivante est décalée d' une chaîne vers la droite.

Un tissage généralisé peut être décrit en faisant passer la trame sur les temps v de chaîne , puis sur les temps u , chaque rangée suivante étant décalée de s chaînes vers la droite. (Toutes les valeurs sont des entiers, s peut être 0 ou négatif, u et v doivent être non négatifs.)

Un métier à tisser 7 × 4 avec v = 1 , u = 2 , s = 2 , un type d' armure sergée :

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

Défi

Votre tâche consiste à écrire le programme le plus court (en octets) qui produit un motif tissé de barres et de tirets étant donné v , u , s , la largeur et la hauteur du métier à tisser et le décalage initial .

Le décalage initial est le nombre de chaînes que la première ligne de la trame est décalée vers la droite (0 dans les exemples ci-dessus). Chaque ligne suivante est décalée de s chaînes supplémentaires.

Votre programme doit prendre ces 6 chiffres dans un format facile à utiliser (stdin, un appel de fonction, etc.) et produire la grille tissée de barres et de rectangles sur stdout. Vous pouvez supposer que toutes les entrées sont valides. (Toutes les valeurs sont des entiers, la largeur et la hauteur doivent être positives, le décalage initial peut être n'importe quoi.)

Exemples

largeur = 5, hauteur = 4, décalage initial = 0, v = 1, u = 3, s = -2:

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

largeur = 5, hauteur = 4, décalage initial = 3, v = 1, u = 3, s = -2:

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

largeur = 5, hauteur = 4, décalage initial = 1, v = 1, u = 1, s = 0:

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

largeur = 5, hauteur = 4, décalage initial = 0, v = 1, u = 0, s = 0:

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

Remarques

• Le motif commence toujours par la trame sur la chaîne dans le coin supérieur gauche de la grille (à moins qu'elle ne soit initialement décalée).
• Tous les fils de trame viennent de la gauche. Ils ne tournent pas comme ça .
• u + v n'est pas nécessairement un multiple de la largeur de la grille.
• u et v peuvent ne pas être tous les deux 0

Rubis, 72 octets

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

Pas grand chose à dire à ce sujet. Je crée une répétition de -et |, je la répète plusieurs wfois (juste pour être sûr), et je découpe la section appropriée pour chaque ligne.

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

Tester

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

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

Python, 92 octets

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 ... Tellement tenté d'apprendre le rubis maintenant.

Saisie en affectant une variable chaîne dans ce format: "largeur, hauteur, décalage initial, v, u, s".
Coller avant le programme:

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

JavaScript (ES6), 111 octets

Une approche ES6 légèrement différente, utilisant le Array.from fonctionnel.

fprend des arguments (w,h,i,v,u,s)et retourne une chaîne. Ajout de sauts de ligne au code et saut de ligne littéral dans la chaîne par \nsouci de clarté; ni reflété dans le nombre d'octets.

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`

Usage

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

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

*/

Version non golfée avec explication

J'ai enregistré quelques octets en créant un alias pour Array, qui ne se reflète pas dans la version non golfée.

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

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

"C'est plus confortable qu'il n'y paraît." "Il faudrait que ce soit le cas." - Gia et Eidon (Personne ne va obtenir cette référence. Indice: "Weave Mat")

Je travaille donc sur ce sujet depuis environ cinq heures maintenant, et j'abandonne. Je ne sais pas comment faire fonctionner ce code. Il continue à reculer après la première ligne, puis se trompe complètement (7 4 0 2 2 1).

Voici la version plus simple que vous pouvez lire plus facilement. Tout ce que je fais, c'est récupérer l'entrée, créer le tableau de modèles, puis imprimer dans les boucles.

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

Vous pouvez facilement le tester ici: http://www.compileonline.com/compile_c_online.php en utilisant "7 4 0 1 1 1" dans la zone de saisie STDIN en bas. Commencez à éditer les nombres et vous verrez les problèmes.

Désolé, je n'ai pas pu trouver de solution de travail; Je me déteste pour ça. J'ai passé trop de temps à ne pas le télécharger pour que quelqu'un d'autre le répare.

J'utilise ce printf depuis un certain temps pour séparer davantage la ligne supérieure (facile) des autres (les lignes problématiques): printf("%c",g[i?abs(t+f+j)%l:abs(t+j)%l]);

Haskell, 126 octets

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