Quel est le démarreur de ce numéro construit?


14

Un certain nombre de langages de programmation construisent de grands entiers en «concaténant» le chiffre à la fin du nombre existant. Par exemple, Labyrinth ou Adapt . En concaténant le chiffre jusqu'à la fin, je veux dire que si le nombre existant est 45 et que le chiffre est 7 , le nombre résultat est 457(45×10+7) .

Un nombre construit est un nombre qui peut être construit de cette façon en utilisant les multiples de nombres à un chiffre: 1,2,3,4,5,6,7,8,9 AKA un élément dans l'une de ces 9 séquences:

1,12,123,1234,12345,
2,24,246,2468,24690,
3,36,369,3702,37035,
4,48,492,4936,49380,
5,60,615,6170,61725,
6,72,738,7404,74070,
7,84,861,8638,86415,
8,96,984,9872,98760,
9,108,1107,11106,111105,

Pour fournir un exemple de la façon dont les séquences sont construites, voici comment la séquence pour a=3 construite:

u1=a=3=3u2=10×u1+2×a=30+6=36u3=10×u2+3×a=360+9=369u4=10×u3+4×a=3690+12=3702u5=10×u4+5×a=37020+15=37035u6=10×u5+6×a=370350+18=370368
u33=10×u32+33×a=37260+99=37359u34=10×u33+34×a=37359+102=373692

u33 etu34 inclus pour démontrer quandn×a100 . Ungrand nombrede chiffrespointillés pourespace.

La façon dont ces séquences sont construites n'est peut-être pas encore claire, alors voici deux façons différentes de les comprendre:

  • Chaque séquence commence à partir du seul chiffre. Le terme suivant est trouvé en prenant le multiple suivant de ce chiffre, en multipliant le terme précédent par 10 et en ajoutant le multiple. En termes de séquence:

    un=10×un1+n×a,u1=a

    a est un seul chiffre ( 1 à 9 )


  • Chacun des 9 éléments à n'importe quel point de la séquence (prenez n=3 par exemple) sont les multiples de 123 de 1 à 9 , où 123 est construit par un+1=10×un+n (1,12,123,,123456789,1234567900,12345679011,)

    Ainsi, les premières valeurs sont 1×1,2,3,,8,9 , les secondes sont 12×1,2,3,,8,9 , la troisième 123×1,2,3,,8,9 , etc.

Votre tâche consiste à prendre un nombre construit en entrée et à sortir le chiffre initial utilisé pour le construire. Vous pouvez supposer que l'entrée sera toujours un nombre construit et sera supérieure à 0 . Il peut s'agir d'un seul chiffre, qui correspond à lui-même.

Vous pouvez saisir des données de toute manière raisonnable, y compris sous forme de liste de chiffres, sous forme de chaîne, etc. Il est acceptable (mais non recommandé) de saisir des données de manière unaire ou dans toute autre base de votre choix.

C'est un donc le code le plus court gagne!

Cas de test

       u_n        => a
 37035            => 3
 6172839506165    => 5
 5                => 5
 246913580244     => 2
 987654312        => 8
 61728395061720   => 5
 1111104          => 9
 11111103         => 9
 111111102        => 9
 2469134          => 2
 98760            => 8
 8641975308641962 => 7

ou en deux listes:

[37035, 6172839506165, 5, 246913580244, 987654312, 61728395061720, 1111104, 11111103, 111111102, 2469134, 98760, 8641975308641962]
[3, 5, 5, 2, 8, 5, 9, 9, 9, 2, 8, 7]

Lorsque j'ai publié ce défi, je ne savais pas qu'il pouvait être tellement simplifié par la méthode utilisée dans la réponse de Grimy , et donc je serais très intéressé par les réponses qui adoptent une approche plus mathématique pour résoudre ce problème, plutôt que par un `` chiffre '' astuce (Évidemment, toutes les réponses valides sont également valables, juste ce que je serais intéressé de voir).


Poteau de bac à sable . J'ai une solution de 9 octets dans Jelly, si quelqu'un veut contester cela.
caird coinheringaahing

Réponses:


26

05AB1E , 7 5 4 octets

>9*н

Essayez-le en ligne!

>            # input + 1
 9*          # * 9
   н         # take the first digit

6
Hmm, cela n'augure rien de bon pour ce défi s'il peut être simplifié aussi facilement
Cairn Coinheringaahing

9
Vous disposez d'environ 1 octet de code pour 800 octets d'explication de défi. : p
Arnauld

1
Comment trouvez-vous la solution et pourquoi est-elle correcte?
Joel

7
@Joel le (n-1) ème terme de la séquence commençant par a is a * (((10**n - 1) / 9 - n) / 9). Multipliez cela par 9 et ajoutez a*n, et vous obtenez a * ((10**n - 1) / 9), alias le chiffre répété n fois. Il s'avère que l'ajout de 9 au lieu de a*nfonctionne pour n = 1, et pour n plus grand, la différence constante est négligeable à côté de la croissance exponentielle.
Grimmy

3
@Grimy Merci beaucoup pour l'explication. Vous pouvez peut-être le mettre dans votre message.
Joel

3

MathGolf , 6 octets

)9*▒├Þ

Essayez-le en ligne!

Malheureusement, il n'y a aucune headopération dans MathGolf, donc je dois me contenter ▒├Þde convertir en chaîne, de sauter à partir de la gauche et de jeter tout sauf le haut de la pile.





2

Fusain , 7 octets

§I×⁹⊕N⁰

Essayez-le en ligne! Le lien est vers la version détaillée du code. @ La méthode de Grimy bien sûr. Voici une approche mathématique de 27 octets:

NθW¬№Eχ×κ↨υχθ⊞υLυI⌕Eχ×ι↨υχθ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Plantage sur des entrées invalides. Explication:

Nθ

Saisissez le nombre construit.

W¬№Eχ×κ↨υχθ

Interprétez la liste comme un nombre en base 10, multipliez par tous les nombres de 0à 9et voyez si le nombre construit apparaît.

⊞υLυ

Poussez la longueur de la liste sur elle-même. La liste devient donc du formulaire [0, 1, 2, ..., n].

I⌕Eχ×ι↨υχθ

Recréez les nombres construits mais cette fois trouvez et sortez l'index auquel le numéro d'entrée est apparu.



2

Espace , 108 octets

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S S S T    N
_Push_1][T  S S S _Add][S S S T S S T   N
_Push_9][T  S S N
_Multiply][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP][S S S T S T S N
_Push_10][T S S N
_Multiply][S N
S _Duplicate][S T   S S S T S N
_Copy_0-based_2nd]S N
T   Swap_top_two][T S S T   _Subtract][N
T   T   S N
_If_neg_jump_to_Label_PRINT][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    S T S N
_Push_10][T S T S _Integer_divide][T    S T S _Integer_divide][T    N
S T _Output_top_as_number]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Port de @Grimy réponse 05AB1E de , sauf que je n'ai pas builtin pour obtenir le premier chiffre. ;)

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Explication en pseudo-code:

Integer i = STDIN as integer
i = i + 1
i = i * 9
Integer t = 1
Start LOOP:
  t = t * 10
  If(i - t < 0):
    Call function PRINT
  Go to next iteration of LOOP

function PRINT:
  t = t / 10
  i = i / t    (NOTE: Whitespace only has integer-division)
  Print i as integer to STDOUT

2

Python 3 , 22 octets

lambda i:str(-~i*9)[0]

Essayez-le en ligne!

Port de Grimy de réponse 05AB1E


Python 3 , 74 octets

f=lambda i,j=1,k=2,l=1:l*(i==j)or f(i,*(10*j+k*l,l+1,k+1,2,l,l+1)[i<j::2])

Essayez-le en ligne!

Explication

Fonction récursive. Itère sur la séquence de chaque chiffre l, en commençant par 1. Si l'entrée iest égale à l'itération en cours j, le chiffre correspondant lest renvoyé. Sinon, si la valeur actuelle jde la séquence dépasse la valeur d'entrée i, elle incrémentera le chiffre let recommencera. L'argument kest utilisé pour incrémenter le facteur de multiplication.


1

JavaScript (ES6),  16  15 octets

Merci à @Grimy d'avoir levé la contrainte 32 bits que j'avais avec la version précédente.

Utilisation de l'incantation magique de Grimy . Prend l'entrée sous forme de chaîne.

n=>(n*9+9+n)[0]

Essayez-le en ligne!


JavaScript (ES6), 53 octets

Approche par force brute naïve.

n=>(g=(k,x=i=0)=>x>n?g(k+1):x<n?g(k,++i*k+10*x):k)(1)

Essayez-le en ligne!


-~n*9peut être n*9+9, ce qui est le même bytecount mais devrait se débarrasser de la limitation 32 bits si j'ai bien compris.
Grimmy

la force brute fonctionne pour un> = 10, comme14808
Nahuel Fouilleul

1
@NahuelFouilleul si l'on considère a> = 10, la réponse n'est plus unique (14808 pourrait être soit le 4ème terme de a = 12, soit le premier terme de a = 14808). Si la sortie de l'un de ceux-ci est autorisée, n=>nfonctionne pour toutes les entrées.
Grimmy

1

Java 8, 23 octets

n->(n*9+9+"").charAt(0)

Port de @Grimy réponse 05AB1E de , alors assurez - vous de le upvote!

Essayez-le en ligne.

Mais parce que je me sens un peu mal pour @cairdCoinheringaahing , voici une approche par force brute avec un peu plus de moyens ( 83 octets ):

n->{long r=n,a=0,u,k;for(;++a<10;r=u>n?r:a)for(k=2,u=a;u<n;)u=u*10+k++*a;return r;}

Essayez-le en ligne.

Explication:

n->{                 // Method with long as both parameter and return-type
  long r=n,          //  Result, starting at the input in case it's already a single digit
       a=0,          //  The digit to start the sequence with
       u,            //  The last number of the sequence we're building for digit a
       k;            //  Multiplier which increments each iteration
  for(;++a<10;       //  Loop in the range [1,9] (over each digit):
      r=u>n?         //    After ever iteration: if `u` is larger than the input:
            r        //     Keep the result the same
           :         //    Else:
            a)       //     Change the result to `a`
    for(k=2,         //   Reset `k` to 2
        u=a;         //   Reset `u` to the current digit `a`
        u<n;)        //   Inner loop as long as `u` is smaller than the input
      u=             //    Change `u` to:
        u*10         //     10 times the current `u`
            +k++*a;  //     With `k` multiplied by `a` added
                     //     (after which `k` increases by 1 with `k++`)
  return r;}         //  And after we iterated over each digit, return the result


0

Gelée , 8 octets

RRḌ÷@fⱮ9

Essayez-le en ligne!

Un programme complet qui prend un entier et imprime le chiffre de démarrage. N'utilise pas la méthode intelligente de Grimy! Terriblement inefficace pour une plus grande entrée. La version suivante gère tous les cas de test mais est un octet plus long:

Gelée , 9 octets

DJRḌ÷@fⱮ9

Essayez-le en ligne!



0

Keg -rr , 4 octets

⑨9*÷

Essayez-le en ligne!

Bien sûr, utilise la même approche que la réponse 05AB1E. Utilise également le nouveau-rr drapeau (inverser et imprimer brut).

Transpile vers:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
increment(stack)
integer(stack, 9)
maths(stack, '*')
item_split(stack)
if not printed:
    reverse(stack)
    raw(stack)

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.