Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą N i wypisuje lub zwraca ciąg artystyczny N × N ASCII, którego górna połowa jest półkolem z ('s, a dolna połowa jest trójkątem skierowanym w dół z V' spacje używane jako wypełnienie.

Innymi słowy, zrób rożek do lodów ASCII: (wyjście dla N = 17)

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

Przykłady

Oto wyniki dla N = 1 do 5. Zauważ, że dla nieparzystego N trójkąt zawsze musi być większą połówką.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Oto paczka N = 101.

A oto implementacja referencji bez języka Python 3:

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

Detale

• Weź dane wejściowe z stdin, wiersza poleceń lub jako argument funkcji. Wyjście na standardowe wyjście lub podobne, lub możesz zwrócić ciąg, jeśli napiszesz funkcję.
• Część stożkowa powinna dokładnie pasować do implementacji referencyjnej dla wszystkich N.
• Część lodów nie musi dokładnie pasować do implementacji referencyjnej, o ile ma wyraźnie półkole dla wszystkich liter N. (Dzięki temu nie musisz się martwić drobnymi różnicami w półkolu z powodu błędów zaokrąglania .)
• Nie powinno być żadnych zbędnych spacji wiodących, ale mogą być zbędne spacje końcowe.
• Dane wyjściowe mogą opcjonalnie zawierać końcowy znak nowej linii.
• Opcjonalnie można używać 3 inne odrębne druku ASCII znaków w miejscu (, Vi przestrzeń.

Punktacja

Najkrótsze przesłanie w bajtach wygrywa. Tiebreaker przechodzi do najstarszego zgłoszenia.

CJam, 46 bajtów

Wypróbuj online.

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

Uważam, że obecnie dokładnie naśladuje oryginalną specyfikację, która była wymagana, kiedy zacząłem tworzyć tę odpowiedź. Być może uda się zaoszczędzić kilka bajtów, czyniąc matematykę mniej dokładną w stosunku do oryginalnej specyfikacji, ale dopóki nie zobaczę sposobu na zaoszczędzenie więcej niż jednego lub dwóch bajtów, pozostawię ją taką, jaka jest.

Wyjaśnienie

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

Najczęściej używa to formuł z przykładu python, ale używa kropek i jot zamiast podwójnej pętli. Te iczynności wykonuje okrągły testowe do jfunkcji, która wywołuje jota-dot na nim. I kfunkcja wykonuje test trójkąta dla tej lfunkcji. cFunkcja catenates wyniki ji li przekształca się do N x N.

edytuj: -6 połącz 2 mapy w 1.
edytuj: -2 usuń bezużyteczne strzępy.
edycja: ładniejszy maszynopis.
edycja: -10 stosuje powtarzane wyrażenia tablicowo.
edycja: -4 wyodrębnia powtarzające się wyrażenie jako funkcję.
edycja: komentarz linia po linii.

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' 

Bardziej szczegółowo, punktem wejścia jest cfunkcja, która przyjmuje domyślnie jeden argument 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

jFunkcyjnego tę samą wartość sygnału wejściowego jako jego yparametru.

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

Jot-kropka robi podwójną pętlę. Wywołuje ifunkcję z każdą kombinacją elementów z lewej i prawej tablicy (0..n / 2 i 0..n). Zatem ifunkcja odbiera jako xw y indeks tabeli, a to odbiera jak yna x indeksu. Nazwiska mają tu trochę wstecz :).

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

gdzie qrobi

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

wrócić do 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

Podłoga nie powinna być konieczna. Ale najwyraźniej w tłumaczu jest błąd.

lFunkcja działa podobnie do jfunkcji, za pomocą JOT-kropka.

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

kFunkcja daje wartość logiczną skalowana przez 2, a więc wartości można odróżnić od wartości lodów później, w odwzorowaniu.

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

W akcji (przesyłanie potokowe w trcelu usunięcia znaków tabulacji, które są monitami 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

Nie używa ciągów, tylko matematykę

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)zwraca liczbę w postaci „ Ucyfr z najdalszymi z prawej strony Lzerami, a pozostałe”
f(N,m)zwraca liczbę N-cyfrową z wewnętrzną sekcją 2i m-szeroką ramką z 1każdej strony
g(N,m)robi to samo, ale 7dla „koloru” wewnętrznej części, ponieważ bardziej pasuje do tekstury stożka

Wynik

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

Perl 6, 175

Dość prosta implementacja bez większego golfa, po prostu eliminacja białych znaków / interpunkcji:

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