La meilleure base est 10… atteignons-la!

40

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)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 .

Stewie Griffin
la source
2
Apparemment, j'adore les matrices , alors j'ai pensé faire un défi de conversion de base à la place.
Stewie Griffin
34
"La meilleure base est 10" ... "10" est écrit dans quelle base?
Olivier Grégoire
5
@ OlivierGrégoire C'est la chose intelligente ... Quelle que soit la base, ce sera toujours une déclaration valable!
Stewie Griffin
@StewieGriffin Mais comment le lisez-vous? "10" a un nom différent dans chaque base.
user11153
10
Eh bien, cela dépend de la base ... ou comme dirait Meghan, "tout tourne autour de cette base, 'Bout cette base, pas de problème" ;-)
Stewie Griffin Le

Réponses:

20

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:

enter image description here

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

enter image description here

(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.

Martin Ender
la source
4
@StewieGriffin devrait être sur le côté gauche. Les petits écarts sont là, car les nombres menant à un multiple d'une puissance de 10 contiennent un 9, alors ils sont déjà en base 10. Mais pour 30k et 60k il semble que les nombres avec un 8 ou même 7 (devraient vérifier) ​​au lieu de cela 9 deviennent toujours la base 10 après au plus un pas.
Martin Ender
@StewieGriffin Pour être précis, tous les nombres de la plage [28051, 28888] sont en base 9 et traduisent en nombres de la forme 19xxx, doublant ainsi à peu près cet écart.
cmaster
Ah, j'ai compris ... :) Pour mémoire: je savais pourquoi il y avait des trous à gauche des puissances de 10 ... Ce n'étaient que les trous à double dimension qui étaient étranges (pourquoi 30/60, et non 20 / 40/50). Je vois maintenant que les nombres dans la plage 28xxx -> 19xxx, mais 38xxx -> 26xxx, pas 29xxx.
Stewie Griffin
10

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().getAsInt()-47)
                        //     where `b` is the largest digit in the String + 1
  );                    //  End of loop
  return s;             //  Return result-String
}                       // End of method
Kevin Cruijssen
la source
1
Promettre de rester calme? : p Ok ... allons-y: s->{for(Integer b=0;b<10&s.length()>1;)s=""+b.valueOf(s,b=s.chars().max().getAsInt()-47);return s;}. De plus, j'ai supprimé la plupart de mes commentaires car ils sont totalement hors de propos maintenant ( bc'est la base, votre a; et sle nombre sur lequel nous travaillons).
Olivier Grégoire Le
1
J'ai essayé de récursiver cette opération pour supprimer quelques octets avec: Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:c(""+b.valueOf(s,b));(88), mais je suis novice en matière de codage golf. Ceci est un extrait, non? Y at-il un moyen de déclarer cela comme une méthode sans avoir à ajouter public String c(String s)?
Lord Farquaad
1
@ LordFarquaad Vous n'avez pas besoin de public, mais je crains que vous n'ayez vraiment à utiliser String c(String s){}pour les appels récursifs, même en Java 8. Lorsque vous créez un lambda à l'aide d' java.util.function.Function<String, String> c=s->{Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:c‌.apply​(""+b.valueOf(s,b));}une interface, vous obtenez interface N{String c(String s);}N n = s->{Integer b;return(b=s.chars().max().getAsInt()-47)>9|s.length()<2?s:n.c‌​(""+b.valueOf(s,b));};une " auto-référence dans l'initialiseur erreur "dans les deux cas. Mais très belle approche quand même!
Kevin Cruijssen
Ah, je suppose que je l'ai dégolfé quelques octets alors. Mais merci pour l'aide! Je garderai cela à l'esprit à l'avenir.
Lord Farquaad
8

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
isaacg
la source
C'est un peu bizarre de voir comment vous avez utilisé un lambda à deux variables, en fin de compte, en utilisant une seule variable ... et cela n'a pas jeté d'erreur (s). Oh, les deux variables sont Qet Q, je comprends.
Erik l'Outgolfer
@EriktheOutgolfer Pas exactement. usans que sa troisième entrée soit appliquée jusqu'à la répétition, alors qu'avec une troisième entrée, elle s'applique un nombre de fois déterminé. uLambda a Get H, mais vous n'avez pas besoin de l'utiliser H.
isaacg
En fait, remplacer Gpar Haurait eu le même résultat ... la variable implicite btw est G?
Erik l'Outgolfer
@EriktheOutgolfer La variable implicite est Goui. Hcompte à partir de 0 à chaque itération, donc c'est complètement différent. Je ne sais pas vraiment de quoi vous parlez. Voici un exemple de programme pour vous montrer ce qui se passe: pyth.herokuapp.com/…
isaacg Le
6

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

À M
la source
Me battre à elle. Je pense que vous pourriez économiser quelques octets avec +a>9||b<9et inverser le ternaire.
Shaggy
1
@Shaggy edit: Je suis idiot
Tom le
1
Ne sois pas si dur avec toi-même Tom! Vous n'êtes pas stupide ", mais vous n'êtes certainement pas aussi intelligent que @Shaggy!
Stewie Griffin
1
Alternative pour 55 octetsf=n=>n>9&&(k=Math.max(...n+"")+1)<10?f(parseInt(n,k)):n
Dom Hastings le
@DomHastings Merci pour les améliorations! :)
Tom
5

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
M. Xcoder
la source
5

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)
Emigna
la source
Aussi, ne pouvez-vous pas simplement utiliser тFZ>ö§? Vu que le nombre d'itérations ( comme on le voit ici ) semble plafonner? Si vous voulez être technique, le taux d'augmentation des itérations est probablement logarithmique ... Vous pouvez donc utiliser quelque chose du type: DFZ>ö§et indiquez que cela ne fonctionnera pas trop cher n. OU peut-être même: T.n>FZ>ö§calculer directement le nombre d'itérations sous la forme log_10(n).
Urne Magique Octopus
@MagicOctopusUrn: Ouais, maintenant que vous en parlez, la séquence semble définitivement plus lente que linéaire, F§Z>ödevrait faire l'affaire.
Emigna
Je pense que vous pouvez enlever le §.
Erik l'Outgolfer
@EriktheOutgolfer: Malheureusement non. Si nous supprimons le §, Zprendra le nombre le plus élevé de la pile au lieu du chiffre le plus élevé du nombre situé en haut de la pile.
Emigna
@ Emigna Hein?
Erik the Outgolfer
3

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!

Adam
la source
3

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!

Valeur d'encre
la source
3

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.

Greg Martin
la source
3

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
}
Brad Gilbert b2gills
la source
2

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
DLosc
la source
2

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.

Emigna
la source
pourquoi ne pas utiliser x==y and x or ...ce xqui ne sera jamais 0(base 1). ou même(x==y)*x or ...
Felipe Nardi Batista le
@ FelipeNardiBatista: Merci! J'ai essayé x and x==y or ...qui n'a pas fonctionné, mais je ne maîtrise pas très bien ces astuces et je ne savais donc pas que je pouvais l'inverser :)
Emigna
@ovs: Vous avez raison. Merci!
Emigna
@FelipeNardiBatista "Entrée: Un entier positif n composé de chiffres compris entre 0 et 9." 0 est toujours une entrée valide, et maintenant le code la rejette.
Mât
@Mast: Heureusement pour nous, 0 n'est pas un entier positif, il ne sera donc pas donné en entrée.
Emigna
2

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; };
Ceshion
la source
1

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)&
J42161217
la source
1

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')
utilisateur71507
la source
3
Bienvenue chez PPCG! :) C'est probablement une très bonne réponse, mais je ne peux pas le dire sans une explication. Moi (et probablement d’autres) ne lève jamais les réponses sans explications.
Stewie Griffin
1
Pourquoi appelez-vous f('11')après la fonction? À moins que je manque quelque chose qui semble seulement être l'utilisation ne fait pas réellement partie de la soumission. Si tel est le cas, supprimez-le de la section de code et mettez-le dans votre explication (lorsque vous en ajoutez un) et mettez à jour votre nombre d'octets à 67.
PunPun1000 Le
1

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
streetster
la source
1

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

jrtapsell
la source
0

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;}
Govind Parmar
la source
0

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.

V. Courtois
la source