Echa un vistazo a esta flor de manzanilla:

Bonita, ¿no es así? Bueno, ¿y si te dijera que esta no era realmente una flor?

Muchas flores (incluyendo girasoles, manzanillas, margaritas y otras) en realidad consisten en muchas flores muy pequeñas (los puntos negros en los girasoles) en una cabeza de flor. Estas flores en miniatura se llaman floretes , y están dispuestas de una manera muy especial.

Básicamente, la posición del enésimo flósculo en una cabeza de flor es (en coordenadas polares):

donde c = 1 (Tenga en cuenta que 137.508 grados = ángulo de oro. No tiene que usar esta precisión exacta).

Esto hace que las florecillas se formen en una espiral llamada Espiral de Fermat. El posicionamiento de los floretes también está relacionado con los números de Fibonnaci, pero eso es una historia para otro momento.

Entonces, aquí está el desafío. Dado un número entero n como entrada, calcule las posiciones de los primeros n floretes y grafíelos . Esta es una salida gráfica , por lo que realmente quiero que muestre los puntos en una ventana de algún tipo o que se muestren como datos en algún formato de imagen común a STDOUT o un archivo. Aparte de eso, este desafío debería ser bastante sencillo. Es código de golf , por lo que gana el código más corto. GLHF!

Aquí hay una imagen de muestra de cómo se vería una salida:

TI-BASIC, 34 bytes

Para la serie de calculadoras 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

Esto considera que el punto en el origen es el punto 0.

Gracias al sinh⁻¹(token de un byte , 2πe^(-2sinh⁻¹(.5es una forma corta de obtener el ángulo dorado en radianes. Esto se deriva del hecho de que e^(sinh⁻¹(.5es la proporción áurea.

Aquí hay capturas de pantalla para N = 50.

(Sí, es una pantalla monocromática de 96x64 en una TI-84 +. Las calculadoras de color más nuevas tienen una actualización de resolución, pero aún tienen solo el 3,7% de los píxeles de un iPhone).

Presione TRACEpara recorrer cada punto.

Python 2, 85 82 81 bytes

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

Acortado por un byte por marinus.

Usando el ángulo dorado en radianes. La longitud del byte es la misma si utilizo 137.508 en su lugar, pero de alguna manera no se ve tan bien. Genera un diagrama polar usando pylab. A continuación es cuando 300 (para la versión anterior) es la entrada y 7000 (para la versión más nueva) es la entrada. Podría redondear el ángulo hasta 2,4 para reducir el número de bytes a 77.

Aquí hay una versión más larga que produce una apariencia más limpia al eliminar la cuadrícula y el eje:

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

La razón de los diferentes colores es porque cada punto se traza por separado y se trata como su propio conjunto de datos. Si los ángulos y los radios se pasaran como listas, entonces se tratarían como un conjunto y serían de un solo color.

Blitz 2D / 3D , 102 bytes

(¡La primera respuesta de Blitz 2D / 3D en este sitio!)

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

Una entrada de 50llena la ventana. (Sí, podría reducir dos bytes haciendo Graphics 99,99, pero eso no es tan interesante o útil visualmente).

Versión más bonita (y sale más bien):

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 bytes

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

Esta es una función sin nombre que toma un argumento entero, por ej.

^{La captura de pantalla usa una versión anterior, pero el resultado se ve igual.}

Mathematica en realidad tiene una función integrada GoldenAnglepara obtener resultados aún más precisos, pero eso es más largo que 2.39996.

MATLAB, 42 bytes

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

Obtiene el número de entrada, crea un rango de 1 a ese número.

Multiplica el rango por el ángulo dorado en radianes (el valor utilizado está más cerca del valor verdadero que 137.508 grados a 6 pies cuadrados).

Después, simplemente traza theta vs r en un gráfico usando coordenadas polares puntos. Aquí se muestra con 2000 puntos

Un gráfico de aspecto un poco más bonito (sin líneas de cuadrícula) sería este código:

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

Aunque eso es a expensas de 31 bytes. Nuevamente aquí se muestra con 2000 puntos.

R, 58 55 54 bytes

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

Esto requiere plotrixque se instale el paquete, pero el paquete no tiene que importarse porque estamos haciendo referencia explícita al espacio de nombres.

Sin golf:

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

Ejemplo de salida para n = 1500:

¡Guardado 3 bytes gracias a plannapus!

R, 55 54 bytes

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

Aquí está el resultado para n = 1000:

Editar: se guardó 1 byte utilizando una coincidencia parcial de argumentos (en aslugar de asp) gracias a @AlexA.!

R, 48 47 bytes

Creo que esto es suficientemente diferente de las otras soluciones R hasta ahora. Éste usa vectores complejos para construir las coordenadas. los sqrt de t y t se ponen en los parámetros de módulo y argumento y los x, y están tomando de lo real y lo imaginario. Gracias a @AlexA. para el 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 bytes

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

(salida para n = 5000)

Pruébalo en línea. (tenga en cuenta que la espiral resultante es pequeña)

No compite desde que Jolf fue creado después de este desafío. Esto es de 25 bytes cuando se codifica con ISO-8859-7, y contiene uno no imprimible (aquí hay un hexdump):

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

Explicación

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 bytes

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

MATL , 20 bytes (no competidor)

Marcado como no competitivo porque el lenguaje es posterior al desafío

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

¡Pruébalo en MATL Online!

El ángulo dorado, 137.708deg = pi*(3-sqrt(5))rad = 2.39996...rad se aproxima como 2.4rad.

La siguiente versión ( 25 bytes ) utiliza el valor exacto, hasta la doubleprecisión de punto flotante:

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

¡Pruébalo en 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}

Ejemplo de uso:

P 1024

y saca la ventana