Dê uma olhada nesta flor de camomila:

Bonito, não é? Bem, e se eu lhe dissesse que essa não era realmente uma flor?

Muitas flores (incluindo girassóis, chamomiles, margaridas e outras) na verdade consistem em muitas flores muito pequenas (os pontos pretos nos girassóis) em uma cabeça de flor. Essas flores em miniatura são chamadas de florzinhas e são dispostas de uma maneira muito especial.

Basicamente, a posição da enésima floreta em uma cabeça de flor é (em coordenadas polares):

onde c = 1 (observe que 137,508 graus = ângulo de ouro. Você não precisa usar essa precisão exata.)

Isso faz com que os floretes sejam formados em uma espiral chamada Espiral de Fermat. O posicionamento das florzinhas também está relacionado aos números de Fibonnaci, mas isso é outra história.

Então, aqui está o desafio. Dado um número inteiro n como entrada, calcule as posições dos primeiros n floretes e plote-os . Essa é uma saída gráfica , então, na verdade, quero que você exiba os pontos em uma janela de algum tipo ou como dados em algum formato de imagem comum para STDOUT ou um arquivo. Fora isso, esse desafio deve ser bastante direto. É código-golfe , então o código mais curto vence. GLHF!

Aqui está uma imagem de exemplo de como uma saída pode ser:

TI-BASIC, 34 bytes

Para a série 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

Isso considera o ponto na origem como o 0º ponto.

Graças ao sinh⁻¹(token de um byte , 2πe^(-2sinh⁻¹(.5é uma maneira curta de obter o ângulo de ouro em radianos. Isso é derivado do fato de que e^(sinh⁻¹(.5é a proporção áurea.

Aqui estão as capturas de tela para N = 50.

(Sim, é uma tela monocromática de 96x64 em uma TI-84 +. As calculadoras de cores mais recentes têm uma atualização de resolução, mas ainda possuem apenas 3,7% dos pixels de um iPhone.)

Pressione TRACEpara percorrer cada ponto.

Python 2, 85 82 81 bytes

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

Encurtado por um byte por marinus.

Usando o ângulo de ouro em radianos. O comprimento dos bytes é o mesmo se eu usasse 137.508, mas de alguma forma não parece tão bom. Gera um gráfico polar usando o pylab. Abaixo está quando 300 (para a versão mais antiga) é a entrada e 7000 (para a versão mais recente) é a entrada. Pode arredondar o ângulo até 2,4 para diminuir o número de bytes para 77.

Aqui está uma versão mais longa que produz uma aparência mais limpa, removendo a grade e o eixo:

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

A razão para as diferentes cores é porque cada ponto é plotado separadamente e tratado como seu próprio conjunto de dados. Se os ângulos e raios fossem passados ​​como listas, eles seriam tratados como um conjunto e seriam de uma cor.

Blitz 2D / 3D , 102 bytes

(A primeira resposta 2D / 3D do Blitz FIRST EVER neste site!)

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

Uma entrada de 50preenche a janela. (Sim, eu poderia economizar dois bytes fazendo isso Graphics 99,99, mas isso não é tão visualmente interessante ou útil.)

Versão mais bonita (e sai mais bem):

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 é uma função sem nome que recebe um argumento inteiro, por exemplo

^{A captura de tela usa uma versão mais antiga, mas a saída parece a mesma.}

O Mathematica realmente tem um built-in GoldenAnglepara resultados ainda mais precisos, mas é mais do que isso 2.39996.

MATLAB, 42 bytes

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

Obtém o número de entrada, cria um intervalo de 1 a esse número.

Multiplica o intervalo pelo ângulo de ouro em radianos (o valor usado é mais próximo do valor real do que 137,508 graus a 6 sf).

Simplesmente plota theta x r em um gráfico de coordenadas polares usando pontos. Aqui mostrado com 2000 pontos

Um gráfico com aparência um pouco mais bonita (sem linhas de grade) seria este código:

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

Embora isso seja à custa de 31 bytes. Novamente, aqui é mostrado com 2000 pontos

R, 58 55 54 bytes

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

Isso requer que o plotrixpacote seja instalado, mas o pacote não precisa ser importado porque estamos referenciando o espaço para nome explicitamente.

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

Exemplo de saída para n = 1500:

Economizou 3 bytes graças ao plannapus!

R, 55 54 bytes

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

Aqui está o resultado para n = 1000:

Editar: salvou 1 byte usando correspondência parcial de argumentos (em asvez de asp) graças a @AlexA.!

R, 48 47 bytes

Eu acho que isso é suficientemente diferente das outras soluções R até agora. Este usa vetores complexos para construir as coordenadas. o sqrt de t e t são colocados nos parâmetros de módulo e argumento e os x, y estão tirando do real e do imaginário. Graças a @AlexA. para o 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'.}

(saída para n = 5000)

Experimente online. (observe que a espiral resultante é pequena)

Não concorrente desde que Jolf foi criado após esse desafio. São 25 bytes quando codificados com ISO-8859-7 e contêm um não imprimível (aqui está um hexdump):

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

Explicação

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 (não concorrente)

Marcado como não concorrente porque o idioma pós-desafio

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

Experimente no MATL Online!

O ângulo de ouro, 137.708deg = pi*(3-sqrt(5))rad = 2.39996...rad é aproximado como 2.4rad.

A versão a seguir ( 25 bytes ) usa o valor exato, com doubleprecisão de ponto flutuante:

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

Experimente no 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}

Exemplo de uso:

P 1024

e gera a janela