Escreva um programa ou função que receba um número inteiro positivo N e imprima ou retorne uma sequência de arte N × N ASCII cuja metade superior seja um semicírculo feito de ('s e cuja metade inferior seja um triângulo apontando para baixo feito de V' s, com espaços usados ​​como preenchimento.

Em outras palavras, faça um sorvete ASCII: (saída para N = 17)

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

Exemplos

Aqui estão as saídas para N = 1 a 5. Observe que para N ímpar, o triângulo sempre deve ser a metade maior.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Aqui está uma pastabin N = 101.

E aqui está uma implementação de referência Python 3 não-destruída:

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

Detalhes

• Pegue a entrada de stdin, linha de comando ou como argumento de função. Saída para stdout ou similar, ou você pode retornar a string se escrever uma função.
• A parte do cone deve corresponder exatamente à implementação de referência para todos os N.
• A parte do sorvete não precisa corresponder exatamente à implementação de referência, desde que esteja claramente na forma de um semicírculo para todos os N. (Isso é para que você não precise se preocupar com pequenas diferenças no semicírculo devido a erros de arredondamento .)
• Não deve haver espaços à esquerda desnecessários, mas pode haver espaços à direita supérfluos.
• A saída pode opcionalmente conter uma nova linha à direita.
• Opcionalmente, pode utilizar quaisquer outros 3 distintas ASCII imprimível caracteres em lugar de (, Ve espaço.

Pontuação

O menor envio em bytes vence. O desempatador vai para a finalização mais antiga.

CJam, 46 bytes

Experimente online.

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

Acredito que isso atualmente imite exatamente a especificação original, necessária quando comecei a produzir esta resposta. Pode haver um potencial para salvar alguns bytes, tornando a matemática menos precisa para a especificação original, mas até encontrar uma maneira de salvar mais de um ou dois bytes, deixarei como está.

Explicação

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

Isso usa principalmente as fórmulas do exemplo python, mas usa pontos de anotação e iotas em vez de loop duplo. A ifunção executa o teste circular para a jfunção que chama um ponto de anotação nela. E a kfunção executa o teste do triângulo para a lfunção. A cfunção catenates os resultados de je le remodela-o a N * N.

edit: -6 combina 2 mapas em 1.
edit: -2 remove ravels inúteis.
editar: melhor datilografado.
edit: -10 aplica a expressão repetida em matriz.
edit: -4 fatoram a expressão repetida como uma função.
editar: comentário linha por linha.

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' 

Mais detalhadamente, o ponto de entrada é a cfunção que recebe um argumento implicitamente nomeado 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

A jfunção recebe o mesmo valor de entrada que seu yparâmetro.

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

O jot-point aqui faz o loop duplo. Ele chama a ifunção com todas as combinações de elementos das matrizes esquerda e direita (0..n / 2 e 0..n). Assim, a ifunção recebe como xo y índice da tabela, e que recebe como yo x índice. Os nomes ficaram um pouco para trás aqui :).

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

onde qfaz

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

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

O piso não deve ser necessário. Mas, aparentemente, há um erro no intérprete.

A lfunção funciona de maneira semelhante à jfunção, usando um ponto de anotação.

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

A kfunção gera um valor booleano escalado por 2, para que os valores possam ser diferenciados dos valores de sorvete posteriormente, no mapeamento.

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

Em ação (canalizando trpara remover os caracteres de tabulação que são o prompt do 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

Não usa strings, apenas matemática

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)retorna um número da forma " U-dígitos com os Lzeros mais à direita e os demais"
f(N,m)retorna um número de dígito N com a seção interna de 2e uma borda de largura m de 1cada lado
g(N,m)faz o mesmo, mas o uso 7da 'cor' da seção interna, uma vez que coincide mais com a textura do cone

Resultado

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

Perl 6, 175

Implementação bastante direta, sem muito golfe, apenas eliminação de espaço em branco / pontuação estranha:

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