Dai un'occhiata a questo fiore di camomilla:

Piuttosto no? Bene, e se ti dicessi che questo non era in realtà un fiore?

Molti fiori (compresi girasoli, camomille, margherite e altri) sono in realtà costituiti da molti fiori molto piccoli (i punti neri sui girasoli) su una testa di fiore. Questi fiori in miniatura sono chiamati cimette e sono disposti in un modo molto speciale.

Fondamentalmente, la posizione dell'ennesimo fiorellino su un capolino è (in coordinate polari):

dove c = 1 (Nota che 137.508 gradi = angolo d'oro. Non devi usare questa precisione esatta.)

Questo fa sì che le cimette si formino in una spirale chiamata Spirale di Fermat. Anche il posizionamento degli ornamenti è collegato ai numeri di Fibonnaci, ma questa è una storia per un'altra volta.

Quindi, ecco la sfida. Dato un numero intero n come input, calcola le posizioni dei primi n fiori e tracciali . Questo è un output grafico , quindi in realtà voglio che tu mostri i punti in una finestra di qualche tipo o in uscita come dati in un formato immagine comune su STDOUT o su un file. A parte questo, questa sfida dovrebbe essere abbastanza semplice. È code-golf , quindi vince il codice più breve. GLHF!

Ecco un esempio di come potrebbe apparire un output:

TI-BASIC, 34 byte

Per la serie di calcolatori TI-83 + / 84 +.

Input N
2πe^(-2sinh⁻¹(.5→θstep
AnsN→θmax
"√(θ→r₁
Polar                      ;Displays polar mode graphs to graph screen
Dot                        ;Prevents lines from connecting points
DispGraph                  ;Displays graph screen

Questo considera il punto all'origine come il punto 0.

Grazie al sinh⁻¹(token a un byte , 2πe^(-2sinh⁻¹(.5è un modo breve per ottenere l'angolo d'oro in radianti. Ciò deriva dal fatto che e^(sinh⁻¹(.5è il rapporto aureo.

Ecco alcuni screenshot per N = 50.

(Sì, questo è un display monocromatico 96x64 su una TI-84 +. I nuovi calcolatori del colore hanno un aggiornamento della risoluzione, ma hanno ancora solo il 3,7% dei pixel di un iPhone.)

Premere TRACEper scorrere ciascun punto.

Python 2, 85 82 81 byte

from pylab import*
for i in arange(0,input(),2.39996):polar(i,sqrt(i),'o')
show()

Accorciato di un byte di Marinus.

Usando l'angolo d'oro in radianti. La lunghezza del byte è la stessa se avessi usato 137.508, ma in qualche modo non sembra buono. Genera un diagramma polare usando pylab. Di seguito è indicato quando 300 (per la versione precedente) è l'input e 7000 (per la versione più recente) è l'input. Potrebbe arrotondare l'angolo fino a 2,4 per ridurre il numero di byte a 77.

Ecco una versione più lunga che produce un aspetto più pulito rimuovendo la griglia e l'asse:

from pylab import *
def florets(n):
    for i in arange(0, n, 2.39996):polar(i, sqrt(i), 'o')
    grid(0)#turn off grid
    xticks([])#turn off angle axis
    yticks([])#turn off radius axis
    show()

Il motivo dei diversi colori è perché ogni punto viene tracciato separatamente e trattato come un proprio set di dati. Se gli angoli e i raggi fossero passati come elenchi, verrebbero trattati come un set e di un colore.

Blitz 2D / 3D , 102 byte

(La PRIMA MAI risposta Blitz 2D / 3D su questo sito!)

Graphics 180,180
Origin 90,90
n=Input()
For i=1To n
t#=i*137.508
r#=Sqr(t)
Plot r*Cos(t),r*Sin(t)
Next

Un input di 50riempie la finestra. (Sì, potrei radere due byte facendo Graphics 99,99, ma non è così visivamente interessante o utile.)

Versione più carina (ed esce più bene):

Graphics 400,400
Origin 200,200

n=Input("How many florets? ")

For i = 1 To n
    t# = i * 137.508
    r# = Sqr(t)

    Oval r*Cos(t)-3,r*Sin(t)-3,7,7,1
Next

WaitKey
End

Mathematica, 43 42 byte

ListPolarPlot@Array[(2.39996#)^{1,.5}&,#]&

Questa è una funzione senza nome che accetta un argomento intero, ad es

^{Lo screenshot utilizza una versione precedente, ma l'output ha lo stesso aspetto.}

Mathematica in realtà ha un built-in GoldenAngleper risultati ancora più precisi, ma è più lungo di 2.39996.

MATLAB, 42 byte

t=2.39996*(1:input(''));polar(t,t.^.5,'.')

Ottiene il numero di input, crea un intervallo da 1 a quel numero.

Moltiplica l'intervallo per l'angolo d'oro in radianti (il valore utilizzato è più vicino al valore reale da 137,508 gradi a 6 sf).

Quindi traccia semplicemente theta vs. r su un grafico di coordinate polari usando i punti. Qui mostrato con 2000 punti

Un grafico dall'aspetto leggermente più bello (senza linee della griglia) sarebbe questo codice:

t=2.39996*(1:input(''));[x,y]=pol2cart(t,t.^.5);plot(x,y,'.');axis equal

Tuttavia, ciò è a scapito di 31 byte. Anche in questo caso viene mostrato con 2000 punti

R, 58 55 54 byte

x=2.39996*1:scan();plotrix::radial.plot(x^.5,x,rp="s")

Ciò richiede l' plotrixinstallazione del pacchetto, ma il pacchetto non deve essere importato perché ci riferiamo esplicitamente allo spazio dei nomi.

Ungolfed:

# Read a number of STDIN
n <- scan()

x <- 2.39996*(1:n)

# The rp.type = "s" option specifies that we want to plot points rather
# than lines (the default)
plotrix::radial.plot(lengths = sqrt(x), radial.pos = x, rp.type = "s")

Esempio di output per n = 1500:

Salvato 3 byte grazie a plannapus!

R, 55 54 byte

t=1:scan()*2.39996;r=t^.5;plot(r*cos(t),r*sin(t),as=1)

Ecco il risultato per n = 1000:

Modifica: 1 byte salvato utilizzando una corrispondenza parziale degli argomenti ( asanziché asp) grazie a @AlexA.!

R, 48 47 byte

Penso che questo sia sufficientemente diverso dalle altre soluzioni R finora. Questo utilizza vettori complessi per costruire le coordinate. lo sqrt di te viene inserito nei parametri del modulo e dell'argomento e l'x, y sta prendendo dal reale e dall'immaginario. Grazie a @AlexA. per il byte.

plot(complex(,,,t^.5,t<-1:scan()*2.39996),as=1)

HTML + JavaScript 179

<canvas id=C></canvas><script>n=1500,C.width=C.height=400,T=C.getContext('2d');for(n=prompt(M=Math);n--;)r=M.sqrt(t=n*2.4)*9,T.fillRect(M.cos(t)*r+200,M.sin(t)*r+200,2,2)</script>

Jolf, 25 byte

yG@@KyoΜzXDyOUH*Hm°yT'.}

(output per n = 5000)

Provalo online. (nota che la spirale risultante è piccola)

Non competitiva da quando Jolf è stato creato dopo questa sfida. Sono 25 byte quando sono codificati con ISO-8859-7 e ne contiene uno non stampabile (ecco un hexdump):

0000000: 7947 4096 404b 796f cc7a 5844 794f 5548  yG@.@Kyo.zXDyOUH
0000010: 2a48 6db0 7954 272e 7d                   *Hm.yT'.}

Spiegazione

yG@@KyoΜzXDyOUH*Hm°yT'.}
yG@@K                      goto (150,75) (center of the canvas)
     yo                    set current location as the origin
       MzX                 map over range 1...input
          D                start of function
           yO              goto polar coordinates ....
             UH            radius: square root of argument
               *Hm°        angle: argument times golden angle
                   yT'.    draw a dot there
                       }

Python 2, 74 byte

from pylab import*
i=arange(1,input(),2.39996)
polar(i,sqrt(i),'o')
show()

MATL , 20 byte (non concorrenti)

Contrassegnato come non competitivo perché il linguaggio postdatizza la sfida

:2.4*tX^wJ*Ze*'.'&XG

Provalo su MATL Online!

L'angolo d'oro, 137.708deg = pi*(3-sqrt(5))rad = 2.39996...rad è approssimato come 2.4rad.

La seguente versione ( 25 byte ) utilizza il valore esatto, fino alla doubleprecisione in virgola mobile:

:YPI5X^-**tX^wJ*Ze*'.'&XG

Provalo su MATL Online!

Tcl / Tk, 114

grid [canvas .c]
proc P n {time {incr i
.c cr o [lmap h {cos sin cos sin} {expr sqrt($i*2.4)*$h\($i*2.4)+99}]} $n}

Esempio di utilizzo:

P 1024

e genera la finestra