Wyobraź sobie prostokątną siatkę |znaków reprezentującą napięte sznurki na krośnie ( osnowę ), które można owinąć innymi wątkami ( wątkiem ), które będziemy reprezentować -.

Oto nietkana osnowa krosna 7 × 4:

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

Istnieje wiele sposobów, w jakie wątek można wplecić w osnowę, najprostszym z nich jest zwykły splot .

W pierwszym rzędzie płaskiego splotu wątek zaczyna się powyżej pierwszego ciągu osnowy, schodzi poniżej drugiego ciągu, następnie powyżej trzeciego ciągu, a następnie poniżej czwartego i tak dalej.

Drugi rząd wątku jest identyczny z pierwszym, ale przesunięty w prawo o jeden ciąg osnowy, więc zaczyna się pod, potem przechodzi i tak dalej.

Na naszym krośnie 7 × 4 splot gładki wygląda następująco:

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

Możemy opisać zwykły splot, mówiąc, że wątek przechodzi przez osnowę 1 raz, a następnie poniżej 1 raz, a każdy kolejny rząd jest przesuwany 1 łańcuch w prawo.

Uogólniony Splot może być opisany poprzez wątkową przejść osnowowe v razy, a następnie w kształcie U razy, przy czym każdy następny wiersz przesunięty s łańcuchów w prawo. (Wszystkie wartości są liczbami całkowitymi, s może być 0 lub ujemne, u i v muszą być nieujemne.)

Krosno 7 × 4 o v = 1 , u = 2 , s = 2 , rodzaj splotu diagonalnego :

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

Wyzwanie

Twoim zadaniem jest napisanie najkrótszego programu (w bajtach), który tworzy tkany wzór prętów i kresek, biorąc pod uwagę v , u , s , szerokość i wysokość krosna oraz początkowe przesunięcie .

Początkowe przesunięcie jest liczbą łańcuchów pierwszy wiersz w wątku jest przesunięty w prawo (0 w powyższych przykładach). Każdy kolejny rząd jest przesunięty przez s więcej strun.

Twój program powinien pobrać te 6 liczb w jakimś łatwym w użyciu formacie (stdin, wywołanie funkcji itp.) I wyprowadzić tkaną siatkę prętów i prostokątów na standardowe wyjście. Możesz założyć, że wszystkie dane wejściowe są prawidłowe. (Wszystkie wartości są liczbami całkowitymi, szerokość i wysokość muszą być dodatnie, początkowe przesunięcie może być dowolne.)

Przykłady

szerokość = 5, wysokość = 4, wstępne przesunięcie = 0, v = 1, u = 3, s = -2:

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

szerokość = 5, wysokość = 4, wstępne przesunięcie = 3, v = 1, u = 3, s = -2:

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

szerokość = 5, wysokość = 4, wstępne przesunięcie = 1, v = 1, u = 1, s = 0:

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

szerokość = 5, wysokość = 4, wstępne przesunięcie = 0, v = 1, u = 0, s = 0:

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

Notatki

• Wzór zawsze zaczyna się od wątku nad osnową w lewym górnym rogu siatki (chyba że początkowo przesunięto).
• Wszystkie wątki wątku przychodzą od lewej strony. Oni nie spirala jak ten .
• u + v niekoniecznie jest wielokrotnością szerokości siatki.
• u i v mogą nie być równe 0

Rubinowy, 72 bajty

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

Nie ma wiele do powiedzenia na ten temat. Buduję jedno powtórzenie -i |powtarzam je wrazy (dla pewności), a następnie wycinam odpowiednią sekcję dla każdej linii.

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 bajty

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 ... Teraz kusi mnie nauka rubinu.

Wprowadź, przypisując zmienną łańcuchową w tym formacie: „szerokość, wysokość, początkowe przesunięcie, v, u, s”.
Wklej przed programem:

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

JavaScript (ES6), 111 bajtów

Nieco inne podejście ES6, wykorzystujące funkcjonalny Array.from.

fpobiera argumenty (w,h,i,v,u,s)i zwraca ciąg znaków. Nowe wiersze dodane do kodu i dosłowne znaki nowego wiersza zastąpione przez \ndla przejrzystości; nie odzwierciedlone w liczbie bajtów.

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`

Stosowanie

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

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

*/

Wersja bez golfa z wyjaśnieniem

Zapisałem niektóre bajty, tworząc alias dla Array, który nie jest odzwierciedlony w wersji bez golfisty.

// 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 bajtów

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

„Jest wygodniejszy niż się wydaje”. „Musiałoby być”. - Gia i Eidon (Nikt nie otrzyma tego odniesienia. Wskazówka: „Weave Mat”)

Pracuję nad tym i wyłączam już od około pięciu godzin i poddaję się. Nie mam pojęcia, jak uruchomić ten kod. Cofa się po pierwszym rzędzie, a następnie całkowicie się myli (7 4 0 2 2 1).

Oto prostsza wersja, którą możesz łatwiej przeczytać. Wystarczy pobrać dane wejściowe, utworzyć tablicę szablonów, a następnie wydrukować w pętli.

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

Możesz to łatwo przetestować tutaj: http://www.compileonline.com/compile_c_online.php używając „7 4 0 1 1 1” w polu wprowadzania STDIN na dole. Rozpocznij edycję liczb, a zobaczysz problemy.

Przepraszam, że nie mogłem znaleźć działającego rozwiązania; Nienawidzę się za to. Spędziłem zbyt dużo czasu, aby nie przesłać go, aby ktoś mógł go naprawić.

Używam tego printf przez jakiś czas, aby dodatkowo oddzielić górny wiersz (łatwy) od pozostałych (problematyczne rzędy): printf("%c",g[i?abs(t+f+j)%l:abs(t+j)%l]);

Haskell, 126 bajtów

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