Jetez un œil à cette fleur de camomille:

Joli, non? Et si je te disais que ce n'était pas vraiment une fleur?

Beaucoup de fleurs (y compris les tournesols, la camomille, les marguerites et autres) se composent en fait de très petites fleurs (les points noirs sur les tournesols) sur une tête de fleur. Ces fleurs miniatures sont appelées fleurons , et elles sont disposées de manière très spéciale.

Fondamentalement, la position du nième fleuron sur un capitule est (en coordonnées polaires):

où c = 1 (Notez que 137,508 degrés = angle d'or. Vous n'avez pas besoin d'utiliser cette précision exacte.)

Cela provoque la formation des fleurons dans une spirale appelée spirale de Fermat. Le positionnement des fleurons est également lié aux nombres de Fibonnaci, mais c'est un conte pour une autre fois.

Voici donc le défi. Étant donné un entier n en entrée, calculez les positions des n premiers fleurons et tracez-les . C'est une sortie graphique , donc je veux vraiment que vous affichez les points dans une fenêtre quelconque ou sortis sous forme de données dans un format d'image commun vers STDOUT ou un fichier. En dehors de cela, ce défi devrait être assez simple. C'est le code-golf , donc le code le plus court gagne. GL HF!

Voici un exemple d'image de ce à quoi pourrait ressembler une sortie:

TI-BASIC, 34 octets

Pour la série de calculatrices 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

Cela considère que le point à l'origine est le 0ème point.

Merci au sinh⁻¹(jeton d' un octet , 2πe^(-2sinh⁻¹(.5est un moyen rapide d'obtenir l'angle d'or en radians. Cela découle du fait que e^(sinh⁻¹(.5c'est le nombre d'or.

Voici des captures d'écran pour N = 50.

(Oui, c'est un écran monochrome 96x64 sur une TI-84 +. Les nouvelles calculatrices couleur ont une mise à niveau de la résolution, mais n'ont toujours que 3,7% des pixels d'un iPhone.)

Appuyez TRACEpour parcourir chaque point.

Python 2, 85 82 81 octets

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

Raccourci d'un octet par marinus.

Utilisation de l'angle d'or en radians. La longueur en octets est la même si j'utilise 137.508 à la place, mais en quelque sorte, ça n'a pas l'air aussi bien. Génère un tracé polaire à l'aide de pylab. Ci-dessous, lorsque 300 (pour l'ancienne version) est l'entrée et 7000 (pour la nouvelle version) est l'entrée. Pourrait arrondir l'angle jusqu'à 2,4 pour réduire le nombre d'octets à 77.

Voici une version plus longue qui produit un look plus net en supprimant la grille et l'axe:

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 raison des différentes couleurs est que chaque point est tracé séparément et traité comme son propre ensemble de données. Si les angles et les rayons étaient transmis sous forme de listes, ils seraient traités comme un ensemble et seraient d'une seule couleur.

Blitz 2D / 3D , 102 octets

(La toute première réponse Blitz 2D / 3D sur ce 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

Une entrée de 50remplit la fenêtre. (Oui, je pourrais raser deux octets en faisant Graphics 99,99, mais ce n'est pas aussi intéressant ou utile visuellement.)

Version plus jolie (et quitte plus joliment):

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 octets

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

Il s'agit d'une fonction sans nom prenant un argument entier, par exemple

^{La capture d'écran utilise une version plus ancienne, mais la sortie est identique.}

Mathematica a en fait une fonction intégrée GoldenAnglepour des résultats encore plus précis, mais c'est plus long que 2.39996.

MATLAB, 42 octets

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

Obtient le numéro d'entrée, crée une plage de 1 à ce nombre.

Multiplie la plage par l'angle d'or en radians (la valeur utilisée est plus proche de la valeur réelle que 137,508 degrés à 6 pieds carrés).

Ensuite, tracez simplement thêta vs r sur un graphique de coordonnées polaires en utilisant des points. Ici montré avec 2000 points

Un graphique légèrement plus joli (sans lignes de grille) serait ce code:

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

Bien que cela se fasse au détriment de 31 octets. Encore une fois, il est montré avec 2000 points

R, 58 55 54 octets

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

Cela nécessite que le plotrixpackage soit installé, mais il n'est pas nécessaire d'importer le package car nous référençons explicitement l'espace de noms.

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

Exemple de sortie pour n = 1500:

Sauvegardé 3 octets grâce à plannapus!

R, 55 54 octets

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

Voici le résultat pour n = 1000:

Edit: 1 octet enregistré en utilisant la correspondance partielle des arguments ( asau lieu de asp) grâce à @AlexA.!

R, 48 47 octets

Je pense que cela est suffisamment différent des autres solutions R jusqu'à présent. Celui-ci utilise des vecteurs complexes pour construire les coordonnées. le sqrt de t et t sont mis dans les paramètres de module et d'argument et les x, y sont tirés du réel et de l'imaginaire. Merci à @AlexA. pour l'octet.

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 octets

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

(sortie pour n = 5000)

Essayez-le en ligne. (notez que la spirale résultante est petite)

Non compétitif depuis la création de Jolf après ce challenge. C'est 25 octets lorsqu'il est encodé avec ISO-8859-7, et il contient un non imprimable (voici un hexdump):

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

Explication

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 octets

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

MATL , 20 octets (non concurrent)

Marqué comme non concurrent car la langue est postérieure au défi

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

Essayez-le sur MATL Online!

L'angle d'or, 137.708deg = pi*(3-sqrt(5))rad = 2.39996...rad est approximativement 2.4exprimé en rad.

La version suivante ( 25 octets ) utilise la valeur exacte, jusqu'à une doubleprécision à virgule flottante:

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

Essayez-le à 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}

Exemple d'utilisation:

P 1024

et sort la fenêtre