Implémenter la séquence aléatoire de Fibonacci

Question

La séquence aléatoire de Fibonacci est définie comme suit:

$$ f_n = \begin{cases} f_{n-1}+f_{n-2} \text{ with probability } 1/2 \\ f_{n-1}-f_{n-2} \text{ with probability } 1/2 \\ \end{cases} $$ $$ f_1 = f_2 = 1 $$

c'est-à-dire que le terme suivant est la somme ou la différence des deux précédents est choisi au hasard, indépendamment des termes précédents. Votre tâche est de mettre en œuvre cette séquence.

Chaque réalisation aléatoire de la séquence doit utiliser des valeurs cohérentes. Par exemple, si \$f_3 = 2\$, \$f_4\$doit alors être soit \$2+1 = 3\$ou \$2-1 = 1\$. Cela peut être considéré comme la séquence "rappelant" les valeurs précédentes. Cela signifie que cet exemple de programme n'est pas valide, car les valeurs précédentes de la séquence ne sont pas conservées par les valeurs ultérieures. De plus, vous devez expliquer comment votre programme répond à la \$1/2\$ exigence de probabilité.

Comme c'est le cas pour les défis de séquence , vous pouvez effectuer l'une des trois tâches suivantes:

• Prenez un entier positif \$n\$comme entrée et sortie \$f_n\$
• Prenez un entier positif \$n\$comme entrée et sortie \$f_1, f_2, ..., f_n\$
• Sortie de la séquence indéfiniment sans fin

Encore une fois, comme c'est standard, vous pouvez utiliser soit \$0\$ou \$1\$indexation, mais les deux valeurs initiales \$f_1 = f_2 = 1\$ doit être utilisé.

C'est du code-golf , donc le code le plus court, en octets, l'emporte.

Exemples

n -> possible values of f_n | probabilities of values
1 -> 1                      | 1
2 -> 1                      | 1
3 -> 2, 0                   | 1/2, 1/2
4 -> 3, 1, -1               | 1/4, 1/2, 1/4
5 -> 5, 3, 1, -1            | 1/8, 1/8, 3/8, 3/8
6 -> 8, 4, 2, 0, -2         | 1/16, 1/8, 1/4, 5/16, 1/4

Answer 1

05AB1E , 8 7 octets

λ₂D(‚Ω+

-1 octet grâce à @ovs .

Imprime la séquence infinie.

Essayez-le en ligne.

Explication:

λ        # Create a recursive environment to output the infinite sequence,
         # implicitly starting at a(0)=1
         #  (push a(n-1) implicitly)
 ₂       #  Push a(n-2) (NOTE: all negative a(n) are 0, so a(-1)=0)
  D      #  Duplicate a(n-2)
   (     #  Negate the copy: -a(n-2)
    ‚    #  Pair them together: [a(n-2), -a(n-2)]
     Ω   #  Pop and push a random item
      +  #  And add it to the a(n-1)
         # (after which the infinite list is output implicitly)

Answer 2

APL (Dyalog Unicode) , 20 octets

{⍵,(¯1*?2)⊥¯2↑⍵}/⎕⍴1

Essayez-le en ligne!

Prend n de stdin et imprime les n premiers termes.

{⍵,(¯1*?2)⊥¯2↑⍵}/⎕⍴1  ⍝ Full program. Input: n
{              }/⎕⍴1  ⍝ Reduce a vector of n ones...
           ¯2↑⍵  ⍝ Last two items ([0 1] for the first iteration)
   (¯1*?2)       ⍝ 1 or -1
          ⊥      ⍝ Base convert (or polynomial evaluate),
                 ⍝ giving f(x-2)+f(x-1) or -f(x-2)+f(x-1) with 50% chance each
 ⍵,              ⍝ Append to the previous iteration

Answer 3

Japt , 14 13 11 octets

Produit le nterme, indexé 1. Utilise JavaScript Math.random()comme vu ici .

@Zä+iÍö)Ì}g

Essayez-le , vérifiez les premiers ntermes ou affichez les distributions sur 10000 exécutions

@Zä+iÍö)Ì}g     :Implicit input of integer U
@               :Function taking an array as argument via parameter Z
 Zä             :  Consecutive pairs of Z reduced by
   +            :    Literal "+"
    i           :    Insert
     Í          :      "n" at index 2 with wrapping, resulting in "n+"
                :      (Hooray for shortcut abuse!)
      ö         :    Random character from that string, where XnY=Y-X
       )        :  End reduction
        Ì       :  Get last element
         }      :End function
          g     :Starting with [0,1], repeatedly run it through that function,
                : pushing the result back to it each time
                :Implicit output of Uth element, 0-indexed

Pour expliquer comment fonctionne l'abus de raccourci ici: Íest le raccourci de Japt pour n2<space>lequel est principalement destiné à être utilisé pour convertir des chaînes binaires en entiers (par exemple, "1000"Í="1000"n2 =8). Cependant, lorsque vous passez un raccourci à 2 caractères + espace comme celui-ci à une autre méthode - dans ce cas i- l'espace est utilisé pour fermer cette méthode et les 2 caractères sont divisés et passés à cette méthode en tant qu'arguments séparés. Ce qui est pratique ici car la iméthode pour les chaînes attend un argument contenant la chaîne à insérer et un autre argument d'entier facultatif pour l'index auquel il doit être inséré.

Answer 4

Gelée , 10 octets

^{Je suis à peu près sûr que 10 est aussi bon qu'il y en aura dans Jelly; J'avais des solutions beaucoup plus longues en cours de route.}

1ṫ-ḅØ-XṭƲ¡

Un lien monadique acceptant un entier, qui donne toutes les valeurs jusqu'à et y compris cet index indexé 0
(c'est-à-dire \$n \to [f_0, f_1,\cdots, f_n]\ |\ f_0=f_1=1 : f_n = f_{n-1} \pm f{n-2} \$).

Essayez-le en ligne!

Comment?

1ṫ-ḅØ-XṭƲ¡ - Link: integer, n
1          - set the left argument to 1
         ¡ - repeat this n times:
        Ʋ  -   last four links as a monad f(left):  e.g. left = [1,1,2,3,5,8]
 ṫ-        -     tail from 1-based, modular index -1            [5,8]
                 (tailing 1 from index -1 yields [1])
    Ø-     -     signs (a nilad)                                [-1,1]
   ḅ       -     convert from base (vectorises)                 [3,13]
                                        (i.e. [5×-1¹+8×-1°, 5×1¹+8×1°])
      X    -     random choice                                  3?
       ṭ   -     tack                                           [1,1,2,3,5,8,3]

Answer 5

perl -061 -M5.010, 46 43 octets

say$,while($,,$/)=($/,$/+$,-2*$,*(.5<rand))

Essayez-le en ligne!

Cela imprime la série infinie.

Sauvegardé de trois octets à l'aide d'une suggestion de Nahuel Fouilleul.

Comment ça marche?

La première astuce est le commutateur de ligne de commande -061. Cela définit l'enregistrement d'entrée sur 1(car la valeur ASCII de 1est 49, soit 61 en octal). Le séparateur d'enregistrement d'entrée est $/.

Nous utilisons ensuite deux variables pour conserver l'état, $,qui est initialement la chaîne vide, mais Perl la traitera comme 0lorsqu'elle est utilisée comme un nombre. $/est défini sur 1, comme indiqué ci-dessus. Dans une boucle infinie, nous mettons $,à $/, et $/à $, + $/, puis, avec une probabilité de 0,5, soustrayons 2 * $,de ce dernier. Nous imprimons ensuite $,.

Answer 6

Wolfram Language (Mathematica) , 45 octets

Sorties f (n) en utilisant RandomInteger 0 ou 1

#&@@Nest[+##|(-1)^Random@0[[0]]#&@@#&,0|1,#]&

Essayez-le en ligne!

-6 octets de @att

J'ai aussi essayé ça 46 bytes

If[#>1,#0[#-1]+(-1)^RandomInteger[]#0[#-2],#]&     

mais la séquence ne pouvait pas "se souvenir" des valeurs précédentes

Answer 7

Python 2, 66 64 octets

Sort la séquence à l'infini.

from random import*
a=b=1
while 1:print a;a,b=b,b+choice([-a,a])

Essayez-le en ligne!

Python 2, 73 octets

Sort le nième terme de la séquence.

from random import*
a,b=0,1
exec"a,b=b,b+choice([-a,a]);"*input()
print a

Essayez-le en ligne!

Answer 8

J , ²⁸ 22 octets

-6 grâce à Bubbler!

0{1&({,]#.~_1^?@2)&1 1

Essayez-le en ligne!

0{1&({,]#.~_1^?@2)&1 1
  1&      …       &1 1 a verb that will apply 1&… on 1 1 y (the input) times 
              ?@2        0 or  1
           _1^           1 or _1
       ]#.~              to base, e.g. 3 5:
                           (3* 1^1)+(5* 1^0) = 8 or
                           (3*_1^1)+(5*_1^0) = 2
     {,                  prepend tail of list, i.e. 5 8 or 5 2
0{                     take first element

Answer 9

JavaScript (ES6),  68 67 66 53  52 octets

Sauvegardé 2 octets grâce à @Shaggy

Renvoie le n -ème terme, indexé à 0.

f=(n,p=1,q=0)=>n?f(n-1,Math.random()<.5?p+q:p-q,p):p

Essayez-le en ligne!

Commenté

f = (                // f is a recursive function taking:
  n,                 //   n = 0-indexed input
  p = 1,             //   p = previous value
  q = 0              //   q = penultimate value
) =>                 //
  n ?                // if n is not equal to 0:
    f(               //   do a recursive call:
      n - 1,         //     decrement n
      Math.random()  //     set p to either:
      < 0.5 ? p + q  //       p + q
            : p - q, //       or p - q
      p              //     copy the previous value in q
    )                //   end of recursive call
  :                  // else:
    p                //   return the last value

Answer 10

> <> , 22 octets

1|.00<-x+40.08&:{&:}n:

Essayez-le en ligne!

C'est généralement un langage terrible pour les défis impliquant le hasard, car la seule source d'aléa dans> <> est x.

Mais dans ce cas, tout va bien. xenvoie le pointeur d'instruction dans une direction aléatoire, de sorte qu'il s'enroule sur lui-même dans la direction y, ou frappe a +ou -avec une probabilité égale.

Answer 11

C (gcc) , 58 57 47 octets

a,b;f(x){a=--x?f(b=x),b+=rand(x=b)%2?a:-a,x:1;}

Essayez-le en ligne!

• Enregistré 1 grâce à @ceilingcat
• 10 sauvés grâce à @Dominic van Essen

Solution récursive qui lance tous les appels nécessaires avant de les exécuter, le dernier appel initialise les valeurs.

un B; - variables aux
f (x) {- fonction collant un entier n et
               renvoyant le n ième terme 1 indexé.

a = - retourne le registre eax creux
--x? f (b = x) - appel récursivement avant de faire le travail
x = b - local x utilisé comme température
, b + = rand ()% 2? a: -a - rnd étape fib
, x - assigne temp (x) à un
: 1;} - arrête la récursivité et initialise a à 1

Answer 12

R , 69 ... 55 octets

-1 octet grâce à Giuseppe (qui a conduit à -4 octets supplémentaires), et -1 octet grâce à Dominic van Essen (qui a conduit à un autre -1 octet)

F=0:1;repeat cat(" ",{F=F[2]+F[1]*(0:-1)^sample(2)}[1])

Essayez-le en ligne!

Imprime la séquence indéfiniment, séparée par des espaces.

Fest initialisé en tant que vecteur [1 1].

À chaque étape, dessinez une permutation aléatoire du vecteur [1 2]avec sample(2). Cela signifie que (0:-1)^sample(2)c'est soit [0^1 (-1)^2]=[0 1]ou [0^2 (-1)^1]=[0 -1](avec une probabilité de 1/2 chacun). Dans les deux cas, F[1]prend la valeur précédente de F[2], et en fonction du tirage au sort, F[2]devient soit F[2]+F[1]ou F[2]-F[1]. Terminez l'étape en imprimant la première valeur de F.

Notez que je peux raccourcir ces 2 octets en utilisant un délimiteur stupide entre les valeurs de séquence: Essayez en ligne une version de 53 octets qui utilise la chaîne TRUE comme délimiteur.

Answer 13

Raku , 26 octets

{1,1,*+* *(-1,1).pick...*}

Essayez-le en ligne!

Produit une liste infinie paresseuse. C'est à peu près identique au programme normal de fibonacci, mais avec *(-1,1).pickcloué dessus pour retourner au hasard le signe du deuxième paramètre.

Answer 14

Python 3 , 77 octets

from random import*
f=lambda n,t=0,o=1:o if n<2else f(n-1,o,o+choice((-t,t)))

Une fonction récursive qui accepte \$n\$et donne un possible \$f_n\$.

Essayez-le en ligne! Ou voyez les premières distributions 10K échantillonnées .

Answer 15

Rouge , 75 octets

func[n][a: b: 1 loop n - 1[set[a b]reduce[b b +(a * pick[1 -1]random 2)]]a]

Essayez-le en ligne!

Renvoie le ne terme.

Answer 16

Wolfram Language (Mathematica) , 38 octets

Imprime la séquence indéfiniment. Adapté de la réponse de J42161217 .

#0[Echo@+##,RandomChoice@{#,-#}]&[0,1]

Essayez-le en ligne!

Non golfé:

f[a_, b_] := ( Echo[a+b]; f[a+b, RandomChoice[{a,-a}]] );
f[0, 1]

Answer 17

R , 55 54 53 52 51 49 48 47 octets

Edit: -1 octet, et encore -1 octet grâce à Giuseppe, -1 octet grâce à AZTECCO

cat(1);repeat cat(" ",T<-sign(rt(1,1))*F+(F=T))

Essayez-le en ligne! ou vérifiez la distribution n = 6 .

Programme complet ne prenant aucune entrée. Renvoie la séquence de fibonacci aléatoire complète.

Le programme pour renvoyer l' nélément en utilisant la même approche est de 48 octets .

Commenté:

cat(1);             # First, print the first element (1) 
                    # (T is initialized to 1 by default,
                    # and F is initialized to 0).
repeat              # Now, repeat indefinitely:
 cat(" ",           # output " ", followed by...
  T<-               #   T, updated to equal...
     sign(rt(1,1))  #   the sign of 1 randomization of 
                    #     the t-distribution with 1 degree-of-freedom
                    #     (distribution is centred around zero,
                    #     so sign is [+1,-1] with probability [.5,.5])...
     *F             #   times F (second-last value)...
       +(F=T))      #   plus T (last value)...
                    #   while updating F to equal T.

Answer 18

Dotty, 75 octets

val| :Stream[Int]=1#::1#::(|zip|.tail map(_*((math.random*2).toInt*2-1)+_))

Essayez-le en ligne

Comme ci-dessous.

Scala, 91 87 85 84 octets

Sauvegardé 4 octets grâce à corvus_192

val| :Stream[Int]=1#::1#::(|zip|.tail map{t=>t._2+t._1*((math.random*2).toInt*2-1)})

Essayez-le en ligne

|est un Streamafin que les éléments précédents soient mémorisés. Pour obtenir le nième élément, vous pouvez utiliser |(n-1)(il est indexé à 0). Pour obtenir les n premiers éléments, utilisez |.take(n)( l.take(n).toListpour le forcer).

Answer 19

Charbon , 28 octets

≔⁰θ≔¹ηＦＮ«≔⁺η×θ⊖⊗‽²ι≔ηθ≔ιη»Ｉθ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Sort le nème nombre. Explication:

≔⁰θ≔¹η

Commencez par 0 comme ième nombre et 1comme i+1ème nombre.

ＦＮ«

nTemps de boucle .

≔⁺η×θ⊖⊗‽²ι

Calculez le nombre suivant.

≔ηθ≔ιη

Mélangez les valeurs.

»Ｉθ

Sortez le nème nombre.

29 octets pour sortir les premiers nnombres:

Ｆ²⊞υ¹ＦＮ⊞υ⁺§υ±¹×§υ±²⊖⊗‽²Ｉ✂υ⁰±²

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

Ｆ²⊞υ¹

Commencez par 1les premier et deuxième nombres.

ＦＮ

nTemps de boucle .

⊞υ⁺§υ±¹×§υ±²⊖⊗‽²

Calculez le nombre suivant.

Ｉ✂υ⁰±²

Sortez tous les nombres sauf deux.

Answer 20

Icône , 70 octets

procedure n()
f:=[1,1]
while write(f[2])&push(f,f[1]+?[1,-1]*f[2])
end

Essayez-le en ligne!

Imprime le séquène indéfiniment.

Answer 21

code machine x86, 21 octets

La version rdtsc est de la même taille pour le code machine x86-64.

rdrand reg(3 octets) nous donne un nombre vraiment aléatoire. Le branchement sur son mors de signe est bon marché. En testant seulement 1 bit, la probabilité 50/50 est évidemment satisfaite exactement avec un biais nul.

rdtsc(2 octets) nous donne un horodatage « cycle de référence » dont la faible bits sont un peu au hasard (il faut au moins 25 cycles pour courir à dos instructions RDTSC, mais le compteur ne fonctionne pas que beaucoup plus rapide que nous échantillonnons il). Tester un bit avec test al, 1conduit à une corrélation significative entre les décisions consécutives, mais test al,al/ jnp(branche sur l'indicateur de parité, xor horizontal des 8 bits bas) donne des résultats étonnamment bons et pourrait être utilisé sur des machines pré-IvyBridge qui manquent rdrand. Les deux golfent à la même taille globale en mode 32 bits.

Essayez-le en ligne! Liste NASM pour la rdrandversion EAX rfib(ECX):, appelable de C avec MS__fastcall

21                         rfib:          ;;; 0-indexed.  ecx=5 gives the n=6 test case results.
22 00000020 31C0               xor eax, eax
23 00000022 99                 cdq                         ; EDX = fib[-1] = 0
24 00000023 40                 inc eax                     ; fib[0] = 1
25 00000024 E30E               jecxz   .done               ; ecx=0 : return 1 without looping

27                         .loop:
28 00000026 0FC7F7             rdrand  edi
29 00000029 85FF               test    edi, edi        ; 1 byte shorter than sar reg, imm / xor / sub 2's complement bithack
30 0000002B 7902               jns    .no_negate       ; the top bit is fully random
31 0000002D F7DA               neg    edx
32                         .no_negate:
33 0000002F 0FC1D0             xadd    eax, edx        ; like xchg + add, and same size
34 00000032 E2F2               loop   .loop
35                         .done:
36 00000034 C3                 ret
 size = 0x35 - 0x20 = 0x15 = 21 bytes

Notez que cela xaddn'enregistre en fait aucun octet par rapport à xchg eax, edx/ add eax, edx. C'est juste amusant. Et c'est "seulement" 3 uops, au lieu de 4 au total, sur Intel Skylake avec des opérandes de registre. (Normalement, l'instruction n'est utilisée qu'avec le lockpréfixe et une destination mémoire, mais elle fonctionne entièrement avec les registres).

Cas de test:

  bash loop to test the ECX=5 case
$ asm-link -m32 -dn random-fib.asm && { declare -A counts; counts=(); for i in {1..10000}; do ./random-fib; ((counts[$?]++));done; 
  for i in "${!counts[@]}"; do echo "result: $(( i > 128 ? i-256 : i )):   
${counts[$i]} times";done }

result: 8:   617 times
result: 4:   1290 times
result: 2:   2464 times
result: 0:   3095 times
result: -2:   2534 times

---

MSNA liste pour la rdtscversion : EBX rfib2(ECX). Cette version aurait la même taille en mode 64 bits; n'a pas besoin de 1 octet inc. RDTSC écrit EAX et EDX afin que nous ne puissions pas profiter de cdql'initialisation.

 2                         rfib2:            ; 0-index count in ECX, returns in EBX
 3 00000000 31F6               xor  esi, esi
 4 00000002 8D5E01             lea  ebx, [esi+1]           ; fib[0] = 1, fib[-1] = 0
 5 00000005 E30D               jecxz .done
 6                         .loop:
 7 00000007 0F31               rdtsc                       ; EDX:EAX = TimeStamp Counter
 8                         
 9 00000009 84C0               test    al, al               ; low bits are essentially random; high bits not so much
10 0000000B 7B02               jnp    .no_negate
11 0000000D F7DE               neg     esi
12                         .no_negate:
13 0000000F 0FC1F3             xadd    ebx, esi
14 00000012 E2F3               loop   .loop
15                         .done:
16                             ; returns in EBX
17 00000014 C3                 ret
 size = 0x15 = 21 bytes

Résultats des tests pour ECX = 5:

result: 8:   668 times         (ideal: 625)
result: 4:   1217 times        (ideal: 1250)
result: 2:   2514 times        (ideal: 2500)
result: 0:   3135 times        (ideal: 3125)
result: -2:   2466 times       (ideal: 2500)

vs avec test al, 1/ jnzpour utiliser uniquement le bit bas du TSC comme valeur aléatoire:

  # test al,1  / jnz   version: correlation between successive results.
result: 8:   115 times
result: 4:   79 times
result: 2:   831 times
result: 0:   3070 times
result: -2:   5905 times

test al,4fonctionne raisonnablement bien pour les longues exécutions sur mon processeur Skylake (i7-6700k) qui augmente jusqu'à 3,9 GHz à l'énergie_performance_preference = balance_performance que j'utilise, par rapport à une fréquence de référence (TSC) de 4008 MHz ( plus d'informations sur la constante x86 -Trucs TSC ). J'imagine qu'il y a une étrange alchimie de prédiction de branche, et rdtscelle - même ayant un débit d'environ 25 cycles (horloges principales) sur Skylake (https://uops.info).

Les résultats sont généralement mieux distribués avec test al,al/ jnpcependant, donc préférez que pour prendre l'entropie des 8 bits faibles. Lorsque la fréquence du processeur est faible (inactif), de sorte que le TSC n'est pas proche de la même fréquence que le cœur, prendre l'entropie d'un seul bit pourrait fonctionner encore mieux, bien que la parité des 8 bits bas soit probablement toujours meilleure.

Je n'ai pas testé sur un processeur avec turbo désactivé où l'horloge du cœur non-boost est exactement égale à l'horloge de référence TSC. Cela pourrait plus facilement conduire à de mauvais modèles si le rdtscdébit se trouve être une puissance de 2 ou quelque chose du genre, favorisant peut-être une séquence permettant de verrouiller la prédiction de branche.

Tous mes tests ont été effectués avec une seule invocation de la fonction par démarrage de processus. Un exécutable statique Linux est assez efficace à démarrer, mais coûte toujours beaucoup plus cher que d'appeler la fonction dans une boucle depuis l'intérieur du processus.

Answer 22

C (gcc) , 56 53 52 octets

Edit: -3 octets grâce à AZTECCO, -1 octet grâce au plafonnier

x;y;r(n){for(x=y=1;--n;)x=~-(rand()&2)*y+(y=x);x=y;}

Essayez-le en ligne!

Réponse non récursive en C.
Fonction qui renvoie l' nélément (basé sur un) de la séquence aléatoire de fibonacci.

x;y;                # x & y hold last and last-but-one elements;
r(n){               # n is index of element we're looking for;
for(x=y=1;          # initialise first two elements to 1;
 --n;)              # now loop by decreasing n until it is zero,
 x=                 # update x to become equal to:
   ~-(rand()&2)*y   # plus-or-minus y...
   +(y=x)           # plus x
                    # (while updating y to equal the current x).
    ;x=y;}          # after looping, return y.

Remarque : Suite à une discussion dans les commentaires ici et dans la réponse d'AZTECCO , un consensus a été atteint sur le fait qu'il n'est pas nécessaire d'initialiser la graine aléatoire dans une fonction . Bien sûr, cela signifie que le programme appelant doit le faire, ou la fonction peut donner la même séquence de sortie pseudo-aléatoire à chaque fois que le programme appelant est exécuté. Une variante de 74 octets de la fonction peut elle-même initialiser la graine aléatoire elle-même (mais uniquement lors du premier appel, de sorte que les appels ultérieurs du même programme exécuté donnent une sortie différente).

Answer 23

Bash , 65 octets

a=1;b=1;while :;do echo $a;t=$b;:$[b+=$RANDOM&1?$a:-$a];a=$t;done

Essayez-le en ligne!

Sort sans fin la dernière et la meilleure version de la séquence.

Answer 24

Swift , 77 octets

sequence(first:(1,1)){a,b in(b,.random() ?a+b:a-b)}.lazy.forEach{print($0.0)}

Sorties jusqu'au Intdébordement.

Answer 25

Lua , 81 octets

t={1,1}for i=1,...do t[i]=t[i]or t[i-1]+t[i-2]*(math.random(2)*2-3)print(t[i])end

Essayez-le en ligne!

Prend le nombre de membres à imprimer comme argument. Remplacez ...par 1/0 pour imprimer la séquence pour toujours à const d'un octet.