Écrivez un programme ou une fonction qui prend un entier positif N, et imprime ou renvoie une chaîne d'art ASCII N × N dont la moitié supérieure est un demi-cercle fait de ('s et dont la moitié inférieure est un triangle pointant vers le bas fait de V' s, avec espaces utilisés comme rembourrage.

En d'autres termes, faites un cornet de crème glacée ASCII: (sortie pour N = 17)

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

Exemples

Voici les sorties pour N = 1 à 5. Notez que pour N impair, le triangle doit toujours être la moitié la plus grande.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Voici un N = 101 pastebin.

Et voici une implémentation de référence Python 3 non golfée:

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

Détails

• Prenez l'entrée de stdin, de la ligne de commande ou comme argument de fonction. Sortie vers stdout ou similaire, ou vous pouvez renvoyer la chaîne si vous écrivez une fonction.
• La partie conique doit correspondre exactement à l'implémentation de référence pour tous les N.
• La portion de crème glacée n'a pas besoin de correspondre exactement à la mise en œuvre de référence tant qu'elle est clairement sous la forme d'un demi-cercle pour tous les N. .)
• Il ne doit pas y avoir d'espaces de début inutiles mais il peut y avoir des espaces de fin superflus.
• La sortie peut éventuellement contenir une nouvelle ligne de fin.
• Vous pouvez éventuellement utiliser les 3 autres distincts ASCII imprimables caractères à la place (, Vet l' espace.

Notation

La soumission la plus courte en octets l' emporte. Tiebreaker va à la soumission la plus ancienne.

CJam, 46 octets

Essayez-le en ligne.

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

Je crois que cela imite actuellement exactement les spécifications d'origine, ce qui était nécessaire lorsque j'ai commencé à produire cette réponse. Il peut être possible d'économiser quelques octets en rendant les calculs moins précis par rapport à la spécification d'origine, mais jusqu'à ce que je vois un moyen d'enregistrer plus d'un ou deux octets, je le laisserai tel quel.

Explication

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

Cela utilise principalement les formules de l'exemple python, mais en utilisant des jot-dots et des iotas au lieu de la double boucle. La ifonction effectue le test circulaire pour la jfonction qui invoque jot-dot sur elle. Et la kfonction effectue le test du triangle pour la lfonction. La cfonction catenates les résultats de jet let remodèle à N × N.

edit: -6 combine 2 cartes en 1.
edit: -2 supprime les ravels inutiles.
edit: meilleur dactylographie.
edit: -10 applique une expression répétée dans le tableau.
edit: -4 factorise l'expression répétée en fonction.
edit: commentaire ligne par ligne.

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' 

Plus en détail, le point d'entrée est la cfonction qui prend un argument nommé implicitement 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 jfonction reçoit la même valeur d'entrée que son yparamètre.

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

Le point-jot fait ici la double boucle. Il appelle la ifonction avec chaque combinaison d'éléments des tableaux gauche et droit (0..n / 2 et 0..n). Ainsi, la ifonction reçoit comme xl' index y de la table, et elle reçoit comme yl' index x . Les noms ont un peu reculé ici :).

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

d'où qvient

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

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

Le sol ne devrait pas être nécessaire. Mais apparemment, il y a un bug dans l'interpréteur.

La lfonction fonctionne de manière similaire à la jfonction, en utilisant un point-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 kfonction donne un booléen mis à l'échelle par 2 afin que les valeurs puissent être distinguées des valeurs de la crème glacée plus tard, dans la cartographie.

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

En action (passe trà travers pour supprimer les caractères de tabulation qui sont l'invite du 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'utilise pas de chaînes, uniquement des mathématiques

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)renvoie un certain nombre de la forme " U-digits avec les Lzéros les plus à droite et les autres"
f(N,m)renvoie un nombre à N chiffres avec la section intérieure de 2et une bordure large de m de 1chaque côté
g(N,m)fait la même chose, mais en utilisant 7pour la 'couleur' de la section intérieure car elle correspond plus étroitement à la texture du cône

Production

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

Perl 6, 175

Mise en œuvre assez simple sans beaucoup de golf, juste une suppression des espaces blancs / ponctuation:

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