Introdução

Para encurtar a história: alguns dias atrás, acidentalmente, comecei a tricotar uma meia e a estrutura lógica dos pontos simples me levou à ideia: por que não tricotamos apenas uma meia em ASCII?

Entrada

A entrada é um número inteiro N no intervalo [2,30].

Resultado

A saída é uma meia, obviamente.

Estrutura

Como usaremos somente pontos simples, você usará apenas vpara um ponto descendente e >um ponto à direita. Deixe-me explicar a estrutura completa com um exemplo para N=8:

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

• O primeiro bloco é a parte superior. Tem a largura Ne a alturaN*1.5
• Depois o calcanhar começa. Você subtrai um vpor linha do lado direito até ter a N/2largura. Em seguida, adicione N/2linhas com a largura N/2abaixo para finalizar as malhas descendentes. Observe que ele fornece um total de N/2 + 1linhas com a larguraN/2

primeira 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

• Agora as malhas laterais começam. Você começa com a primeira linha reduzida, preenche >até ter a largura Ne adicione mais duas. Continue esse processo, incluindo a primeira linha comN/2 largura
• Preencha as linhas abaixo desse nível e adicione N*1.5tempos >a esse
• Deixe as partes externas como estão e adicione na linha abaixo da primeira e sobre o lase mais duas >'saté terminar

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

Regras

Trailing novas linhas estão ok.

Você pode escolher entre maiúsculas ou minúsculas V mas deve ser consistente.

Isso é código-golfe portanto o código mais curto em bytes vence.

Casos de teste

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

Pitão - 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">

Explicação:

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

Você pode tentar aqui!

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

Função sem nome, recebendo um número inteiro positivo como entrada e retornando uma string (com uma nova linha à direita). Observe que a nova linha entre as duas linhas de código acima faz parte do código. O trabalho principal é realizado pela função c, cuja definição não destruída

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

cria uma tabela de listas, cada uma consistindo em vários "v"s em uma linha seguida por vários ">"s seguidos por uma nova linha. Felizmente, o intervalo #3para o externo Tablepode ter um nome de variável, que pode ser referido nas expressões #1e #2; isso permite que a função cseja chamada com argumentos constantes e variáveis. O resto é apenas computação, e o operador de junção de cadeias ""<>simplifica as listas aninhadas que surgem de graça.

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

Explicação recebida.

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

Este é um fechamento sem nome. A abordagem é completamente semelhante à minha resposta do Python 3.5 .

Experimente Online!

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: a segunda linha termina em um espaço. O lote tem problemas com o eco de >s em variáveis, então eu tenho que: a) usar um substituto; b) chamar uma sub-rotina para ecoar a string corrigida. Na verdade, tenho três sub-rotinas:

• aé usado para o calcanhar. Um vé removido a cada vez e três >s são adicionados. Dois >s extras são adicionados para que a sub-rotina possa entrar na bsub - rotina.
• bé usado para a parte inferior do pé. Dois >s são removidos de cada vez. A sub-rotina então entra na csub - rotina.
• cimprime a linha atual da meia, substituindo o caractere de espaço reservado, para que a >impressão seja correta.

A quarta linha lida com a largura da perna, enquanto a quinta linha lida com seu comprimento. A sétima linha lida com o comprimento do pé, enquanto a oitava linha lida com a metade superior da altura do pé, adicionando dois >>a cada linha após a impressão. Isso funciona para tamanhos de meias que são múltiplos de 4 e é feito um ajuste para outros tamanhos de meias, para que a linha mais longa não seja repetida.

PHP, 229 bytes

uma abordagem bastante preguiçosa

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 uma nova linha principal. Corra com -nr.

demolir

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

Tudo bem, bem ... isso é enorme . Não foi fácil, vou lhe dizer isso, com todas as referências de registro, comparações, macros, falta de capacidade de manipulação de cordas, etc. Mesmo assim, eu me diverti montando isso, e isso é tudo o que realmente importa, certo ? ;)

Experimente Online!