introduzione

Per farla breve: qualche giorno fa ho iniziato a lavorare a maglia una calza per caso e la struttura piuttosto logica dei punti semplici mi ha portato all'idea: perché non facciamo solo una calza ASCII?

Ingresso

L'input è un numero intero pari nell'intervallo [2,30].

Produzione

L'output è un calzino, ovviamente.

Struttura

Poiché utilizzeremo solo punti semplici che utilizzerai solo vper un punto verso il basso e >per un punto a destra. Vorrei spiegare l'intera struttura con un esempio per N=8:

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

• Il primo blocco è la parte superiore. Ha la larghezza Ne l'altezzaN*1.5
• Successivamente inizia il tallone. Sottrai uno vper riga dal lato destro fino ad avere N/2la larghezza. Quindi aggiungi le N/2righe con la larghezza N/2sottostante per finire le maglie verso il basso. Si noti che fornisce un totale di N/2 + 1righe con la larghezzaN/2

prima 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

• Ora iniziano i reparti a maglia. Si inizia con la prima riga ridotta, si riempie >fino ad avere la larghezza Ne si aggiungono altri due. Continua quel processo inclusa la prima riga con N/2larghezza
• Riempire le righe di sotto a quel livello e aggiungere N*1.5volte >a quella
• Lasciate le parti esterne come sono e aggiungetele sulla fila sotto la prima e sopra la lase altre due >'sfino a quando non è finita

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

Regole

Le nuove righe finali sono ok.

Puoi scegliere tra lettere maiuscole o minuscole Vma deve essere coerente.

Questo è code-golf quindi vince il codice più breve in byte.

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

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

Spiegazione:

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

Puoi provarlo qui!

Mathematica, 104 byte

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

Funzione senza nome che accetta un numero intero pari positivo come input e restituisce una stringa (con una nuova riga finale). Si noti che la nuova riga tra le due righe di codice sopra fa parte del codice. Il lavoro principale è svolto dalla funzione c, la cui definizione non definita

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

crea una tabella di liste, ognuna composta da più "v"s di seguito seguite da diverse ">"s seguite da una nuova riga. Fortunatamente, l'intervallo #3per l'esterno Tablepuò avere un nome variabile, a cui si può fare riferimento nelle espressioni #1e #2; ciò consente cdi chiamare la funzione con argomenti sia costanti che variabili. Il resto è solo calcolo, e l'operatore che unisce le stringhe ""<>appiattisce gli elenchi nidificati che sorgono gratuitamente.

Python, 3,5 183 177 byte

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

Spiegazione in arrivo.

Provalo online!

Groovy, 168 byte

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

Questa è una chiusura senza nome. L'approccio è completamente simile alla mia risposta Python 3.5 .

Provalo online!

Lotto, 279 byte

@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 seconda riga termina in uno spazio. Batch ha problemi con l'eco delle >variabili s, quindi devo a) usare un sostituto b) chiamare una subroutine per ripetere la stringa corretta. In effetti ho tre subroutine:

• aè usato per il tallone. Uno vviene rimosso ogni volta e >vengono aggiunti tre secondi. Vengono aggiunti altri due messaggi in >modo che la subroutine possa rientrare nella bsubroutine.
• bè usato per la parte inferiore del piede. >Vengono rimossi due secondi ogni volta. La subroutine quindi rientra nella csubroutine.
• cstampa la riga corrente della calza, sostituendo il carattere segnaposto in modo che le >s vengano stampate correttamente.

La quarta linea gestisce la larghezza della gamba mentre la quinta linea gestisce la sua lunghezza. La settima riga gestisce la lunghezza del piede mentre l'ottava riga gestisce la metà superiore dell'altezza del piede aggiungendone due >>a ciascuna riga dopo averla stampata. Funziona con taglie di calze multiple di 4 e viene effettuata una regolazione per altre taglie di calze in modo che la linea più lunga non venga ripetuta.

PHP, 229 byte

un approccio abbastanza pigro

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

stampa una nuova riga principale. Corri con -nr.

abbattersi

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

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

Va bene, beh ... questo è enorme . Non è stato facile, ti dirò così tanto, con tutti i riferimenti al registro, i confronti, le macro, la mancanza di abilità di manipolazione delle stringhe, ecc. Tuttavia, mi sono divertito a metterlo insieme, e questo è tutto ciò che conta davvero, giusto ? ;)

Provalo online!