Introduction (peut être ignoré)

Mettre tous les nombres positifs dans son ordre régulier (1, 2, 3, ...) est un peu ennuyeux, n'est-ce pas? Voici donc une série de défis autour des permutations (remaniements) de tous les nombres positifs. Il s'agit du quatrième défi de cette série (liens vers les premier , deuxième et troisième défis).

Dans ce défi, nous explorerons non pas une permutation des nombres naturels, mais un monde entier de permutations!

En 2000, Clark Kimberling a posé un problème dans le 26 ^e numéro de Crux Mathematicorum , une revue scientifique de mathématiques publiée par la Société mathématique du Canada. Le problème était:

$\text{Sequence }a = \begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{2} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{2} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = 3 a_{n-1}\text{ otherwise} \end{cases}$

Est-ce que chaque entier positif se produit exactement une fois dans cette séquence?

En 2004, Mateusz Kwasnicki a fourni une preuve positive dans le même journal et en 2008, il a publié une preuve plus formelle et (par rapport à la question d'origine) plus générale. Il a formulé la séquence avec les paramètres $p$ et $q$ :

$\begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{q} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{q} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = p a_{n-1}\text{ otherwise} \end{cases}$

Il a prouvé que pour tout $p, q>1$ tel que $log_p(q)$ est irrationnel, la séquence est une permutation des nombres naturels. Puisqu'il existe un nombre infini de valeurs $p$ et $q$ pour lesquelles cela est vrai, il s'agit véritablement d'un monde entier de permutations des nombres naturels. Nous nous en tiendrons à l'original $(p, q)=(3, 2)$ , et pour ces paramètres, la séquence peut être trouvée comme A050000dans l'OEIS. Ses 20 premiers éléments sont:

1, 3, 9, 4, 2, 6, 18, 54, 27, 13, 39, 19, 57, 28, 14, 7, 21, 10, 5, 15

Puisqu'il s'agit d'un défi de "séquence pure", la tâche consiste à sortir $a(n)$ pour un $n$ donné en entrée, où $a(n)$ est A050000 .

Tâche

Étant donné une entrée entière $n$ , sortie $a(n)$ au format entier, où:

$\begin{cases} a(1) = 1\\ a(n) = \lfloor \frac{a(n-1)}{2} \rfloor\text{ if }\lfloor \frac{a(n-1)}{2} \rfloor \notin \{0, a_1, ... , a(n-1)\}\\ a(n) = 3 a(n-1)\text{ otherwise} \end{cases}$

Remarque: l'indexation basée sur 1 est supposée ici; vous pouvez utiliser une indexation basée sur 0, donc $a(0) = 1; a(1) = 3$ , etc. Veuillez le mentionner dans votre réponse si vous choisissez de l'utiliser.

Cas de test

Input | Output
---------------
1     |  1
5     |  2
20    |  15
50    |  165
78    |  207
123   |  94
1234  |  3537
3000  |  2245
9999  |  4065
29890 |  149853

Règles

• L'entrée et la sortie sont des entiers (votre programme devrait au moins prendre en charge l'entrée et la sortie dans la plage de 1 à 32 767)
• Une entrée non valide (0, flottants, chaînes, valeurs négatives, etc.) peut entraîner une sortie imprévue, des erreurs ou un comportement (non) défini.
• Les règles d'E / S par défaut s'appliquent.
• Les failles par défaut sont interdites.
• Il s'agit de code-golf , donc les réponses les plus courtes en octets l'emportent

Japt , 15 14 octets

1 indexé.

@[X*3Xz]kZ Ì}g

Essayez-le

@[X*3Xz]kZ Ì}g     :Implicit input of integer U
             g     :Starting with the array [0,1] do the following U times, pushing the result to the array each time
@                  :  Pass the last element X in the array Z through the following function
 [                 :    Build an array containing
  X*3              :      X multiplied by 3
     Xz            :      X floor divided by 2
       ]           :    Close array
        kZ         :    Remove all elements contained in Z
           Ì       :    Get the last element
            }      :  End function
                   :Implicit output of the last element in the array

JavaScript (ES6),  55 51  50 octets

1 octet enregistré grâce à @EmbodimentofIgnorance
1 octet enregistré grâce à @tsh

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

Essayez-le en ligne!

Gelée , 15 octets

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ

Un programme complet acceptant l'entier, n(basé sur 1), de STDIN qui imprime le résultat.

Essayez-le en ligne!

Comment?

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ - Main Link: no arguments (implicit left argument = 0)
µ           µ¡  - repeat this monadic chain STDIN times (starting with x=0)
                -                   e.g. x = ...  0      [1,0]            [9,3,1,0]
 ×3             -   multiply by 3                 0      [3,0]            [27,9,3,0]
    H           -   halve                         0      [1.5,0]          [4.5,1.5,0.5,0]
   ż            -   zip together                  [0,0]  [[3,1.5],[0,0]]  [[27,4.5],[9,1.5],[3,0.5],[0,0]]
     Ḟ          -   floor                         [0,0]  [[3,1],[0,0]]    [[27,4],[9,1],[3,0],[0,0]]
      Ḣ         -   head                          0      [3,1]            [27,4]
       ḟ        -   filter discard if in x        []     [3]              [27,4]
        ȯ1      -   logical OR with 1             1      [3]              [27,4]
          Ṫ     -   tail                          1      3                4
           ;    -   concatenate with x            [1,0]  [3,1,0]          [4,9,3,1,0]
              Ḣ - head                            1      3                4
                - implicit print

05AB1E , 16 15 octets

Enregistré 1 octet grâce à Kevin Cruijssen .
0 indexé.

¾ˆ$FDˆx3*‚;ï¯Kн

Essayez-le en ligne!

Explication

Utilisation n=1comme exemple

¾ˆ                 # initialize global array as [0]
  $                # initialize stack with 1, input
   F               # input times do:
    Dˆ             # duplicate current item (initially 1) and add one copy to global array
                   # STACK: 1, GLOBAL_ARRAY: [0, 1]
      x            # push Top_of_stack*2
                   # STACK: 1, 2, GLOBAL_ARRAY: [0, 1]
       3*          # multiply by 3
                   # STACK: 1, 6, GLOBAL_ARRAY: [0, 1]
         ‚;ï       # pair and integer divide both by 2
                   # STACK: [0, 3], GLOBAL_ARRAY: [0, 1]
            ¯K     # remove any numbers already in the global array
                   # STACK: [3], GLOBAL_ARRAY: [0, 1]
              н    # and take the head
                   # STACK: 3

Perl 6 , 49 octets

-2 octets grâce à nwellnof

{(1,3,{(3*@_[*-1]Xdiv 6,1).max(*∉@_)}...*)[$_]}

Essayez-le en ligne!

Renvoie l'élément indexé 0 dans la séquence. Vous pouvez changer cela en 1 indexé en remplaçant les éléments de départ par au 0,1lieu de1,3

Explication:

{                                             }  # Anonymous code block
 (                                   ...*)[$_]   # Index into the infinite sequence
  1,3                                            # That starts with 1,3
     ,{                             }            # And each element is
       (                 ).max(    )             # The first of
          @_[*-1]X                               # The previous element
        3*        div 6                          # Halved and floored
        3*        div  ,1                        # Or tripled
                               *∉@_             # That hasn't appeared in the sequence yet

J , 47 40 octets

[:{:0 1(],<.@-:@{:@](e.{[,3*{:@])])^:[~]

Essayez-le en ligne!

non golfé

[: {: 0 1 (] , <.@-:@{:@] (e. { [ , 3 * {:@]) ])^:[~ ]

La traduction directe de la définition en J. Elle se construit de bas en haut en utilisant ^:pour itérer à partir de la valeur de départ le nombre de fois requis.

Java 10, 120 99 octets

n->{var L=" 1 0 ";int r=1,t;for(;n-->0;L+=r+" ")if(L.contains(" "+(r=(t=r)/2)+" "))r=t*3;return r;}

Essayez-le en ligne.

Explication:

n->{                              // Method with integer as both parameter and return-type
  var L=" 1 0 ";                  //  Create a String that acts as 'List', starting at [1,0]
  int r=1,                        //  Result-integer, starting at 1
      t;                          //  Temp-integer, uninitialized
  for(;n-->0;                     //  Loop the input amount of times:
      L+=r+" "))                  //    After every iteration: add the result to the 'List'
                          t=r     //   Create a copy of the result in `t`
                       r=(...)/2  //   Then integer-divide the result by 2
    if(L.contains(" "+(...)+" ")) //   If the 'List' contains this result//2:
      r=t*3;                      //    Set the result to `t` multiplied by 3 instead
  return r;}                      //  Return the result

Haskell , 67 65 octets

(h[1,0]!!)
h l@(a:o)|elem(div a 2)o=a:h(3*a:l)|1>0=a:h(div a 2:l)

Essayez-le en ligne!

Utilise l'indexation basée sur 0.

EDIT: enregistré 2 octets en utilisant elemau lieu de notElemet en changeant les conditions

Gelée , 21 octets

Ø.;0ị×3$:2$:2eɗ?Ɗ$⁸¡Ṫ

Essayez-le en ligne!

Un lien monadique qui prend l'index zéro $n$ comme argument et retourne $a(n)$.

Rubis , 54 52 48 octets

->n{*s=0;j=2;n.times{s<<j=s==s-[j/2]?j/2:j*3};j}

Essayez-le en ligne!

C ++ (gcc) , 189 octets

-9 octets au petit golf

#import<vector>
#import<algorithm>
int a(int n){std::vector<int>s={1};for(int i=0;i<n;++i)s.push_back(i&&std::find(s.begin(),s.end(),s[i]/2)==s.end()?s[i]/2:3*s[i]);return s[n-1];}

Essayez-le en ligne!

Calcule la séquence jusqu'à n, puis renvoie l'élément souhaité. Lent pour les indices plus grands.

Python 2 , 66 octets

l=lambda n,p=1,s=[0]:p*(n<len(s))or l(n,3*p*(p/2in s)or p/2,[p]+s)

Essayez-le en ligne!

Utilise une indexation à base zéro. Le lambda ne fait guère plus que de construire récursivement la séquence et de revenir dès que l'index requis est atteint.

Stax , 14 octets

üÑα↕○Ü1∟¡f↑ô┬♥

Exécuter et déboguer

Zéro indexé.

Wolfram Language (Mathematica) , 63 octets

(L=Last)@Nest[{##,If[FreeQ[#,x=⌊L@#/2⌋],x,3L@#]}&,{0,1},#]&

Essayez-le en ligne!

Ceci est indexé 0
(dans TIO j'ai ajouté -1 dans chaque cas de test)

Python 2 , 62 octets

a=lambda n:n<1or a(n-1)*6**(a(n-1)//2in[0]+map(a,range(n)))//2

Essayez-le en ligne!

Retourne Truepour a(0). 0 indexé.

Python 3 , 105 103 100 100 95 83 octets

-2 octets grâce à agtoever
-12 octets grâce à ArBo

def f(n):
 s=0,1
 while len(s)<=n:t=s[-1]//2;s+=(t in s)*3*s[-1]or t,
 return s[-1]

Essayez-le en ligne!

Gaia , 22 20 octets

2…@⟨:):3פḥ⌋,;D)+⟩ₓ)

Essayez-le en ligne!

Index basé sur 0.

Nous remercions Shaggy pour l'approche

2…			| push [0 1]
  @⟨		 ⟩ₓ	| do the following n times:
    :):			| dup the list L, take the last element e, and dup that
       3פḥ⌋,		| push [3*e floor(e/2)]
	     ;D		| take the asymmetric set difference [3*e floor(e/2)] - L
	       )+	| take the last element of the difference and add it to the end of L (end of loop)
		   )	| finally, take the last element and output it

;D

Haskell , 55 octets

(1%[0]!!)
a%o|b<-div a 2=a:last(b:[3*a|elem b o])%(a:o)

Essayez-le en ligne!

La méthode de génération de listes de golf de user1472751 .

Même longueur:

(1%[0]!!)
a%o=a:[x|x<-[div a 2,a*3],all(/=x)o]!!0%(a:o)

Essayez-le en ligne!

Lua , 78 octets

x,y=1,3 u={}for _=2,...do
u[x]=0
x,y=y,y//2
if u[y]then y=3*x end
end
print(x)

Essayez-le en ligne!