Introducción

En pocas palabras: hace unos días, accidentalmente comencé a tejer un calcetín y la estructura bastante lógica de los puntos simples me llevó a la idea: ¿por qué no tejemos un calcetín ASCII?

Entrada

La entrada es un entero par N en el rango [2,30].

Salida

La salida es un calcetín, obviamente.

Estructura

Debido a que solo usaremos puntadas simples, solo lo usará vpara una puntada hacia abajo y >para una puntada a la derecha. Permítanme explicar la estructura completa con un ejemplo para N=8:

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

• El primer bloque es la parte superior. Tiene el ancho Ny la alturaN*1.5
• Luego comienza el talón. Resta uno vpor fila del lado derecho hasta que tenga el N/2ancho. Luego agrega N/2filas con el ancho N/2debajo para terminar los tejidos hacia abajo. Tenga en cuenta que da un total de N/2 + 1filas con el anchoN/2

primera parte:

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

• Ahora comienzan los tejidos de las guardas laterales. Empiezas con la primera fila reducida, rellena >hasta que tengas el ancho Ny agrega dos más. Continúe ese proceso, incluida la primera fila con N/2ancho
• Rellene las filas debajo de ese nivel y agregue N*1.5tiempos >a ese nivel
• Deje las partes externas como están y agregue en la fila debajo de la primera y sobre las dos dos más >'shasta que esté terminado

segunda parte:

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

Reglas

Las nuevas líneas finales están bien.

Puede elegir entre mayúsculas o minúsculas, Vpero tiene que ser coherente.

Este es el código de golf, por lo que gana el código más corto en bytes.

Casos de prueba

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

Explicación:

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

¡Puedes probarlo aquí!

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

Función sin nombre que toma un número entero positivo como entrada y devuelve una cadena (con una nueva línea final). Tenga en cuenta que la nueva línea entre las dos líneas de código anteriores es parte del código. El trabajo principal lo realiza la función c, cuya definición sin golf

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

crea una tabla de listas, cada una de las cuales consta de varias "v"s seguidas de varias ">"s seguidas de una nueva línea. Afortunadamente, el rango #3para el exterior Tablepuede tener un nombre de variable, al que se puede hacer referencia en las expresiones #1y #2; Esto permite que la función cse llame con argumentos constantes y variables. El resto es solo cálculo, y el operador de unión de cadenas ""<>aplana las listas anidadas que surgen de forma gratuita.

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

Explicación entrante.

Pruébalo en línea!

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

Este es un cierre sin nombre. El enfoque es completamente similar a mi Python 3.5 respuesta de .

Pruébalo en línea!

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

Nota: la segunda línea termina en un espacio. Batch tiene problemas con la repetición de >s en las variables, así que tengo que a) usar un sustituto b) llamar a una subrutina para repetir la cadena corregida. De hecho, tengo tres subrutinas:

• aSe utiliza para el talón. Uno vse elimina cada vez y >se agregan tres s. Se agregan dos >s adicionales para que la subrutina pueda caer en la bsubrutina.
• bse usa para la planta del pie. Se >eliminan dos s cada vez. La subrutina luego cae en la csubrutina.
• cimprime la fila actual del calcetín, reemplazando el carácter de marcador de posición para que se >imprima correctamente.

La cuarta línea maneja el ancho de la pierna mientras que la quinta línea maneja su longitud. La séptima línea maneja la longitud del pie mientras que la octava línea maneja la mitad superior de la altura del pie agregando dos>> a cada línea después de imprimirla. Esto funciona para tamaños de calcetines que son múltiplos de 4, y se realiza un ajuste para otros tamaños de calcetines para que la línea más larga no se repita.

PHP, 229 bytes

un enfoque bastante vago

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 una nueva línea principal. Corre con-nr .

Descompostura

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

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

Muy bien, bueno ... esto es masivo . No fue fácil, te diré eso, con todas las referencias de registro, comparaciones, macros, falta de habilidades de manipulación de cadenas, etc. Sin embargo, me divertí armando esto, y eso es todo lo que realmente importa, ¿verdad? ? ;)

¡Pruébelo en línea!