Einführung

Lange Rede, kurzer Sinn: Vor ein paar Tagen habe ich aus Versehen angefangen, eine Socke zu stricken, und die hübsche logische Struktur der einfachen Stiche hat mich auf die Idee gebracht: Warum stricken wir nicht einfach eine Socke im ASCII-Format?

Eingang

Die Eingabe ist eine gerade Ganzzahl N im Bereich [2,30].

Ausgabe

Die Ausgabe ist offensichtlich eine Socke.

Struktur

Da wir nur normale Stiche verwenden, werden Sie nur für einen Stich nach vunten und >für einen Stich nach rechts verwenden. Lassen Sie mich die gesamte Struktur anhand eines Beispiels erläutern für N=8:

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

• Der erste Block ist der obere Teil. Es hat die Breite Nund die HöheN*1.5
• Danach beginnt die Ferse. Sie subtrahieren eine vpro Zeile von der rechten Seite, bis Sie die N/2Breite haben. Anschließend fügen Sie N/2Reihen mit der Breite N/2darunter hinzu, um die Abwärtsstrickarbeiten zu beenden. Beachten Sie, dass es insgesamt N/2 + 1Zeilen mit der Breite gibtN/2

erster Teil:

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

• Jetzt fangen die Seitenwirkereien an. Sie beginnen mit der ersten verkleinerten Zeile, füllen >bis Sie die Breite haben Nund fügen zwei weitere hinzu. Setzen Sie diesen Vorgang mit der ersten Zeile mit der N/2Breite fort
• Füllen Sie die Zeilen unterhalb auf dieser Ebene und fügen Sie N*1.5mal >zu , dass
• Lassen Sie die äußeren Teile wie sie sind und fügen Sie die Reihe unter der ersten und über der Las zwei weitere hinzu, >'sbis es fertig ist

zweiter Teil:

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

Regeln

Neue Zeilen nachziehen ist in Ordnung.

Sie können zwischen Groß- und Kleinschreibung wählen V, diese muss jedoch konsistent sein.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

Testfälle

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 Bytes

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">

Erläuterung:

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

Sie können es hier ausprobieren!

Mathematica, 104 Bytes

""<>{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]}&

Unbenannte Funktion, die eine positive gerade Ganzzahl als Eingabe verwendet und eine Zeichenfolge zurückgibt (mit einer nachgestellten Newline). Beachten Sie, dass die neue Zeile zwischen den beiden obigen Codezeilen Teil des Codes ist. Die Hauptarbeit wird von der Funktion geleistet c, deren ungolfed Definition

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

Erstellt eine Tabelle mit Listen, von denen jede aus mehreren "v"s in einer Reihe besteht, gefolgt von mehreren ">"s, gefolgt von einer neuen Zeile. Glücklicherweise kann der Bereich #3für den äußeren Tableeinen Variablennamen haben, auf den in den Ausdrücken #1und verwiesen werden kann #2. Dadurch kann die Funktion csowohl mit konstanten als auch mit variablen Argumenten aufgerufen werden. Der Rest ist nur eine Berechnung, und der Operator für ""<>das Verbinden von Zeichenfolgen reduziert die verschachtelten Listen, die kostenlos entstehen.

Python, 3.5 183 177 Bytes

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

Erklärung eingehend.

Probieren Sie es online!

Groovy, 168 Bytes

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

Dies ist eine namenlose Schließung. Der Ansatz ist meiner Python 3.5- Antwort völlig ähnlich .

Probieren Sie es online!

Batch, 279 Bytes

@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:]=^>%

Hinweis: Die zweite Zeile endet in einem Leerzeichen. Batch hat Probleme mit dem Echo von >s in Variablen, daher muss ich a) einen Ersatz verwenden b) eine Unterroutine aufrufen, um die korrigierte Zeichenfolge wiederzugeben. Tatsächlich habe ich drei Unterprogramme:

• awird für die Ferse verwendet. vJeweils eine wird entfernt und drei >s hinzugefügt. Es werden zwei zusätzliche >s hinzugefügt, damit das Unterprogramm in das bUnterprogramm hineinfallen kann .
• bwird für die Unterseite des Fußes verwendet. >Jeweils zwei s werden entfernt. Das Unterprogramm fällt dann in das cUnterprogramm durch.
• cdruckt die aktuelle Zeile des Strumpfs und ersetzt das Platzhalterzeichen, damit das >s richtig gedruckt wird.

Die vierte Linie regelt die Breite des Beins, während die fünfte Linie die Länge regelt. Die siebte Zeile behandelt die Länge des Fußes, während die achte Zeile die obere Hälfte der Fußhöhe behandelt, indem >>jeder Zeile nach dem Drucken zwei hinzugefügt werden . Dies funktioniert für Sockengrößen, die ein Vielfaches von 4 sind, und es wird eine Anpassung für andere Sockengrößen vorgenommen, damit die längste Linie nicht wiederholt wird.

PHP, 229 Bytes

ein ziemlich fauler Ansatz

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

druckt eine führende Newline. Laufen Sie mit -nr.

Nervenzusammenbruch

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

Gleichstrom , 269 Bytes

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

Also gut ... das ist gewaltig . Es war nicht einfach, ich werde Ihnen so viel sagen, was mit all den Registerreferenzen, Vergleichen, Makros, mangelnden Manipulationsfähigkeiten für Zeichenfolgen usw. zu tun hat. Trotzdem hatte ich Spaß daran, dies zusammenzustellen, und das ist alles, was wirklich wichtig ist, richtig ? ;)

Probieren Sie es online!