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 \times 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, \dots

$1, 12, 123, 1234, 12345, \: \dots$

2, 24, 246, 2468, 24690, \dots

$2, 24, 246, 2468, 24690, \: \dots$

3, 36, 369, 3702, 37035, \dots

$3, 36, 369, 3702, 37035, \: \dots$

4, 48, 492, 4936, 49380, \dots

$4, 48, 492, 4936, 49380, \: \dots$

5, 60, 615, 6170, 61725, \dots

$5, 60, 615, 6170, 61725, \: \dots$

6, 72, 738, 7404, 74070, \dots

$6, 72, 738, 7404, 74070, \: \dots$

7, 84, 861, 8638, 86415, \dots

$7, 84, 861, 8638, 86415, \: \dots$

8, 96, 984, 9872, 98760, \dots

$8, 96, 984, 9872, 98760, \: \dots$

9, 108, 1107, 11106, 111105, \dots

$9, 108, 1107, 11106, 111105, \: \dots$

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

\begin{aligned} u_{1} = & a = & 3 & = 3 \\ u_{2} = & 10 \times u_{1} + 2 \times a = & 30 + 6 & = 36 \\ u_{3} = & 10 \times u_{2} + 3 \times a = & 360 + 9 & = 369 \\ u_{4} = & 10 \times u_{3} + 4 \times a = & 3690 + 12 & = 3702 \\ u_{5} = & 10 \times u_{4} + 5 \times a = & 37020 + 15 & = 37035 \\ u_{6} = & 10 \times u_{5} + 6 \times a = & 370350 + 18 & = 370368 \end{aligned}

$\begin{align} u_1 = && a = && 3 & = 3\\ u_2 = && 10 \times u_1 + 2 \times a = && 30 + 6 & = 36 \\ u_3 = && 10 \times u_2 + 3 \times a = && 360 + 9 & = 369 \\ u_4 = && 10 \times u_3 + 4 \times a = && 3690 + 12 & = 3702 \\ u_5 = && 10 \times u_4 + 5 \times a = && 37020 + 15 & = 37035 \\ u_6 = && 10 \times u_5 + 6 \times a = && 370350 + 18 & = 370368 \\ \end{align}$

⋮

$\vdots$

\begin{aligned} u_{33} = & 10 \times u_{32} + 33 \times a = & 37 \dots 260 + 99 & = 37 \dots 359 \\ u_{34} = & 10 \times u_{33} + 34 \times a = & 37 \dots 359 + 102 & = 37 \dots 3692 \end{aligned}

$\begin{align} u_{33} = && 10 \times u_{32} + 33 \times a = && 37\dots260 + 99 & = 37\dots359 \\ u_{34} = && 10 \times u_{33} + 34 \times a = && 37\dots359 + 102 & = 37\dots3692 \end{align}$

⋮

$\vdots$

_{$u_{33}$ et $u_{34}$ inclus pour démontrer quand $n \times a \ge 100$ . 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:

$u_{n} = 10 \times u_{n - 1} + n \times a, u_{1} = a$ $u_n = 10 \times u_{n-1} + n \times a, \: \: u_1 = a$

où $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\dots$ de $1$ à $9$ , où $123\dots$ est construit par $u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

Ainsi, les premières valeurs sont $1 \times 1, 2, 3, \dots, 8, 9$ , les secondes sont $12 \times 1, 2, 3, \dots, 8, 9$ , la troisième $123 \times 1, 2, 3, \dots, 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 code-golf 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).

code-golf number sequence caird coinheringaahing
la source

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

caird coinheringaahing

26

05AB1E , 7 5 4 octets

>9*н

Essayez-le en ligne!

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

Grimmy
la source

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.

Jo King
la source

2

Gelée , 5 octets

‘×9DḢ

Essayez-le en ligne!

En utilisant l'approche de Grimy .

Erik le Outgolfer
la source

2

Stax , 5 octets

^9*Eh

Exécuter et déboguer

Oliver
la source

2

Japt `-g` , 7 6 5 octets

-1 octet grâce à Shaggy

Prend l'entrée sous forme de chaîne

i°U*9

Essayez-le | Testez plusieurs entrées

Oliver
la source

1

5 octets , en prenant l'entrée comme une chaîne.

Shaggy

2

Fusain , 7 octets

§Ｉ×⁹⊕Ｎ⁰

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:

ＮθＷ¬№Ｅχ×κ↨υχθ⊞υＬυＩ⌕Ｅχ×ι↨υχθ

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

Ｎθ

Saisissez le nombre construit.

Ｗ¬№Ｅχ×κ↨υχθ

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.

⊞υＬυ

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

Ｉ⌕Ｅχ×ι↨υχθ

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

Neil
la source

2

Labyrinthe , 28 22 20 octets

9 10/;!@
? _ :
)*"""

Applique la méthode basée sur les chiffres décrite par Grimy par division d'entier répétée par dix jusqu'à ce que zéro soit trouvé.

Essayez-le en ligne!

Jonathan Allan
la source

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

Kevin Cruijssen
la source

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.

Jitse
la source

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!

Arnauld
la source

-~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

Kevin Cruijssen
la source

0

PHP , 20 octets

<?=(_.++$argn*9)[1];

Essayez-le en ligne!

Encore un autre port de réponse de Grimy !

Nuit2
la source

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!

Nick Kennedy
la source

0

Hy , 44 octets

(defn a[p](print(get(str(*(+(int p)1)9))0)))

Utilise la méthode de Grimy

Essayez-le en ligne!

Girobuz
la source

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)

Lyxal
la source

0

Troglodyte , 30 octets

Juste un port de la plupart des réponses.

Fn.new{|i|(i*9+9).toString[0]}

Essayez-le en ligne!

la source

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

Cas de test

Réponses:

05AB1E , 7 5 4 octets

MathGolf , 6 octets

Gelée , 5 octets

Stax , 5 octets

Japt `-g` , 7 6 5 octets

Fusain , 7 octets

Labyrinthe , 28 22 20 octets

Espace , 108 octets

Python 3 , 22 octets

Python 3 , 74 octets

Explication

JavaScript (ES6), 16 15 octets

JavaScript (ES6), 53 octets

Java 8, 23 octets

PHP , 20 octets

Gelée , 8 octets

Gelée , 9 octets

Hy , 44 octets

Keg `-rr` , 4 octets

Troglodyte , 30 octets

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

Cas de test

Réponses:

05AB1E , 7 5 4 octets

MathGolf , 6 octets

Gelée , 5 octets

Stax , 5 octets

Japt -g , 7 6 5 octets

Fusain , 7 octets

Labyrinthe , 28 22 20 octets

Espace , 108 octets

Python 3 , 22 octets

Python 3 , 74 octets

Explication

JavaScript (ES6), 16 15 octets

JavaScript (ES6), 53 octets

Java 8, 23 octets

PHP , 20 octets

Gelée , 8 octets

Gelée , 9 octets

Hy , 44 octets

Keg -rr , 4 octets

Troglodyte , 30 octets

Japt `-g` , 7 6 5 octets

Keg `-rr` , 4 octets