Contribution:

Un entier positif n composé de chiffres compris entre 0 et 9 .

Défi:

Si d est le chiffre le plus élevé du nombre entier, supposons que la base du nombre est d + 1 . Par exemple, si le nombre entier est 1256, vous supposerez qu'il se trouve en base 7 , s'il s'agit de 10110, vous supposerez qu'il est en base 2 (binaire) et s'il est 159 il est décimal.

À présent, procédez comme suit: 1: atteignez un nombre entier en base 10 ou 2: atteignez un nombre entier.

1. Convertir le nombre entier de base- (d + 1) en base 10
2. Trouver la base de ce nouvel entier (encore une fois, base- (d + 1) où d est le chiffre le plus élevé du nouveau nombre)
3. Passez à l'étape 1 .

Exemples:

Supposons que l'entrée est n = 413574 . Le chiffre le plus élevé d = 7 , il s'agit donc de la base 8 (octale). Convertissez-le en décimal et obtenez 137084 . Le chiffre le plus élevé d = 8 , il s'agit donc de la base 9 . Convertissez-le en décimal et obtenez 83911 . Le chiffre le plus élevé est 9 , il s'agit donc d'un nombre décimal et nous nous arrêtons. La sortie doit être 83911 .

Supposons que l'entrée est n = 13552 . Le chiffre le plus élevé est d = 5 , il s'agit donc de la base 6 . Convertissez-le en décimal et obtenez 2156 . Le chiffre le plus élevé d = 6 , il s'agit donc de la base 7 . Convertissez cela en décimal et obtenez 776 . Le chiffre le plus élevé est d = 7 , il s'agit donc de la base 8 . Convertissez-le en décimal et obtenez 510 . Le chiffre le plus élevé est d = 5 , il s'agit donc de la base 6 . Convertissez-le en décimal et obtenez 186 . Le chiffre le plus élevé est 8 , il s'agit donc de la base 9 . Convertissez ceci en décimal et obtenez 159 . Le chiffre le plus élevé est 9 , il s'agit donc d'un nombre décimal et nous nous arrêtons. La sortie doit être 159 .

Supposons que l'entrée est n = 17 . Cela nous donnera 15 , puis 11 , puis 3 , que nous afficherons puisqu'il s'agit d'un seul chiffre.

Cas de test:

5
5

17
3

999
999

87654321  (base-9 -> 42374116 in decimal -> base-7 -> 90419978 in decimal) 
9041998

41253  (5505 -> 1265 -> 488 -> 404 -> 104 -> 29)
29

Remarques:

• Règles standard concernant les E / S, les échappatoires, etc. Vous pouvez prendre l'entrée comme une chaîne
• Les explications sont encouragées
• Vous pouvez utiliser les commandes de conversion de base intégrées
  • Les solutions qui n'utilisent pas les fonctions de conversion de base intégrées du langage (si elles existent) sont les bienvenues, même si elles s'avèrent beaucoup plus longues que l'approche évidente utilisant des fonctions intégrées.

Apparemment, il s’agit du document OEIS A091047 .

Mathematica, 56 octets

#//.x_/;(b=Max[d=IntegerDigits@x]+1)<11:>d~FromDigits~b&

Essayez-le en ligne! (Utilisation des mathématiques.)

Je pensais vérifier à quoi ressemble la séquence:

Et voici un graphique du nombre d’étapes nécessaires pour trouver le résultat:

^{(Cliquez pour les versions plus grandes. Consultez l'historique des révisions pour les tracés jusqu'à n = 1 000. )}

Cela ressemble à un mélange très intéressant de structure à grande échelle et de chaos à échelle fine. Je me demande ce qui se passe avec les écarts plus larges autour de 30 000 et 60 000.

Java 8, 172 166 163 152 151 151 140 138 116 114 99 octets

s->{for(Integer b=0;b<10&s.length()>1;s=""+b.valueOf(s,b=s.chars().max().getAsInt()-47));return s;}

Prend l'entrée en tant que String.

-64 octets grâce à @ OlivierGrégoire . Et ici, je pensais que mon 172 initial n'était pas trop mauvais ..;)

Essayez ici.

Explication:

s->{                    // Method with String as parameter and return-type
  for(Integer b=0;b<10  //  Loop as long as the largest digit + 1 is not 10
      &s.length()>1;    //  and as long as `s` contains more than 1 digit
    s=""+               //   Replace `s` with the String representation of:
         b.valueOf(s,   //    `s` as a Base-`b` integer
          b=s.chars().max().ge‌tAsInt()-47)
                        //     where `b` is the largest digit in the String + 1
  );                    //  End of loop
  return s;             //  Return result-String
}                       // End of method

Pyth, 9 octets

ui`GhseS`

Suite de tests

Explication:

ui`GhseS`
ui`GhseS`GQ    Implicit variable introduction
u         Q    Repeatedly apply the following function until the value repeats,
               starting with Q, the input.
        `G     Convert the working value to a string.
      eS       Take its maximum.
     s         Convert to an integer.
    h          Add one.
 i`G           Convert the working value to that base

JavaScript (ES6), 63 57 54 53 octets

f=a=>a>9&(b=Math.max(...a+""))<9?f(parseInt(a,b+1)):a

Économisé 8 octets grâce à Shaggy et Dom Hastings

f=a=>a>9&(b=Math.max(...a+""))<9?f(parseInt(a,b+1)):a;

console.log(f("413574"))

Python 3 , 91 78 76 75 73 octets

@ Emigna rasé 5 octets. @FelipeNardiBatista a sauvegardé 1 octet. @ RomanGräf enregistré 2 octets

i=input()
while'9'>max(i)and~-len(i):i=str(int(i,int(max(i))+1))
print(i)

Essayez-le en ligne!

Explication

i=input()                                  - takes input and assigns it to a variable i
while '9'>max(i)and~-len(i):               - repeatedly checks if the number is still base-9 or lower and has a length greater than 1
    i=str(...)                             - assigns i to the string representation of ...
          int(i,int(max(i))+1)             - converts the current number to the real base 10 and loops back again
print(i)                                   - prints the mutated i

05AB1E , 10 5 octets

5 octets sauvés grâce à l' urne magique Octopus

F§Z>ö

Comme cela ralentit très rapidement pour les entrées volumineuses, je laisse ici la version beaucoup plus rapide ici pour les tests. L'algorithme est le même, seul le nombre d'itérations diffère.

[©Z>öD®Q#§

Essayez-le en ligne!

Explication

[             # start a loop
 ©            # store a copy of the current value in the register
  Z>          # get the maximum (digit) and increment
    ö         # convert the current value to base-10 from this base
     D        # duplicate
      ®Q#     # break loop if the new value is the same as the stored value
         §    # convert to string (to prevent Z from taking the maximum int on the stack)

APL (Dyalog) , 20 16 octets

Prend et retourne une chaîne

((⍕⊢⊥⍨1+⌈/)⍎¨)⍣≡

(… )⍣≡ Applique la fonction suivante jusqu'à ce que deux termes consécutifs soient identiques:

 ⍎¨ exécuter chaque caractère (transforme la chaîne en une liste de nombres)

 (… ) Appliquez la fonction tacite suivante à celle-ci:

  ⌈/ trouver le maximum de l'argument

  1+ ajoute un

  ⊢⊥⍨ évaluer l'argument dans cette base

  ⍕ format (stringify, en préparation d'une autre application de la fonction externe)

Essayez-le en ligne!

Ruby , 60 56 octets

->n{n=(s=n.to_s).to_i(s.bytes.max-47)while/9/!~s&&n>9;n}

Essayez-le en ligne!

Mathematica, 52 octets

FromDigits[s=IntegerDigits@#,Max@s+1]&~FixedPoint~#&

Fonction pure prenant un entier non négatif en entrée et renvoyant un entier non négatif. Utilise la même mécanique de base FromDigits[s=IntegerDigits@#,Max@s+1]que la réponse de Jenny_mathy , mais exploite FixedPointpour effectuer l'itération.

Perl 6 , 49 octets

{($_,{.Str.parse-base(1+.comb.max)}...*==*).tail}

Essaye-le

Étendu:

{
  (

    $_,                 # seed the sequence with the input

    {
      .Str
      .parse-base(      # parse in base:
        1 + .comb.max   # largest digit + 1
      )
    }

    ...                 # keep generating values until

    * == *              # two of them match (should only be in base 10)

  ).tail                # get the last value from the sequence
}

PHP , 71 octets

for(;$b<10&9<$n=&$argn;)$n=intval("$n",$b=max(str_split($n))+1);echo$n;

Essayez-le en ligne!

Pip , 17 octets

Wa>9>YMXaaFB:1+ya

Prend l'entrée comme argument de ligne de commande. Essayez-le en ligne!

Explication

C'était amusant - j'ai eu à sortir les opérateurs de comparaison de chaînes.

Nous voulons boucler jusqu'à ce que le nombre soit un chiffre ou OU contient un 9. Équivalemment, nous voulons boucler alors que le nombre est composé de plusieurs chiffres ET ne contient pas un 9. Équivalent, boucler tant que le nombre est supérieur à 9 ET que le chiffre maximum est moins de 9: a>9>MXa.

Wa>9>YMXaaFB:1+ya
                   a is 1st cmdline arg (implicit)
     YMXa          Yank a's maximum digit into the y variable
Wa>9>              While a is greater than 9 and 9 is greater than a's max digit:
         aFB:1+y    Convert a from base 1+y to decimal and assign back to a
                a  At the end of the program, print a

Python 2 , 60 59 56 53 octets

4 octets sauvés grâce à Felipe Nardi Batista
3 octets sauvés grâce à ovs

f=lambda x,y=0:x*(x==y)or f(`int(x,int(max(x))+1)`,x)

Essayez-le en ligne!

En utilisant un lambda récursif, comparant le résultat de la conversion de base à l'itération précédente.

C #, 257 244 243 244 233 222 octets

using System.Linq;z=m=>{int b=int.Parse(m.OrderBy(s=>int.Parse(s+"")).Last()+""),n=0,p=0;if(b<9&m.Length>1){for(int i=m.Length-1;i>=0;i--)n+=int.Parse(m[i]+"")*(int)System.Math.Pow(b+1,p++);return z(n+"");}else return m;};

Bien, C # prend toujours beaucoup d'octets mais c'est juste ridicule. Aucune des fonctions intégrées ne pouvant gérer une base arbitraire, j'ai donc dû calculer la conversion moi-même. Ungolfed:

using System.Linq;
z = m => {
int b = int.Parse(m.OrderBy(s => int.Parse(s + "")).Last()+""), n = 0, p = 0; //Get the max digit in the string
if (b < 9 & m.Length > 1) //if conditions not satisfied, process and recurse
{
    for (int i = m.Length - 1; i >= 0; i--)
        n += int.Parse(m[i] + "") * (int)System.Math.Pow(b+1, p++); //convert each base-b+1 representation to base-10
    return z(n + ""); //recurse
}
else return m; };

Mathematica, 92 octets

f[x_]:=FromDigits[s=IntegerDigits@x,d=Max@s+1];(z=f@#;While[d!=10&&Length@s>1,h=f@z;z=h];z)&

Javascript (ES6) avec fonction de flèche 0, 74 octets

function f(a){a>9&&b=Math.max(...a)<9&&f(parseInt(a,b+1));alert(a)}f('11')

K4 , 19 octets

Solution:

{(1+|/x)/:x:10\:x}/

Exemples:

q)\
  {(1+|/x)/:x:10\:x}/413574
83911
  {(1+|/x)/:x:10\:x}/13552
159
  {(1+|/x)/:x:10\:x}/17
3
  {(1+|/x)/:x:10\:x}/41253
29    

Explication:

Utilisez /:intégré pour convertir la base.

{(1+|/x)/:x:10\:x}/ / the solution
{                }/ / converge lambda, repeat until same result returned
            10\:x   / convert input x to base 10 (.:'$x would do the same)
          x:        / store in variable x
 (     )/:          / convert to base given by the result of the brackets
    |/x             / max (|) over (/) input, ie return largest
  1+                / add 1 to this

Kotlin , 97 octets

fun String.f():String=if(length==1||contains("9"))this else "${toInt(map{it-'0'}.max()!!+1)}".f()

Embellies

fun String.f(): String = if (length == 1 || contains("9")) this else "${toInt(map { it - '0' }.max()!! + 1)}".f()

Tester

fun String.f():String=if(length==1||contains("9"))this else "${toInt(map{it-'0'}.max()!!+1)}".f()
val tests = listOf(
        5 to 5,
        17 to 3,
        999 to 999,
        87654321 to 9041998,
        41253 to 29
)

fun main(args: Array<String>) {
    tests.forEach { (input, output) ->
        val answer = input.toString().f()
        if (answer != output.toString()) {
            throw AssertionError()
        }
    }
}

TIO

TryItOnline

Japt , 25 octets

>9©(A=Uì rw)<9?ßUs nAÄ):U

Essayez-le en ligne!

Gelée , 9 octets

DḅṀ‘$$µÐL

Essayez-le en ligne!

C, 159 157 octets

#include <stdlib.h>
char b[99];i=0;m=-1;c(n){do{m=-1;sprintf(b,"%d",n);i=0;while(b[i]){m=max(b[i]-48,m);i++;}n=strtol(b,0,++m);}while(b[1]&&m<10);return n;}

Scala , 119 octets

if(x.max==57|x.length==1)x else{val l=x.length-1
f((0 to l).map(k=>(((x(k)-48)*math.pow(x.max-47,l-k))) toInt).sum+"")}

Essayez-le en ligne!

Scala , 119 octets

if(x.max==57|x.length==1)x else f((0 to x.length-1).map(k=>(((x(k)-48)*math.pow(x.max-47,x.length-1-k))) toInt).sum+"")

Essayez-le en ligne!

Les deux méthodes fonctionnent de la même manière, mais dans la première, je mets x.length-1une variable et dans la seconde, je ne le fais pas.