Scrivi un programma o una funzione che accetta un numero intero positivo N e stampa o restituisce una stringa di arte ASCII N × N la cui metà superiore è un semicerchio fatto di ('s e la cui metà inferiore è un triangolo rivolto verso il basso fatto di V' s, con spazi usati come imbottitura.

In altre parole, crea un cono gelato ASCII: (output per N = 17)

      (((((      
    (((((((((    
  (((((((((((((  
  (((((((((((((  
 ((((((((((((((( 
 ((((((((((((((( 
(((((((((((((((((
(((((((((((((((((
VVVVVVVVVVVVVVVVV
 VVVVVVVVVVVVVVV 
  VVVVVVVVVVVVV  
   VVVVVVVVVVV   
    VVVVVVVVV    
     VVVVVVV     
      VVVVV      
       VVV       
        V        

Esempi

Ecco le uscite per N = da 1 a 5. Nota che per N dispari, il triangolo deve sempre essere la metà più grande.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Ecco un N = 101 pastebin.

Ed ecco un'implementazione di riferimento di Python 3 non modificata:

N = int(input())
ic = [[' '] * N for _ in range(N)]
for y in range(N//2):
    for x in range(N):
        if (x - (N - 1) / 2)**2 + (y - (N - 1) / 2)**2 < (N / 2)**2:
            ic[y][x] = '('
for y in range(N//2, N):
    for x in range(y - N//2, N - (y - N//2)):
        ic[y][x] = 'V'
for line in ic:
    print(''.join(line))

Dettagli

• Accetta input da stdin, riga di comando o come argomento di funzione. Output su stdout o simile, oppure è possibile restituire la stringa se si scrive una funzione.
• La parte del cono deve corrispondere esattamente all'implementazione di riferimento per tutti N.
• La porzione di gelato non deve necessariamente corrispondere esattamente all'implementazione di riferimento, purché sia ​​chiaramente a forma di semicerchio per tutti i N. (Questo è quindi non devi preoccuparti di lievi differenze nel semicerchio a causa di errori di arrotondamento .)
• Non ci dovrebbero essere spazi iniziali non necessari ma potrebbero esserci spazi finali superflui.
• L'output può contenere facoltativamente una nuova riga finale.
• Si può opzionalmente usare altri 3 distinti ASCII stampabili caratteri al posto di (, Ve lo spazio.

punteggio

Vince l' invio più breve in byte . Tiebreaker va alla presentazione più vecchia.

CJam, 46 byte

Provalo online.

{:Z{Z{Z(2./:R-zYR<):P#YR-zP#+Z2./P#>SP?}/N}fY}

Credo che questo al momento imiti esattamente le specifiche originali, necessarie quando ho iniziato a produrre questa risposta. Potrebbe esserci il potenziale per salvare alcuni byte rendendo la matematica meno accurata rispetto alle specifiche originali, ma fino a quando non vedrò un modo per salvare più di uno o due byte, lascerò così com'è.

Spiegazione

{               "Begin block";
  :Z{             "For each y from 0 to input-1";
    Z{              "For each x from 0 to input-1";
      Z(2./:R         "Calculate the radius as (input-1)/2.0";
      -z              "Calculate the horizontal distance from the center";
      YR<):P          "Calculate the power to raise distances to: (y<radius)+1
                       (This results in Euclidean distance being calculated for
                        the ice cream and Manhattan distance being calculated
                        for the cone)";
      #               "Raise the horizontal distance to the determined power";
      YR-zP#          "Calculate the vertical distance from the center and
                       raise it to the determined power";
      +               "Add the horizontal and vertical distances";
      Z2./P#          "Calculate the solid distance threshold and raise it to
                       the determined power";
      >SP?            "If the solid threshold is exceeded, produce a space;
                       otherwise, produce the determined power digit
                       (This results in ice cream being represented by the
                        digit '2' and the cone by the digit '1')";
    }/              "End x loop";
    N               "Produce a new line";
  }fY             "End y loop";
}               "End block";

inca2 129 123 121 111 107

Questo utilizza principalmente le formule dell'esempio python, ma usando jot-punti e iotas invece del doppio loop. La ifunzione esegue il test circolare per la jfunzione che invoca jot-dot su di essa. E la kfunzione esegue il test del triangolo per la lfunzione. La cfunzione di catenates i risultati di je le rimodella a N × N.

modifica: -6 combina 2 mappe in 1.
modifica: -2 rimuovi i corvi inutili.
modifica: dattiloscritto più bello.
modifica: -10 applica l'espressione ripetuta in termini di array.
modifica: -4 fattorizza l'espressione ripetuta come funzione.
modifica: commento riga per riga.

q:y-(n-1)%2
i:[((n%2)^2)>+/(qx y)^2
j:(~[y%2)i.(~y)
k:2*[x>[|qy
l:(@1+~]y%2)k.(~y)
c:y y#((jn<y),ly){' (V' 

Più in dettaglio, il punto di ingresso è la cfunzione che accetta implicitamente un argomento denominato y.

c:y y#((jn<y),ly){' (V' 
         n<y            } assign y to 'n'
        jn<y            } call j(y)
              ly        } call l(y)
      ((    ),  )       } catenate the results
      (         ){' (V' } map 0 1 2 to ' ' '(' 'V'
  y y#                  } reshape to NxN

La jfunzione riceve lo stesso valore di input del suo yparametro.

j:(~[y%2)i.(~y)
     y%2         } y divided by 2
    [            } floor
   ~             } iota. this generates the row indices 0..y/2
            ~y   } iota y. this generates the column indices 0..y
  (     )i.(  )  } jot-dot with the function i

Il jot-dot qui fa il doppio loop. Chiama la ifunzione con ogni combinazione di elementi delle matrici sinistra e destra (0..n / 2 e 0..n). Quindi la ifunzione riceve come xla y indice della tabella, e riceve come yil x indice. I nomi sono un po 'arretrati qui :).

i:[((n%2)^2)>+/(qx y)^2
     n%2                 } n divided by 2
    (n%2)^2              } squared
                 x y     } make a 2-element array (x,y)
                qx y     } call q on this array

dove lo qfa

q:y-(n-1)%2
     n-1    } n minus 1
         %2 } divided by 2
  y-        } y minus that

torna a i

i:[((n%2)^2)>+/(qx y)^2
               (    )^2  } square the result from q(x,y)
             +/          } sum the two numbers
            >            } compare the left side (above) with the right (=> 0/1)
  [                      } floor

Il pavimento non dovrebbe essere necessario. Ma a quanto pare c'è un bug nell'interprete.

La lfunzione funziona in modo simile alla jfunzione, usando un punto-jot.

l:(@1+~]y%2)k.(~y)
        y%2         } y divided by 2
       ]            } ceiling
      ~             } iota 0..ceil(y/2)-1
    1+              } add 1 => 1..ceil(y/2)
   @                } reverse => ceil(y/2)..1
               ~y   } iota y  0..y-1
  (        )k.(  )  } jot-dot using k

La kfunzione produce un valore booleano ridimensionato di 2 in modo che i valori possano essere distinti dai valori del gelato in seguito, nella mappatura.

k:2*[x>[|qy
     x       } k's left arg
         qy  } y-(n-1)%2
        |    } abs
       [     } floor
     x       } left-hand-side again
      >      } compare 
    [        } floor (should be unnecessary)
  2*         } scale by 2

In azione (reindirizzamento trper rimuovere i caratteri di tabulazione che sono il prompt del REPL):

josh@Z1 ~/inca
$ ./inca2 <icecream | tr -d '\t'

c1
V

c2
((
VV

c3
(((
VVV
 V 

c4
 (( 
((((
VVVV
 VV 

c5
 ((( 
(((((
VVVVV
 VVV 
  V  

josh@Z1 ~/inca
$ 

Python 2, 193 192

Non usa stringhe, solo matematica

N=input()
R=(N+1)/2;r=range(R)
s=lambda L,U:(10**U-10**L)/9
f=lambda N,m:s(0,N)+s(m,N-m)
g=lambda N,m:s(0,N)+s(m,N-m)*6
for i in r[1:]:print f(N,int(R-(2*R*i-i*i)**.5))
for i in r:print g(N,i)

s(L,U)restituisce un numero del modulo " U-cifre con gli Lzeri più a destra e gli altri"
f(N,m)restituisce un numero di N cifre con la sezione interna di 2e un bordo largo m 1su ciascun lato
g(N,m)fa lo stesso, ma usando 7per il 'colore' della sezione interna poiché corrisponde più da vicino alla trama del cono

Produzione

N=8         N=9
11122111    112222211
12222221    122222221
22222222    222222222
22222222    222222222
77777777    777777777
17777771    177777771
11777711    117777711
11177111    111777111
            111171111

Perl 6, 175

Implementazione piuttosto semplice senza molto golf, solo eliminazione di spazi bianchi / punteggiatura estranei:

sub MAIN($d){my$r=($d/2).Int;for 1..$r ->$n
{my$y=$n-$r;my$h=sqrt($r*$r-$y*$y).Int;my$w=2*$h+$d%2;say
' 'x($r-$h)~'('x$w};for 1..($d-$r) ->$y {say ' 'x($y-1)~'V'x($d-2*$y+2)}}