Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl N aufnimmt und eine N × N ASCII-Zeichenfolge ausgibt oder zurückgibt, deren obere Hälfte ein Halbkreis aus ('s und deren untere Hälfte ein nach unten weisendes Dreieck aus V' s ist, mit Leerzeichen als Polsterung.

Mit anderen Worten, stellen Sie eine ASCII-Eistüte her: (Ausgabe für N = 17)

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

Beispiele

Hier sind die Ausgänge für N = 1 bis 5. Beachten Sie, dass für ungerade N das Dreieck immer die größere Hälfte sein muss.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Hier ist ein N = 101 Pastebin.

Und hier ist eine ungolfed Python 3 Referenzimplementierung:

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

Einzelheiten

• Nehmen Sie Eingaben von stdin, der Befehlszeile oder als Funktionsargument entgegen. Ausgabe an stdout oder ähnliches, oder Sie geben die Zeichenfolge zurück, wenn Sie eine Funktion schreiben.
• Der Kegelabschnitt sollte genau mit der Referenzimplementierung für alle N übereinstimmen.
• Die Eisportion muss nicht genau mit der Referenzimplementierung übereinstimmen, solange sie für alle N eindeutig die Form eines Halbkreises hat. (Sie müssen sich also nicht um geringfügige Unterschiede im Halbkreis aufgrund von Rundungsfehlern sorgen .)
• Es sollten keine unnötigen führenden Leerzeichen vorhanden sein, es können jedoch überflüssige nachgestellte Leerzeichen vorhanden sein.
• Die Ausgabe kann optional einen nachgestellten Zeilenumbruch enthalten.
• Optional können Sie alle drei anderen verschiedenen verwenden druckbaren ASCII - Zeichen anstelle von (, Vund Raum.

Wertung

Die kürzeste Übermittlung in Bytes gewinnt. Tiebreaker geht zur ältesten Vorlage.

CJam, 46 Bytes

Probieren Sie es online aus.

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

Ich glaube, dies entspricht genau der ursprünglichen Spezifikation, die erforderlich war, als ich anfing, diese Antwort zu erstellen. Möglicherweise können ein paar Bytes eingespart werden, indem die ursprüngliche Spezifikation der Mathematik nicht mehr eingehalten wird. Solange ich jedoch keine Möglichkeit sehe, mehr als ein oder zwei Bytes zu speichern, belasse ich dies beim jetzigen Stand.

Erläuterung

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

Dabei werden meist die Formeln aus dem Python-Beispiel verwendet, aber anstelle von Doppelschleifen werden Jot-Dots und Iotas verwendet. Die iFunktion führt den Zirkeltest für die jFunktion durch, die darauf einen Punkt aufruft . Und die kFunktion führt den Dreieckstest für die lFunktion durch. Die cFunktion verknüpft die Ergebnisse von jund lund formt sie in N × N um.

Bearbeiten: -6 Kombiniere 2 Karten zu 1.
Bearbeiten: -2 Entferne nutzlose Reisen.
edit: schöner Typoskript.
edit: -10 wende wiederholte Ausdrücke Array-weise an.
edit: -4 Wiederholte Ausdrücke als Funktion ausklammern.
edit: zeilenweiser Kommentar.

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' 

Im Einzelnen ist der Einstiegspunkt die cFunktion, die ein implizit genanntes Argument annimmt 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

Die jFunktion erhält den gleichen Eingabewert wie ihr yParameter.

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

Der Punkt hier macht die Doppelschleife. Es ruft die iFunktion mit jeder Kombination von Elementen aus dem linken und rechten Array (0..n / 2 und 0..n) auf. So ist die iempfängt Funktion wie xder y - Index in der Tabelle, und er empfängt als yder x - Index. Die Namen sind hier etwas verkehrt herum gekommen :).

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

woher qkommt

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

zurück zu 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

Der Boden sollte nicht notwendig sein. Aber anscheinend hat der Dolmetscher einen Fehler.

Die lFunktion arbeitet ähnlich wie die jFunktion mit einem Punkt.

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

Die kFunktion liefert einen Booleschen Wert, der mit 2 skaliert ist, sodass die Werte später im Mapping von den Eiscreme-Werten unterschieden werden können.

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 Aktion (Weiterleiten durch tr, um Tabulatorzeichen zu entfernen, die die REPL-Eingabeaufforderung darstellen):

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

Verwendet keine Zeichenfolgen, nur Mathematik

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)Gibt eine Zahl der Form „ U-digits mit den am weitesten rechts LNullen und der Rest ones“
f(N,m)zurückkehrt eine N-stellige Zahl mit dem inneren Abschnitt 2und einem m-breiten Rand 1auf jeder Seite macht
g(N,m)das gleiche, wobei jedoch 7für die ‚Farbe‘ des inneren Abschnitts, da es der Textur des Kegels genauer entspricht

Ausgabe

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

Perl 6, 175

Ziemlich unkomplizierte Implementierung ohne viel Golfspiel, nur überflüssige Leerzeichen / Interpunktion:

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