Stellen Sie sich ein rechteckiges |Zeichengitter vor, das die gespannten Fäden auf einem Webstuhl ( die Kette ) darstellt, um die andere Fäden ( der Schuss ), die wir darstellen -, gewebt werden können.

Hier ist die ungewebte Kette eines 7 × 4-Webstuhls:

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

Es gibt eine Reihe von Möglichkeiten, wie der Schuss in die Kette eingewebt werden kann, wobei die einfachste die Leinwandbindung ist .

In der ersten Reihe einer Leinwandbindung beginnt der Schuss über der ersten Kette, geht unter der zweiten Kette, dann über der dritten Kette, dann unter der vierten Kette und so weiter.

Die zweite Schussreihe ist mit der ersten identisch, aber um einen Kettfaden nach rechts versetzt. Sie beginnt also unter und geht dann über und so weiter.

Auf unserem 7 × 4-Webstuhl sieht die Leinwandbindung folgendermaßen aus:

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

Wir können die Leinwandbindung beschreiben damit , dass der Schussfaden über die Kett- geht 1 Mal dann unter 1 Zeit, und jede nachfolgende Zeile verschoben 1 String nach rechts.

Eine verallgemeinerte Bindung kann beschrieben werden, indem der Schuss die Kett- V- Zeiten und dann die U- Zeiten durchläuft , wobei jede nachfolgende Reihe um s- Ketten nach rechts verschoben wird . (Alle Werte sind Ganzzahlen, s kann 0 oder negativ sein, u und v dürfen nicht negativ sein.)

Eine 7 × 4-Webmaschine mit v = 1 , u = 2 , s = 2 , eine Art Köperbindung :

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

Herausforderung

Ihre Aufgabe ist es, das kürzeste Programm (in Bytes) zu schreiben, das ein gewebtes Muster aus Strichen und Strichen erzeugt, wenn v , u , s , die Breite und Höhe des Webstuhls und die anfängliche Verschiebung gegeben sind .

Die anfängliche Verschiebung ist die Anzahl der Fäden, um die die erste Reihe im Schuss nach rechts verschoben ist (0 in den obigen Beispielen). Jede folgende Reihe wird durch verschobene s mehr Strings.

Ihr Programm sollte diese 6 Zahlen in einem einfach zu verwendenden Format (stdin, ein Funktionsaufruf usw.) aufnehmen und das gewebte Gitter aus Balken und Rechtecken an stdout ausgeben. Sie können davon ausgehen, dass alle Eingaben gültig sind. (Alle Werte sind ganze Zahlen, Breite und Höhe müssen positiv sein, die anfängliche Verschiebung kann beliebig sein.)

Beispiele

width = 5, height = 4, initial shift = 0, v = 1, u = 3, s = -2:

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

width = 5, height = 4, initial shift = 3, v = 1, u = 3, s = -2:

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

width = 5, height = 4, initial shift = 1, v = 1, u = 1, s = 0:

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

width = 5, height = 4, initial shift = 0, v = 1, u = 0, s = 0:

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

Anmerkungen

• Das Muster beginnt immer mit dem Schuss über der Kette in der oberen linken Ecke des Gitters (sofern nicht anfänglich verschoben).
• Alle Schussfäden kommen von links. Sie tun nicht wie Spirale dies .
• u + v ist nicht unbedingt ein Vielfaches der Gitterbreite.
• u und v dürfen nicht beide 0 sein

Ruby, 72 Bytes

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

Dazu gibt es nicht viel zu sagen. Ich erstelle eine Wiederholung von -und |, wiederhole es wmal (nur um sicherzugehen) und schneide den entsprechenden Abschnitt für jede Zeile heraus.

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

Prüfung

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 ... So versucht, Rubin jetzt zu lernen.

Eingabe durch Zuweisen einer Zeichenfolgenvariablen in diesem Format: "Breite, Höhe, Anfangsverschiebung, v, u, s".
Einfügen vor dem Programm:

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

JavaScript (ES6), 111 Byte

Ein etwas anderer ES6-Ansatz unter Verwendung des funktionalen Array.from.

fNimmt Argumente (w,h,i,v,u,s)und gibt einen String zurück. Dem Code hinzugefügte Zeilenumbrüche und wörtliche Zeilenumbrüche in der Zeichenfolge wurden \naus Gründen der Übersichtlichkeit durch ersetzt. Weder spiegelt sich in der Anzahl der Bytes wider.

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`

Verwendung

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

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

*/

Ungolfed Version mit Erklärung

Ich habe einige Bytes gespart, indem ich einen Alias ​​für Array erstellt habe, der in der ungolfed-Version nicht berücksichtigt wird.

// 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 ist bequemer als es aussieht." "Es müsste sein." - Gia und Eidon (Niemand wird diese Referenz bekommen. Hinweis: "Webmatte")

Also habe ich jetzt ungefähr fünf Stunden lang daran gearbeitet und ich gebe auf. Ich habe keine Ahnung, wie dieser Code funktioniert. Es geht nach der ersten Reihe immer rückwärts und wird dann völlig falsch (7 4 0 2 2 1).

Hier ist die einfachere Version, die Sie leichter lesen können. Ich rufe nur die Eingabe ab, erstelle das Vorlagenarray und drucke dann innerhalb der Schleifen.

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

Sie können es hier ganz einfach testen: http://www.compileonline.com/compile_c_online.php mit "7 4 0 1 1 1" im STDIN-Eingabefeld unten. Beginnen Sie mit der Bearbeitung der Zahlen, und Sie werden die Probleme sehen.

Entschuldigung, ich konnte keine funktionierende Lösung finden. Ich hasse mich dafür. Ich habe zu viel Zeit damit verbracht, es nicht hochzuladen, um es von jemand anderem reparieren zu lassen.

Ich benutze dieses printf für eine Weile, um die obere Reihe (einfach) weiter von den restlichen (die Problemreihen) zu trennen: 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]))