Définissez la fonction f (n) pour un entier positif n comme suit:

• n / 2 , si n est pair
• 3 * n + 1 , si n est impair

Si vous appliquez à plusieurs reprises cette fonction à tout n supérieur à 0, le résultat semble toujours converger vers 1 (bien que personne n'ait encore pu le prouver). Cette propriété est connue sous le nom de conjecture de Collatz .

Définissez le temps d'arrêt d' un entier comme le nombre de fois que vous devez le passer par la fonction Collatz f avant qu'il n'atteigne 1. Voici les temps d'arrêt des 15 premiers entiers:

1  0
2  1
3  7
4  2
5  5
6  8
7  16
8  3
9  19
10 6
11 14
12 9
13 9
14 17
15 17

Appelons n'importe quel ensemble de numéros avec les mêmes cousins ​​Collatz de temps d'arrêt . Par exemple, 5 et 32 ​​sont des cousins ​​Collatz, avec un temps d'arrêt de 5.

Votre tâche: écrire un programme ou une fonction qui prend un entier non négatif et génère l'ensemble des cousins ​​Collatz dont le temps d'arrêt est égal à cet entier.

Contribution

Un entier non négatif S, donné via STDIN, ARGV ou un argument de fonction.

Production

Une liste de tous les numéros dont le temps d' arrêt est S, triée en ordre croissant ordre. La liste peut être sortie par votre programme, ou retournée ou sortie par votre fonction. Le format de sortie est flexible: séparé par des espaces, séparé par des sauts de ligne ou par tout autre format de liste standard de votre langue, tant que les chiffres sont facilement distinguables les uns des autres.

Exigences

Votre soumission doit donner des résultats corrects pour tout S ≤ 30. Elle doit se terminer en quelques secondes ou minutes, et non en heures ou jours.

Exemples

0  -> 1
1  -> 2
5  -> 5, 32
9  -> 12, 13, 80, 84, 85, 512
15 -> 22, 23, 136, 138, 140, 141, 150, 151, 768, 832, 848, 852, 853, 904, 906, 908, 909, 5120, 5376, 5440, 5456, 5460, 5461, 32768

Voici un résumé de la sortie pour S = 30 .

C'est le code-golf : le programme le plus court en octets gagne. Bonne chance!

Pyth, 26 24 21 octets

Su+yMG-/R3fq4%T6G1Q]1

Ce code s'exécute instantanément pour S=30. Essayez-le vous-même: Démonstration

Merci à @isaacg pour avoir économisé 5 octets.

Explication

Mon code commence par 1et annule la fonction Collatz. Il mappe tous les numéros dde l' S-1étape vers 2*det (d-1)/3. Le dernier n'est pas toujours valable cependant.

                        implicit: Q = input number
                   ]1   start with G = [1]
 u                Q     apply the following function Q-times to G:
                          update G by
   yMG                      each number in G doubled
  +                       +
          fq4%T6G           filter G for numbers T, which satisfy 4==T%6
       /R3                  and divide them by 3
      -          1          and remove 1, if it is in the list
                            (to avoid jumping from 4 to 1)
S                       sort the result and print

Mathematica, 98 92 89 octets

Cette solution résout S = 30immédiatement:

(p={0};l={1};Do[l=Complement[##&@@{2#,Mod[a=#-1,2]#~Mod~3~Mod~2a/3}&/@l,p=p⋃l],{#}];l)&

Il s'agit d'une fonction sans nom prenant Scomme seul paramètre et renvoyant une liste des cousins ​​Collatz.

L'algorithme est une simple recherche en largeur. Les cousins ​​Collatz pour une donnée Ssont tous les entiers qui peuvent être atteints à partir des cousins ​​Collatz pour S-1via 2*nou des nombres impairs qui peuvent être atteints via (n-1)/3. Nous devons également nous assurer que nous ne produisons que les entiers qui ont été atteints pour la première fois après les Sétapes, afin de garder une trace de tous les cousins ​​précédents pet de les supprimer du résultat. Comme nous le faisons de toute façon, nous pouvons économiser quelques octets en calculant les étapes de tous les cousins ​​précédents (pas seulement ceux de S-1) pour enregistrer quelques octets (ce qui le rend légèrement plus lent, mais pas sensiblement pour le nécessaire S).

Voici une version légèrement plus lisible:

(
  p = {0};
  l = {1};
  Do[
    l = Complement[
      ## & @@ {2 #, Mod[a = # - 1, 2] #~Mod~3~Mod~2 a/3} & /@ l,
      p = p ⋃ l
    ]~Cases~_Integer,
    {#}
  ];
  l
) &

Python 2, 86 83 75 73 71 octets

f=lambda n,k=1:sorted([k][n:]or(k>4==k%6and f(n-1,k/3)or[])+f(n-1,k*2))

Appelez comme f(30). n = 30est à peu près instantané.

(Merci à @DLosc pour l'idée de récurrence en kétant un nombre plutôt qu'une liste de cousins, et quelques octets. Merci à @isaacg d'avoir abandonné ~-.)

Cette variante est beaucoup plus courte, mais prend malheureusement trop de temps en raison d'une ramification exponentielle:

f=lambda n,k=1:sorted([k][n:]or(k>4==k%6)*f(n-1,k/3)+f(n-1,k*2))

CJam, 29 26 octets

Xari{{2*_Cmd8=*2*)}%1-}*$p

Nous remercions @isaacg pour son idée de supprimer les 1 après chaque itération, ce qui m'a fait économiser deux octets directement et un autre indirectement.

Essayez-le en ligne dans l' interpréteur CJam (devrait se terminer en moins d'une seconde).

Comment ça marche

Xa       e# Push A := [1].
ri{      e# Read an integer from STDIN and do the following that many times:
  {      e# For each N in A:
    2*   e#     Push I := (N * 2) twice.
    _Cmd e#     Push (I / 12) and (I % 12).
     8=  e#     Push K := (I % 12 == 8).

         e#     (K == 1) if and only if the division ((N - 1) / 3) is exact and
         e#     yields an odd integer. In this case we can compute the quotient 
         e#     as (I / 12) * 2 + 1.

    *2*) e#     Push J := (I / 12) * K * 2 + 1.

         e#     This yields ((N - 1) / 3) when appropriate and 1 otherwise.
  }%     e# Replace N with I and J.
  1-     e# Remove all 1's from A.

         e# This serves three purposes:

         e# 1. Ones have been added as dummy values for inappropriate quotients.

         e# 2. Not allowing 1's in A avoids integers that have already stopped
         e#    from beginning a new cycle. Since looping around has been prevented,
         e#    A now contains all integers of a fixed stopping time.

         e# 3. If A does not contain duplicates, since the maps N -> I and N -> J
         e#      are inyective (exluding image 1) and yield integers of different
         e#      parities, the updated A won't contain duplicates either.

}*       e#
$p       e# print(sort(C))

CJam, 35 octets

1]ri{_"(Z/Y*"3/m*:s:~\L+:L-_&0-}*$p

Explication à venir. Il s'agit d'une version beaucoup plus rapide que l'approche "assez simple" (voir dans l'historique des modifications).

Essayez-le en ligne ici pour N = 30lequel s'exécute en quelques secondes sur la version en ligne et instantanément dans le compilateur Java

Java 8, 123

x->java.util.stream.LongStream.range(1,(1<<x)+1).filter(i->{int n=0;for(;i>1;n++)i=i%2<1?i/2:3*i+1;return n==x;}).toArray()

Quand xest 30, le programme prend 15 minutes et 29 secondes.

Étendu

class Collatz {
    static IntFunction<long[]> f =
            x -> java.util.stream.LongStream.range(1, (1 << x) + 1).filter(i -> {
                int n = 0;
                for (; i > 1; n++)
                    i = i % 2 < 1 ? i / 2 : 3 * i + 1;
                return n == x;
            }).toArray();

    public static void main(String[] args) {
        System.out.println(Arrays.toString(f.apply(15)));
    }
}

Python 2, 118 octets

Eh bien, je me suis dit que je n'atteindrais pas le meilleur score Python après avoir vu la solution de @ Sp3000. Mais cela ressemblait à un petit problème amusant, donc je voulais quand même essayer une solution indépendante:

s={1}
for k in range(input()):
 p,s=s,set()
 for t in p:s.add(2*t);t>4and(t-1)%6==3and s.add((t-1)/3)
print sorted(s)

Même chose avant de supprimer les espaces:

s={1}
for k in range(input()):
    p,s=s,set()
    for t in p:
        s.add(2 * t)
        t > 4 and (t - 1) % 6 == 3 and s.add((t - 1) / 3)
print sorted(s)

Il s'agit d'une implémentation très directe d'une première recherche étendue. À chaque étape, nous avons l'ensemble avec le temps d'arrêtk , et dérivons l'ensemble avec le temps d'arrêt k + 1en ajoutant les prédécesseurs possibles de chaque valeur tdans l'ensemble de l'étape k:

• 2 * t est toujours un prédécesseur possible.
• Si tpeut s'écrire 3 * u + 1, où uest un nombre impair qui n'est pas1 , alors uest également un prédécesseur.

Il faut environ 0,02 secondes pour fonctionner N = 30sur mon MacBook Pro.

PHP 5.4+, 178 octets

La fonction

function c($s,$v=1,$p=[],&$r=[]){$p[]=$v;if(!$s--){return$r[$v][]=$p;}c($s,$v*2,$p,$r);is_int($b=($v-1)/3)&!in_array($b,$p)&$b%2?c($s,$b,$p,$r):0;ksort($r);return array_keys($r);}

Test et sortie

echo "0 - ".implode(',',c(0)).PHP_EOL;
// 0 - 1
echo "1 - ".implode(',',c(1)).PHP_EOL;
// 1 - 2
echo "5 - ".implode(',',c(5)).PHP_EOL;
// 5 - 5,32
echo "9 - ".implode(',',c(9)).PHP_EOL;
// 9 - 12,13,80,84,85,512
echo "15 - ".implode(',',c(15)).PHP_EOL;
// 15 - 22,23,136,138,140,141,150,151,768,832,848,852,853,904,906,908,909,5120,5376,5440,5456,5460,5461,32768

S (30) s'exécute en 0,24 seconde * , renvoie 732 éléments. Un couple sont

86,87,89,520,522,524,525,528, [ ... ] ,178956928,178956960,178956968,178956970,1073741824

* Pour économiser sur les octets, j'ai dû ajouter ksortet array_keysà chaque étape. Le seul autre choix que j'avais était de faire une petite fonction wrapper qui appelle c()puis appelle array_keyset ksortsur le résultat une fois. Mais en raison du temps encore décemment accrocheur, j'ai décidé de prendre le coup de performance pour un faible nombre d'octets. Sans un tri et un traitement appropriés, le temps est en moyenne de 0,07 seconde pour S (30).

Si quelqu'un a des moyens intelligents d'obtenir le traitement approprié une seule fois sans trop d'octets supplémentaires, faites-le moi savoir! (Je stocke mes numéros sous forme de clés de tableau, d'où l'utilisation de array_keyset ksort)

Langage C

#include <stdio.h>
#include <limits.h>    
const int s = 30;

bool f(long i)
{
    int r = 0;
    for(;;)
        if (i < 0 || r > s) return false;
        else if (i == 1) break;
        else{r ++;i = i % 2 ? 3*i + 1 : i/2;}
    return (r==s);
}

void main(){
    for(long i = 1; i < LONG_MAX; i++) if (f(i)) printf("%ld ", i);
}