Fonction ou séquence de Fibonacci

115

La séquence de Fibonacci est une séquence de nombres, où chaque nombre de la séquence est la somme des deux nombres qui le précèdent. Les deux premiers chiffres de la séquence sont tous deux 1.

Voici les premiers termes

1 1 2 3 5 8 13 21 34 55 89 ...

Écrivez le code le plus court qui soit:

  • Génère la séquence de Fibonacci sans fin.

  • Given ncalcule le nthème de la séquence. (1 ou zéro indexé)

Vous pouvez utiliser des formes standard d’entrée et de sortie.

(J'ai donné les deux options au cas où l'une est plus facile à faire que l'autre dans la langue de votre choix.)


Pour la fonction prenant un n, une valeur de retour raisonnablement grande (le plus grand nombre de Fibonacci qui correspond au moins à la taille de mot normale de votre ordinateur) doit être prise en charge.


Classement

Chris Jester-Young
la source

Réponses:

48

Perl 6, 10 caractères:

Liste de séquence infinie anonyme de fibonacci:

^2,*+*...*

Pareil que:

0, 1, -> $x, $y { $x + $y } ... Inf;

Donc, vous pouvez l'assigner à un tableau:

my @short-fibs = ^2, * + * ... *;

ou

my @fibs = 0, 1, -> $x, $y { $x + $y } ... Inf;

Et obtenez les onze premières valeurs (de 0 à 10) avec:

say @short-fibs[^11];

ou avec:

say @fibs[^11];

Attendez, vous pouvez aussi obtenir les 50 premiers numéros de la liste anonyme:

say (^2,*+*...*)[^50]

Cela retourne:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169
63245986 102334155 165580141 267914296 433494437 701408733 1134903170 
1836311903 2971215073 4807526976 7778742049

Et quelques repères simples:

real    0m0.966s
user    0m0.842s
sys     0m0.080s

Avec:

$ time perl6 -e 'say (^2, *+* ... *)[^50]'

EOF

Marco Aurélio da Silva
la source
Je ne penserais même pas ^2à remplacer 0,1. +1
Konrad Borowski
2
Ce n'est plus valide, vous devrez l'écrire en tant que |^2,*+*...*, ce qui est le même nombre d'octets que 0,1,*+*...*.
Brad Gilbert b2gills
5
Perl est tellement bizarre.
Cyoce
1
Dans quelle version de Perl 6 cette réponse a-t-elle été écrite?
CalculatriceFeline
3
@CalculatorFeline Il y a eu un grand changement connu sous le nom de GLR (Great List Refactor) qui s'est produit peu de temps avant la première publication officielle qui a eu lieu le 2015-12-25. Ce code aurait fonctionné jusque-là.
Brad Gilbert b2gills
73

Brainfuck, 22 coups

+>++[-<<[->+>+<<]>>>+]

Génère la séquence de Fibonacci se déplaçant progressivement sur la bande mémoire.

R. Martinho Fernandes
la source
5
Magnifique! Littéralement magnifique! Ou peut-être pas ... en tout cas +1 pour ça :)
Per Hornshøj-Schierbeck
2
Cela correspond à 3,334 ou 4 octets dans un brainfuck compressé. (6 ln (22)) / ln (256)
Will Sherwood
24
16 octets:+[[<+>->+>+<<]>]
dimanche
3
14 octets:+[.[>+>+<<-]>]
Charlim
2
@ Stefnotch bien sûr, le plus court est destructeur. La solution ci-dessus se termine par la séquence de fibonacci sur la bande, ce que fait également la solution de 16 octets.
primo le
51

Haskell, 17 15 14 caractères

f=1:scanl(+)1f

Essayez-le en ligne!

Anon
la source
4
Pourquoi ne pas couper deux espaces à f=0:scanl(+)1 f?
R. Martinho Fernandes
@ Martinho: édité, merci.
Anon.
Wow, c'est encore plus court que d'habitude f@(_:x)=0:1:zipWith(+)f x! Je dois m'en souvenir.
FUZxxl
4
Vous pouvez même bande un autre espace: f=0:scanl(+)1f.
FUZxxl
37

C # 4, 58 octets

Stream (69; 65 si faiblement typé IEnumerable)

(En supposant une usingdirective pour System.Collections.Generic.)

IEnumerable<int>F(){int c=0,n=1;for(;;){yield return c;n+=c;c=n-c;}}

Valeur unique (58)

int F(uint n,int x=0,int y=1){return n<1?x:F(n-1,y,x+y);}
Jon Skeet
la source
6
Étant donné que nc'est un uint, n==0peut être raccourci n<1. Et le flux peut économiser quelques caractères en amerrissant l'espace après le type générique et en déclarant xune portée plus large que nécessaire. En fait, fossé xentièrement:n+=c;c=n-c;
Peter Taylor
1
@ Peter: Merci, je vais éditer quand j'aurai du temps.
Jon Skeet
Votre version à valeur unique est aussi longue que ma réponse lambda récursive réponde ... gentil!
Andrew Gray
1
@ wizzwizz4 si je ne me trompe pas, si cela !nfonctionne, alors vous devriez le faire nsi vous retournez le conditionnel.
Cyoce
3
@ JonSkeet Aw. Et là, je pensais avoir battu Jon Skeet en C # ... :-)
wizzwizz4
32

GolfScript, 12

Maintenant, juste 12 caractères!

1.{[email protected]+.}do
jtjacques
la source
+1 beau travail. Si vous faites moins de 13 caractères, j'accepterai instantanément votre réponse (à moins que quelqu'un ne donne une réponse encore plus courte, bien sûr). :-P
Chris Jester-Young Le
1
J'aime les défis. Terminé! ;-)
jtjacques le
Nice, tu gagnes. Au moins, jusqu'à ce que quelqu'un fasse quelque chose d'encore plus court (si c'est même possible). :-P
Chris Jester-Young
5
cette définition est presque aussi courte que le nom "Fibonacci" lui-même! +1
agent-j
23

> <> - 15 caractères

0:nao1v LF a+@:n:<o
Kevin Brown
la source
Bien que vous puissiez le raccourcir 0:nao1v LF a+@:n:<osi vous le souhaitez. Donne 15 :) En fait, cela rend également la sortie un peu plus lisible ...
tomsmeding
5
13 caractères:01r:nao$:@+$r
randomra
21

J, 10 caractères

En utilisant le calcul intégré des coefficients de la série de Taylor alors peut-être un peu tricheur. Appris ici .

   (%-.-*:)t.

   (%-.-*:)t. 0 1 2 3 4 5 10 100
0 1 1 2 3 5 55 354224848179261915075
randomra
la source
2
@aditsu (q:^-^:p) 6est 64 729où p est pair. J est probablement bon pour ce qu'il fait des énigmes. :)
randomra
2
Encore mieux: (<:^-^:>) 4est 81et <:^-^:> 4est 53.5982.
randomra
2
Les emoji démontrés ici correspondent à tous les objectifs du code J. Sur une note de côté, une autre alternative +/@:!&i.-utilise 9 octets.
miles
1
@miles Très sympa! Vous devriez le poster car il est complètement différent du mien.
randomra
21

Hexagone ,18 14 12

Merci Martin pour 6 octets!

1="/}.!+/M8;

Étendu:

  1 = "
 / } . !
+ / M 8 ;
 . . . .
  . . .

Essayez-le en ligne


Vieux, réponds. Ceci est laissé car les images et l'explication pourraient être utiles aux nouveaux utilisateurs d'Hexagony.

!).={!/"*10;$.[+{]

Étendu:

  ! ) .
 = { ! /
" * 1 0 ;
 $ . [ +
  { ] .

Ceci affiche la séquence de Fibonacci séparée par des nouvelles lignes.

Essayez-le en ligne! Attention cependant, l'interprète en ligne n'aime pas vraiment les sorties infinies.

Explication

Il y a deux "sous-routines" à ce programme, chacune étant exécutée par l'un des deux IP utilisés. La première routine imprime les nouvelles lignes et la seconde effectue le calcul et la sortie de Fibonacci.

Le premier sous-programme commence sur la première ligne et se déplace de gauche à droite tout le temps. Il imprime d'abord la valeur au niveau du pointeur de la mémoire (initialisé à zéro), puis incrémente la valeur au niveau du pointeur de la mémoire 1. Après l’interdiction d’opération, l’IP passe à la troisième ligne qui bascule d’abord dans une autre cellule mémoire, puis imprime une nouvelle ligne. Puisqu'une nouvelle ligne a une valeur positive (sa valeur est 10), le code passera toujours à la cinquième ligne, la suivante. La cinquième ligne renvoie le pointeur de la mémoire sur notre numéro Fibonacci, puis passe à l’autre sous-programme. Lorsque nous reviendrons de ce sous-programme, l’adresse IP reviendra à la troisième ligne, après avoir exécuté un no-op.

Le deuxième sous-programme commence dans le coin supérieur droit et commence à se déplacer vers le sud-est. Après un no-op, nous sommes obligés de voyager vers l'ouest le long de la deuxième ligne. Cette ligne imprime le numéro de Fibonacci actuel avant de déplacer le pointeur de la mémoire vers le prochain emplacement. Ensuite, l’IP saute à la quatrième ligne, où il calcule le numéro Fibonacci suivant en utilisant les deux précédents. Il redonne ensuite le contrôle au premier sous-programme, mais lorsqu'il reprend le contrôle du programme, il continue jusqu'à ce qu'il rencontre un saut, où il rebondit sur le miroir qui était utilisé à l'origine pour le diriger vers l'ouest, puis qu'il retourne à la deuxième ligne.


Jolies images préliminaires!

Le côté gauche de l'image est le programme, le côté droit représente la mémoire. La boîte bleue est la première adresse IP et les deux adresses IP pointent vers l'instruction suivante à exécuter.

entrez la description de l'image ici

Remarque: les images peuvent sembler attrayantes aux personnes ayant des compétences limitées similaires avec les programmes d'édition d'images: PI ajoutera au moins 2 itérations supplémentaires afin que l'utilisation de l' *opérateur devienne plus claire.

Note 2: Je n’ai vu la réponse d’Alephalpha qu’après avoir écrit la majeure partie de ceci: j’ai pensé que c’était toujours utile en raison de la séparation, mais les parties Fibonacci de nos programmes sont très similaires. En outre, il s’agit du plus petit programme Hexagony que j’ai vu utiliser plus d’une adresse IP; j’ai donc pensé qu’il serait peut-être bon de le garder de toute façon: P

FryAmTheEggman
la source
Vous devriez créer un lien vers ce que vous avez utilisé pour faire les jolies images, puis mettez le lien sur esolangs.org/wiki/Hexagony .
mbomb007
1
@ mbomb007 J'ai utilisé gimp pour créer manuellement chaque image, puis j'ai téléchargé les images sur un site Web gif. Bien que plusieurs fois au cours de ce processus, j’ai envisagé de créer un outil pour le faire, en considérant combien c’était fastidieux.
FryAmTheEggman
@FryAmTheEggman Impressionnant! Faites-en un défi. Je suis sûr que quelqu'un postera une réponse. : D Encore mieux si vous pouviez créer un site Web similaire à l'interprète en ligne de fish.
mbomb007
@ mbomb007 Cela pourrait être un peu ambitieux pour un défi sur ce site, sans compter que cela souffrirait probablement beaucoup d'être très large. Je ne pense pas que je publierai cela, mais n'hésitez pas à le faire vous-même si vous pensez que vous avez un bon moyen de le présenter. De plus, je pense que Timwi a créé une idée C # pour hexagony, bien que je ne l’aie jamais utilisée car je ne me suis pas soucié de la mono.
FryAmTheEggman
1
@ mbomb007 L'idée vit ici , d'ailleurs, a oublié de la lier la dernière fois.
FryAmTheEggman
18

VACHE , 108

 MoO moO MoO mOo MOO OOM MMM moO moO
 MMM mOo mOo moO MMM mOo MMM moO moO
 MOO MOo mOo MoO moO moo mOo mOo moo
Timtech
la source
17

Python 2, 34 octets

Python, en utilisant la récursivité ... voici un StackOverflow!

def f(i,j):print i;f(j,i+j)
f(1,1)
jtjacques
la source
15

Gelée , 3 octets

+¡1

Essayez-le en ligne!

Comment ça fonctionne

+¡1    Niladic link. No implicit input.
       Since the link doesn't start with a nilad, the argument 0 is used.

  1    Yield 1.
+      Add the left and right argument.
 ¡     For reasons‡, read a number n from STDIN.
       Repeatedly call the dyadic link +, updating the right argument with
       the value of the left one, and the left one with the return value.

¡ jette un œil aux deux liens à gauche. Puisqu'il n'y en a qu'un, ce doit être le corps de la boucle. Par conséquent, un nombre est lu à partir de l'entrée. Comme il n'y a pas d'argument de ligne de commande, ce nombre est lu à partir de STDIN.

Dennis
la source
12

Golfscript - numéro unique - 12/11/10

12 caractères pour prendre l'entrée de stdin:

~0 1@{.@+}*;

11 caractères pour l'entrée déjà sur la pile:

0 1@{.@+}*;

10 caractères pour définir plus en détail 1 comme numéro de Fibonacci:

1.@{.@+}*;
aaaaaaaaaaaa
la source
1
L'option est "Calcule, étant donné n, le nième nombre de Fibonacci". Donc, abandonnez le ~et vous avez 11 caractères qui prennent nla pile et laissent F_nsur la pile.
Peter Taylor
12

Rubis

29 27 25 24 Chars

p a=b=1;loop{b=a+a=p(b)}

Edit: fait une boucle infinie. ;)

st0le
la source
13
quelqu'un a-t-il remarqué b=a+a=bun palindrome? :)
départ le
2
oui st0le fait :)
gnibbler
Je sais que je suis en retard à la fête, mais quelqu'un peut-il expliquer le fonctionnement de la b=a+a=bpièce? Je n'arrive pas à comprendre.
M. Lama
3
@GigaWatt, pensez de cette façon, les instructions sont exécutées de gauche à droite ... sonewb=olda+(a=oldb)
st0le
vous pouvez enregistrer 2 caractères en utilisant loop:p 1,a=b=1;loop{p b=a+a=b}
Patrick Oscity
11

Mathematica, 9 caractères

Fibonacci

Si les fonctions intégrées ne sont pas autorisées, voici une solution explicite:

Mathematica, 33 32 31 caractères

#&@@Nest[{+##,#}&@@#&,{0,1},#]&
celtschk
la source
#&@@Nest[{#+#2,#}&@@#&,{0,1},#]&32 caractères.
Chyanog
1
@chyanog 31:#&@@Nest[{+##,#}&@@#&,{0,1},#]&
Mr.Wizard
1
@ Mr.Wizard 24 caractères (26 octets):Round[GoldenRatio^#/√5]&
JungHwan Min
1
ou 23 caractères (27 octets):Round[((1+√5)/2)^#/√5]&
JungHwan Min
10

DC (20 octets)

En prime, il est même obscurci;)

zzr[dsb+lbrplax]dsax

EDIT: Je peux préciser qu’il affiche tous les nombres de la séquence fibonacci, si vous attendez assez longtemps.

Hiato
la source
13
Je ne dirais pas que c'est obscurci - le code obfusqué est censé être difficile à comprendre, et pour ce qui est de la continuité, le code est tout à fait simple.
Nabb
10

Prélude , 12 octets

Un des rares défis où Prelude est en fait assez compétitif:

1(v!v)
  ^+^

Cela nécessite un interpréteur Python qui imprime les valeurs sous forme de nombres décimaux au lieu de caractères.

Explication

Dans Prelude, toutes les lignes sont exécutées en parallèle, le pointeur d'instruction traversant les colonnes du programme. Chaque ligne a sa propre pile qui est initialisée à zéro.

1(v!v)
  ^+^
| Push a 1 onto the first stack.
 | Start a loop from here to the closing ).
  | Copy the top value from the first stack to the second and vice-versa.
   | Print the value on the first stack, add the top two numbers on the second stack.
    | Copy the top value from the first stack to the second and vice-versa.

La boucle se répète à l'infini, car la première pile n'aura jamais 0de dessus.

Notez que cela commence la séquence de Fibonacci à partir de 0.

Martin Ender
la source
10

Hexagonie , 6 octets

Non compétitif car la langue est plus récente que la question.

1.}=+!

Ungolfed:

  1 .
 } = +
  ! .

Il imprime la séquence de Fibonacci sans séparateur.

Alephalpha
la source
2
Cela a le petit problème de ne pas imprimer de séparateur entre les nombres. Ce n'est pas tout à fait bien spécifié dans le défi cependant. (Et je suis vraiment heureux que quelqu'un utilise Hexagony. :))
Martin Ender
9

TI-BASIC, 11

Par le légendaire golfeur Kenneth Hammond ("Weregoose") de TI-BASIC, de ce site . S'exécute dans le temps O (1) et considère 0 comme le 0ème terme de la séquence de Fibonacci.

int(round(√(.8)cosh(Anssinh‾¹(.5

Utiliser:

2:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     1

12:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     144

Comment cela marche-t-il? Si vous faites le calcul, il s'avère que sinh‾¹(.5)c'est égal à ln φ, alors c'est une version modifiée de la formule de Binet qui arrondit au lieu d'utiliser le (1/φ)^nterme de correction. La valeur round((arrondir à 9 décimales) est nécessaire pour éviter les erreurs d’arrondi.

Thomas Kwa
la source
8

K - 12

Calcule le nombre net n-1Fibonacci.

{x(|+\)/0 1}

Juste le nthnuméro de Fibonacci.

{*x(|+\)/0 1}
isawdrones
la source
+1 pas mal! Si vous pouviez réduire un seul caractère (et me fournir un moyen de le tester), j'accepterais votre réponse. :-)
Chris Jester-Young le
La seule façon de la réduire serait de remplacer la fonction par un appel à un numéro connu: n (| + \) / 0 1 Testez-la à l'aide de cet interpréteur .
isawdrones
7

Julia, 18 octets

n->([1 1;1 0]^n)[]
Rɪᴋᴇʀ
la source
7

Java, 55

Je ne peux pas rivaliser avec la concision de la plupart des langues ici, mais je peux offrir un moyen sensiblement différent et peut-être beaucoup plus rapide (temps constant) de calculer le n-ème nombre:

Math.floor(Math.pow((Math.sqrt(5)+1)/2,n)/Math.sqrt(5))

nest l'entrée (int ou long), en commençant par n = 1. Il utilise la formule et les arrondis de Binet au lieu de la soustraction.

Hans-Peter Störr
la source
J'aime cette solution
Andreas
Cela ne semble pas fonctionner pour moi, mais c'est tôt et il se peut que je manque quelque chose! En supposant que ce 0soit le premier numéro de la séquence, cela donne 0, 0, 1, 1, 3, 4, 8, 12, 21, 33pour les 10 premiers numéros
Shaggy le
@Shaggy Oups! Désolé, j'ai introduit un bogue - corrigé maintenant.
Hans-Peter Störr Le
6

Ruby, 25 caractères

la réponse de st0le raccourcie.

p 1,a=b=1;loop{p b=a+a=b}
Matma Rex
la source
6
En fait, vous pouvez le raccourcir encore davantage aveca=b=1;loop{p a;b=a+a=b}
Ventero
6
Donc, vous bloquez sa réponse? : P
mbomb007
6

FAC: APL fonctionnel, 4 caractères (!!)

Pas le mien, donc posté comme wiki de communauté. FAC est un dialecte de l'APL que Hai-Chen Tu a apparemment suggéré comme thèse de doctorat en 1985. Il a ensuite écrit un article avec Alan J. Perlis intitulé " FAC: un langage fonctionnel de l'APL ". Ce dialecte de APL utilise des "tableaux paresseux" et permet des tableaux de longueur infinie. Il définit un opérateur "iter" ( ) pour permettre une définition compacte de certaines séquences récursives.

Le cas monadique ("unaire") de est fondamentalement celui de Haskell iterate, et est défini comme (F⌼) A ≡ A, (F A), (F (F A)), …. Le cas dyadique ( « binaire ») est défini un peu analogue pour deux variables: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Pourquoi est-ce utile? Eh bien, il s’avère que c’est précisément le type de récurrence de la séquence de Fibonacci. En fait, l’un des exemples cités est:

1+⌼1

produire la séquence familière 1 1 2 3 5 8 ….

Donc, voilà, probablement la mise en oeuvre de Fibonacci la plus courte possible dans un langage de programmation sans nouveauté. :RÉ

Luciole
la source
Oh, j'ai accidentellement non-wikied sur votre communauté dans le cadre de mon (manuel) dés-en-cas en masse (manuel). Tant pis. ;-)
Chris Jester-Young
6

R, 40 octets

N'ayant pas vu de solution R, alors:

f=function(n)ifelse(n<3,1,f(n-1)+f(n-2))
planificateur
la source
1
Je sais que c'est une vieille réponse, mais vous pouvez raccourcir à 38 octets
Robert S.
6

Dodos , 26 octets

	dot F
F
	F dip
	F dip dip

Essayez-le en ligne!

Comment ça fonctionne

La fonction F fait tout le gros du travail; il est défini récursivement comme suit.

F(n) = ( F(|n - 1|), F(||n - 1| - 1|) )

Chaque fois que n> 1 , on a | n - 1 | = n - 1 <n et || n - 1 | - 1 | = | n - 1 - 1 | = n - 2 <n , la fonction retourne donc (F (n - 1), F (n - 2)) .

Si n = 0 , alors | n - 1 | = 1> 0 ; si n = 1 , alors || n - 1 | - 1 | = | 0 - 1 | = 1 = 1 . Dans les deux cas, la tentative d'appels récursifs F (1) déclenche une exception Surrender , donc F (0) renvoie 0 et F (1) renvoie 1 .

Par exemple, F (3) = (F (1), F (2)) = (1, F (0), F (1)) = (1, 0, 1) .

Enfin, la fonction principale est définie comme

main(n) = sum(F(n))

il ajoute toutes les coordonnées du vecteur retourné par F .

Par exemple, main (3) = somme (F (3)) = somme (1, 0, 1) = 2 .

Dennis
la source
5

Desmos , 61 octets

Golfé

Cliquez sur le add sliderbouton pour n.

p=.5+.5\sqrt{5}
n=0
f=5^{-.5}\left(p^n-\left(-p\right)^{-n}\right)

La dernière ligne est la sortie.

Ungolfed

Est une fonction.

\phi =\frac{1+\sqrt{5}}{2}
f_{ibonacci}\left(n\right)=\frac{\phi ^n-\left(-\phi \right)^{-n}}{\sqrt{5}}
Conor O'Brien
la source
5

Cubix , 10 octets

Réponse non concurrente car la langue est plus récente que la question.

Cubix est un nouveau langage bidimensionnel de @ETHproductions dans lequel le code est encapsulé dans un cube de la taille voulue.

;.o.ON/+!)

Essayez-le en ligne

Cela enveloppe un cube 2 x 2 de la manière suivante

    ; .
    o .
O N / + ! ) . .
. . . . . . . .
    . .
    . .
  • O afficher la valeur du TOS
  • N pousser la nouvelle ligne sur la pile
  • / refléter le nord
  • o affiche le caractère du TOS
  • ; pop TOS
  • / refléter l'est après avoir contourné le cube
  • + ajouter les 2 premières valeurs de la pile
  • ! ignorer la commande suivante si le TOS est 0
  • ) incrémente le TOS de 1. Ceci lance la séquence essentiellement.

Il s'agit d'une boucle sans fin qui imprime la séquence avec un séparateur de nouvelle ligne. Il tire parti du fait que la plupart des commandes ne suppriment pas les valeurs de la pile.
Si le séparateur est ignoré, cela peut être fait avec 5 octets.O+!)

MickyT
la source
5

Brainfuck, 16,15, 14/13 caractères

+[[->+>+<<]>]  

Génère la séquence de Fibonacci et n’imprime rien. En outre, est plus courte que celle ci-dessus.

+[.[->+>+<<]>]   

Celui-ci a 14 caractères mais affiche les caractères ASCII avec les valeurs de la séquence de Fibonacci.

Stefnotch
la source
1
C’est bien, mais aurais-je tort de dire que la version à 14 octets n’affiche que le 2e 1? Comme dans "1 2 3 5 8" au lieu de "1 1 2 3 5 8"?
Charlim
1
@Charlim Oh, tu as raison. Je n'ai aucune idée de ce que le moi de 2014 pensait. Quoi qu'il en soit, je l'ai juste corrigé en déplaçant l'instruction d'impression à l'avant de la boucle.
Stefnotch le