Ingresso:

Un numero intero positivo n costituito da cifre nell'intervallo 0-9 .

Sfida:

Se d è la cifra più alta nell'intero, supponiamo che la base del numero sia d + 1 . Ad esempio, se il numero intero è 1256 , supponiamo che sia in base-7 , se è 10110, allora devi assumere che è base-2 (binario), e se è 159 allora è decimale.

Ora, procedi come segue fino a quando: 1: raggiungi un numero intero di base 10 o 2: raggiungi un numero intero a una cifra.

1. Convertire il numero intero da base- (d + 1) a base-10
2. Trova la base di questo nuovo numero intero (di nuovo, base- (d + 1) dove d è la cifra più alta nel nuovo numero)
3. Vai al passaggio 1 .

Esempi:

Supponiamo che l'input sia n = 413574 . La cifra più alta d = 7 , quindi questa è base-8 (ottale). Convertire questo in decimale e ottenere 137084 . La cifra più alta d = 8 , quindi questa è base-9 . Converti questo in decimale e ottieni 83911 . La cifra più alta è 9 , quindi questo è un numero decimale e ci fermiamo. L'output deve essere 83911 .

Supponiamo che l'ingresso sia n = 13552 . La cifra più alta è d = 5 , quindi questa è base-6 . Converti questo in decimale e ottieni 2156 . La cifra più alta d = 6 , quindi questa è base-7 . Converti questo in decimale e ottieni 776 . La cifra più alta è d = 7 , quindi questa è base-8 . Converti questo in decimale e ottieni 510 . La cifra più alta è d = 5, quindi questa è base-6 . Converti questo in decimale e ottieni 186 . La cifra più alta è 8 , quindi questa è base-9 . Converti questo in decimale e ottieni 159. La cifra più alta è 9 , quindi questo è un numero decimale e ci fermiamo. L'output deve essere 159 .

Supponiamo che l'ingresso sia n = 17 . Questo ci darà 15 , quindi 11 , quindi 3 , che emetteremo poiché è una singola cifra.

Casi 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

Gli appunti:

• Regole standard relative a I / O, scappatoie, ecc. È possibile prendere l'input come stringa
• Le spiegazioni sono incoraggiate
• È possibile utilizzare i comandi di conversione di base incorporati
  • Le soluzioni che non utilizzano le funzioni di conversione base incorporate del linguaggio (se esistono) sono benvenute, anche se finiscono per essere molto più lunghe dell'approccio ovvio che utilizza le funzioni integrate.

Apparentemente, questo è OEIS A091047 .

Mathematica, 56 byte

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

Provalo online! (Usando la matematica.)

Ho pensato di dare un'occhiata a come appare la sequenza:

Ed ecco un grafico del numero di passaggi necessari per trovare il risultato:

^{(Fare clic per versioni più grandi. Vedere la cronologia delle revisioni per i grafici solo fino a n = 1000. )}

Sembra una miscela molto interessante di struttura su larga scala e caos su scala fine. Mi chiedo che succede con le lacune più ampie intorno a 30.000 e 60.000.

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

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

Prende l'input come a String.

-64 byte grazie a @ OlivierGrégoire . E qui ho pensato che il mio 172 iniziale non fosse troppo male ..;)

Provalo qui.

Spiegazione:

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 byte

ui`GhseS`

Suite di test

Spiegazione:

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 byte

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

Risparmiato 8 byte grazie a Shaggy e 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 byte

@Emigna rasata di 5 byte. @FelipeNardiBatista ha salvato 1 byte. @ RomanGräf ha salvato 2 byte

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

Provalo online!

Spiegazione

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 byte

5 byte salvati grazie a Magic Octopus Urn

F§Z>ö

Dato che questo rallenta molto rapidamente per input di grandi dimensioni, lascio qui la vecchia versione molto più veloce per i test. L'algoritmo è lo stesso, solo il numero di iterazioni differisce.

[©Z>öD®Q#§

Provalo online!

Spiegazione

[             # 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 byte

Prende e restituisce una stringa

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

(... )⍣≡ applica la seguente funzione fino a quando due termini consecutivi sono identici:

 ⍎¨ esegue ogni carattere (trasforma la stringa in un elenco di numeri)

 (... ) applica la seguente funzione tacita a quella:

  ⌈/ trova il massimo dell'argomento

  1+ Aggiungi uno

  ⊢⊥⍨ valutare l'argomento in quella base

  ⍕ format (stringify, in preparazione per un'altra applicazione della funzione esterna)

Provalo online!

Rubino , 60 56 byte

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

Provalo online!

Mathematica, 52 byte

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

Funzione pura che accetta come input un numero intero non negativo e restituisce un numero intero non negativo. Utilizza la stessa meccanica FromDigits[s=IntegerDigits@#,Max@s+1]di base della risposta di Jenny_mathy , ma sfrutta FixedPointper eseguire l'iterazione.

Perl 6 , 49 byte

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

Provalo

Allargato:

{
  (

    $_,                 # 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 byte

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

Provalo online!

Pip , 17 byte

Wa>9>YMXaaFB:1+ya

Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

È stato divertente - ho dovuto estrarre gli operatori di confronto concatenati.

Vogliamo fare un ciclo fino a quando il numero è una singola cifra O contiene un 9. Equivalentemente, vogliamo fare un ciclo mentre il numero è composto da più cifre E non contiene un 9. Equivalentemente, un ciclo mentre il numero è maggiore di 9 E la cifra massima è meno di 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 byte

Salvato 4 byte grazie a Felipe Nardi Batista
Salvato 3 byte grazie a ovs

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

Provalo online!

Utilizzando un lambda ricorsivo, confrontando il risultato della conversione di base con l'iterazione precedente.

C #, 257 244 243 244 233 222 byte

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;};

Well, C# always takes a lot of bytes but this is just ridiculous. None of the built-ins can handle an arbitrary base, so I had to calculate the conversion myself. 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 bytes

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) with 0 arrow function, 74 bytes

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

K4, 19 bytes

Solution:

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

Examples:

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    

Explanation:

Use /: built-in to convert 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 bytes

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

Beautified

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

Test

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 bytes

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

Try it online!

Jelly, 9 bytes

DḅṀ‘$$µÐL

Try it online!

C, 159 157 bytes

#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 bytes

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+"")}

Try it online!

Scala, 119 bytes

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+"")

Try it online!

Both methods work the same way, but in the first one I put x.length-1 in a variable, and in the second one I don't.