introduction

Pour faire court: il y a quelques jours, j'ai accidentellement commencé à tricoter une chaussette et la structure assez logique des points unis me conduit à l'idée: pourquoi ne pas simplement tricoter une chaussette en ASCII?

Contribution

L'entrée est un entier pair N dans la plage [2,30].

Production

La sortie est une chaussette, évidemment.

Structure

Parce que nous n'utiliserons que des points simples, vous n'utiliserez que vpour un point vers le bas et >pour un point à droite. Permettez-moi d'expliquer la structure complète avec un exemple pour N=8:

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

• Le premier bloc est la partie supérieure. Il a la largeur Net la hauteurN*1.5
• Ensuite, le talon commence. Vous soustrayez un vpar ligne du côté droit jusqu'à ce que vous ayez N/2comme largeur. Ensuite, vous ajoutez des N/2lignes avec la largeur en N/2dessous pour terminer les tricots vers le bas. Notez qu'il donne un total de N/2 + 1lignes avec la largeurN/2

première partie:

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

• Maintenant, les tricots latéraux commencent. Vous commencez avec la première rangée réduite, remplissez >jusqu'à ce que vous ayez la largeur Net ajoutez deux autres. Continuez ce processus, y compris la première ligne avec N/2largeur
• Remplissez les lignes au- dessous de ce niveau et ajouter les N*1.5temps >à ce
• Laissez les parties extérieures telles quelles et ajoutez sur la rangée sous la première et sur le lase deux autres >'sjusqu'à ce qu'elle soit terminée

deuxième partie:

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

Règles

Les nouvelles lignes de fin sont correctes.

Vous pouvez choisir entre majuscules ou minuscules, Vmais cela doit être cohérent.

Il s'agit de code-golf, donc le code le plus court en octets l'emporte.

Cas de test

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 octets

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

Explication:

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

Vous pouvez l'essayer ici!

Mathematica, 104 octets

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

Fonction sans nom prenant un entier pair positif en entrée et renvoyant une chaîne (avec un retour à la ligne de fin). Notez que la nouvelle ligne entre les deux lignes de code ci-dessus fait partie du code. Le travail principal est effectué par la fonction c, dont la définition non golfée

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

crée un tableau de listes, chacune composée de plusieurs "v"s dans une ligne suivie de plusieurs ">"s suivis d'une nouvelle ligne. Heureusement, la plage #3pour l'extérieur Tablepeut avoir un nom de variable, auquel on peut faire référence dans les expressions #1et #2; cela permet à la fonction cd'être appelée avec des arguments constants et variables. Le reste n'est que du calcul, et l'opérateur de jonction de chaîne ""<>aplatit les listes imbriquées qui apparaissent gratuitement.

Python, 3,5 183 177 octets

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

Explication entrante.

Essayez-le en ligne!

Groovy, 168 octets

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

Il s'agit d'une fermeture sans nom. L'approche est complètement similaire à ma réponse Python 3.5 .

Essayez-le en ligne!

Lot, 279 octets

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

Remarque: la deuxième ligne se termine dans un espace. Le lot a des problèmes d'écho> s dans les variables, je dois donc a) utiliser un substitut b) appeler un sous-programme pour faire écho à la chaîne corrigée. En fait, j'ai trois sous-programmes:

• aest utilisé pour le talon. Un vest supprimé à chaque fois et trois >s sont ajoutés. Deux supplémentaires> s sont ajoutés afin que le sous-programme puisse passer à travers le bsous - programme.
• best utilisé pour le bas du pied. Deux >s sont supprimés à chaque fois. Le sous-programme tombe ensuite dans le csous - programme.
• cimprime la ligne actuelle de la chaussette, en remplaçant le caractère d'espace réservé pour que les >s s'impriment correctement.

La quatrième ligne gère la largeur de la jambe tandis que la cinquième ligne gère sa longueur. La septième ligne gère la longueur du pied tandis que la huitième ligne gère la moitié supérieure de la hauteur du pied en ajoutant deux >>à chaque ligne après l'avoir imprimée. Cela fonctionne pour les tailles de chaussettes qui sont des multiples de 4, et un ajustement est effectué pour les autres tailles de chaussettes afin que la ligne la plus longue ne se répète pas.

PHP, 229 octets

une approche assez paresseuse

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

imprime une nouvelle ligne de premier plan. Courez avec -nr.

panne

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

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

Très bien, c'est énorme . Ce n'était pas facile, je vais vous dire beaucoup de choses, avec toutes les références de registre, les comparaisons, les macros, le manque de capacités de manipulation de chaînes, etc. Néanmoins, je me suis amusé à mettre cela ensemble, et c'est tout ce qui compte vraiment, non ? ;)

Essayez-le en ligne!