Wprowadzenie

Krótko mówiąc: kilka dni temu przypadkowo zacząłem robić na drutach skarpetę, a dość logiczna struktura prostych ściegów doprowadziła mnie do pomysłu: dlaczego nie zrobimy skarpety ASCII?

Wejście

Dane wejściowe to parzysta liczba całkowita N w zakresie [2,30].

Wynik

Wyjście jest oczywiście skarpetą.

Struktura

Ponieważ będziemy używać tylko ściegów prostych, będziesz używać tylko vściegu w dół i >ściegu po prawej stronie. Pozwól mi wyjaśnić pełną strukturę na przykładzie N=8:

vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvv>>>
vvvvvv>>>>>>
vvvvv>>>>>>>>>
vvvv>>>>>>>>>>>>
vvvv>>>>>>>>>>>>>>>>>>>>>>>>
vvvv>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvv>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvv>>>>>>>>>>>>>>>>>>>>>>>>

• Pierwszy blok to górna część. Ma szerokość Ni wysokośćN*1.5
• Następnie zaczyna się pięta. Odejmujesz jeden vna rząd od prawej strony, aż uzyskasz N/2taką szerokość. Następnie dodajesz N/2rzędy o szerokości N/2poniżej, aby zakończyć dzianiny w dół. Zauważ, że daje w sumie N/2 + 1wiersze o szerokościN/2

pierwsza część:

vvvvvvvv    //begin with width N
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv
vvvvvvvv    // N*1.5 times
vvvvvvv     // reduce
vvvvvv
vvvvv
vvvv        // till here
vvvv        // repeat N/2 times
vvvv
vvvv
vvvv

• Teraz zaczynają się dzianiny totemów bocznych. Zaczynasz od pierwszego zmniejszonego rzędu, wypełniasz, >aż uzyskasz szerokość Ni dodajesz dwa kolejne. Kontynuuj ten proces, włączając pierwszy wiersz o N/2szerokości
• Wypełnij rzędy poniżej tego poziomu i dodaj do tego N*1.5czasy>
• Pozostaw zewnętrzne części w obecnej postaci i dodaj rząd pod pierwszą i nad laserem jeszcze dwie, >'saż się skończy

druga część:

vvvvvvvv
vvvvvvv>>>  //fill to N and add two >
vvvvvv>>>>>>     //repeat
vvvvv>>>>>>>>>
vvvv>>>>>>>>>>>>   //till here
vvvv>>>>>>>>>>>>>>>>>>>>>>>>       //fill to the row above and add N*1.5 times >
vvvv>>>>>>>>>>>>>>>>>>>>>>>>>>     //add two more '>' than the row above
vvvv>>>>>>>>>>>>>>>>>>>>>>>>>>     //add two more '>' than the row beneath
vvvv>>>>>>>>>>>>>>>>>>>>>>>>

Zasady

Końcowe nowe linie są w porządku.

Możesz wybierać między wielkimi i małymi literami, Vale musi być spójna.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach.

Przypadki testowe

N=2
vv
vv
vv
v>>>
v>>>>>>

N=4
vvvv
vvvv
vvvv
vvvv
vvvv
vvvv
vvv>>>
vv>>>>>>
vv>>>>>>>>>>>>
vv>>>>>>>>>>>>

N=6
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvvv
vvvvv>>>
vvvv>>>>>>
vvv>>>>>>>>>
vvv>>>>>>>>>>>>>>>>>>
vvv>>>>>>>>>>>>>>>>>>>>
vvv>>>>>>>>>>>>>>>>>>

N=12
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvvv
vvvvvvvvvvv>>>
vvvvvvvvvv>>>>>>
vvvvvvvvv>>>>>>>>>
vvvvvvvv>>>>>>>>>>>>
vvvvvvv>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
vvvvvv>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Pyth - 93 bajtów

J/Q2K"V"P*s*Q1.5+*QKbVJp*+Q_+1NK*+3*3N">";InQ2VJp*JK*+s*2aaNc-J 1 2c-J 1 2+3*Q3">";IqQ2pK*6">

Wyjaśnienie:

J/Q2                             sets J to half of input
K"V"                             sets K to "V"
P                                prevents newline after main block of sock
*                                multiply the next 2 items
s*Q1.5                           rounds up input*1.5 (columns in main block)
+                                adds the next 2 item (this item gets multiplied by the previous item)
*QK                              multiplies "V" by input (resulting in each row)
b                                New line
VJ                               For all the numbers 0-((Q/2)-1) (as represented by N)
p                                print
*                                multiply the next 2 items
+Q_+1N                           input + -1*(1+N)
K                                "V"
*+3*3N">"                        3N+3 many ">"'s
;                                ends for statement
InQ2                             if input is not 2
VJ                               For all the numbers 0-((input/2)-1) (as represented by N)
p                                print
*JK                              input/2 many ">"'s
*+s*2aaNc-J 1 2c-J 1 2+3*Q3">"   int(abs(abs(N-((input/2)-1)/2)-((input/2)-1)/2)))+(input*3)+3 many ">"'s
;                                end of for statement
IqQ2                             if input is 2
pK*6">                           print "V" and 6 ">"'s

Możesz spróbować tutaj!

Mathematica, 104 bajty

""<>{t=Table;c=t[{"v"~t~#,">"~t~#2,"
"},#3]&;h=#/2;c[#,0,3h],c[#-i,3i,z={i,h}],c[h,6h+2Min[i-1,h-i],z]}&

Funkcja bez nazwy, przyjmująca dodatnią parzystą liczbę całkowitą jako dane wejściowe i zwracająca ciąg znaków (z końcowym znakiem nowej linii). Zauważ, że nowa linia między dwoma wierszami kodu powyżej jest częścią kodu. Główna praca jest wykonywana przez funkcję c, której nieokreślona definicja

c[#1, #2, #3] = Table[{Table["v", #1], Table[">", #2], "\n"}, #3]

tworzy tabelę list, z których każda składa się z kilku "v"s z rzędu, po których następuje kilka ">"s, po których następuje nowa linia. Na szczęście zakres #3wartości zewnętrznej Tablemoże mieć nazwę zmiennej, do której można się odwoływać w wyrażeniach#1 i #2; pozwala to na wywołanie funkcji czarówno z argumentami stałymi, jak i zmiennymi. Reszta to tylko obliczenia, a operator łączenia łańcuchów ""<>spłaszcza zagnieżdżone listy, które powstają za darmo.

Python, 3,5 183 177 bajtów

n=int(input())
h=n//2
z=h%2
l=['v'*h+'>'*(2*n-h+3*h+i*2)for i in range(1*z+n//4)]
*map(print,['v'*n]*(3*h)+['v'*i+'>'*(3*(n-i))for i in range(h,n)][::-1]+[l,l[:-1]][z]+l[::-1]),

Wyjaśnienie przychodzące.

Wypróbuj online!

Groovy, 168 bajtów

{n->h=n/2;z=(int)h%2;l=(0..<1*z+n/4).collect{'v'*h+'>'*(2*n-h+3*h+it*2)};(['v'*n]*(3*h)+(n-1..h).collect{'v'*it+'>'*(3*(n-it))}+(z==0?l:l[0..<-1])+l[-1..0]).join('\n')}

To jest nienazwane zamknięcie. Podejście jest całkowicie podobne do mojej odpowiedzi w Pythonie 3.5 .

Wypróbuj online!

Partia, 279 bajtów

@echo off
set i=for /l %%i in (2,2,%1)do 
set v=
%i%call set v=v%%v%%v
%i%echo %v%&echo %v%&echo %v%
%i%call:a
%i%call set v=%%v%%]]]
%i:,2,=,4,%call:c&if %%i lss %1 call set v=%%v%%]]
%i:2,=4,%call:b
exit/b
:a
set v=%v:~1%]]]]]
:b
set v=%v:~0,-2%
:c
echo %v:]=^>%

Uwaga: druga linia kończy się spacją. Wsad ma problemy z powtarzaniem echa >w zmiennych, więc muszę: a) użyć substytutu b) wywołać podprogram, aby powtórzyć poprawiony ciąg. W rzeczywistości mam trzy podprogramy:

• asłuży do pięty. Jeden vjest usuwany za każdym razem, a trzy >s są dodawane. >Dodano dwa dodatkowe s, aby podprogram mógł wpaść w bpodprogram.
• bsłuży do dolnej części stopy. Dwa >s są usuwane za każdym razem. Podprogram następnie przechodzi do cpodprogramu.
• cdrukuje bieżący rząd skarpety, zastępując znak zastępczy, aby >drukować poprawnie.

Czwarta linia obsługuje szerokość nogi, podczas gdy piąta linia obsługuje jej długość. Siódma linia obsługuje długość stopy, podczas gdy ósma linia obsługuje górną połowę wysokości stopy, dodając dwie >>do każdej linii po wydrukowaniu. Działa to dla rozmiarów skarpet, które są wielokrotnościami 4, a dla innych rozmiarów skarpet wprowadzana jest korekta, aby najdłuższa linia się nie powtarzała.

PHP, 229 bajtów

dość leniwe podejście

for($m=$n=$p=$argv[1];$i++<$q=$n*1.5;)echo($d=str_pad)("
",$n+1,v);for(;$p-->$n/2;)echo$s="
".$d($d("",$p,v),$m+=2,">");$r=[$s.=$d("",$q,">")];for($k=$n>>2;--$k;)$r[]=$s.=">>";echo join($r),$n&2?"$s>>":"",join(array_reverse($r));

wypisuje wiodącą nową linię. Uruchom z -nr.

awaria

// print first part + preparing some variables for later
for($m=$n=$p=$argv[1];$i++<$q=$n*1.5;)echo str_pad("\n",$n+1,v);

// print second part + prepare $s for third part
for(;$p-->$n/2;)echo$s="\n".str_pad(str_pad("",$p,v),$m+=2,">");

// third part: create an array of strings ...
$r=[$s.=str_pad("",$q,">")];
for($k=$n>>2;--$k;)$r[]=$s.=">>";
// ... then print it and its reverse
echo join($r),$n&2?"$s>>":"",join(array_reverse($r));

dc , 269 bajtów

1k?d1.5*sadsdsb[[[v]nlb1-dsb0<f]dsfx[]pldsbla1-dsa0<c]dscxldd1-sisb2su[[[v]nlb1-dsbldli-<g]dsgx[[>]nlb1-dsblu+0<t]dstx[]plu2+suli1-dsilddsb2/!>m]dsmxld3*dsdsolidswst[[[v]nlw1-dsw0!>x]dsxx[2-]sa[2+]sy[[>]nlo1-dso0<g]dsgxldltli1+2/<yltli1+2/>adsdsolisw[]plt1-dst0!>f]dsfx

W porządku, cóż ... to jest ogromne . Nie było to łatwe, powiem ci tyle, co ze wszystkimi odniesieniami do rejestru, porównań, makr, brakiem możliwości manipulowania łańcuchami itp. Niemniej jednak dobrze się bawiłem, łącząc to ze sobą, i to wszystko jest naprawdę ważne, prawda ? ;)

Wypróbuj online!