14

Un certo numero di linguaggi di programmazione costruisce numeri interi grandi "concatenando" la cifra fino alla fine del numero esistente. Ad esempio, Labyrinth o Adapt . Concatenando la cifra fino alla fine, intendo che, se il numero esistente è $45$ e la cifra è , il numero del risultato è . $7$ $457\:(45 \times 10 + 7)$

Un numero costruito è un numero che può essere costruito in questo modo attraverso l'uso dei multipli di numeri a una cifra: AKA un elemento in una di queste 9 sequenze: $1, 2, 3, 4, 5, 6, 7, 8, 9$

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

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

5, 60, 615, 6170, 61725, ...

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

6, 72, 738, 7404, 74070, ...

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

7, 84, 861, 8638, 86415, ...

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

8, 96, 984, 9872, 98760, ...

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

9, 108, 1107, 11106, 111105, ...

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

Per fornire un esempio di come sono costruite le sequenze, ecco come viene costruita la sequenza per : $a = 3$

\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 un' = & 37020 + 15 & = 37035 \\ u_{6} = & 10 \times u_{5} + 6 \times un' = & 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 un' = & 37 ... 260 + 99 & = 37 ... 359 \\ u_{34} = & 10 \times u_{33} + 34 \times un' = & 37 ... 359 + 102 & = 37 ... 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}$ e inclusi per dimostrare quando . Un sacco di cifre punteggiata fuori per lo spazio. $u_{34}$ $n \times a \ge 100$}

Potrebbe non essere ancora chiaro come siano costruite queste sequenze, quindi ecco due modi diversi per capirle:

Ogni sequenza inizia dalla singola cifra. Il termine successivo viene trovato prendendo il multiplo successivo di quella cifra, moltiplicando il termine precedente per e aggiungendo il multiplo. In termini di sequenza: $10$

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

dove è una singola cifra (da a ) $a$ $1$ $9$

Ognuno dei elementi in qualsiasi punto della sequenza (ad esempio ) sono i multipli di da a , dove è costruito da $9$ $n = 3$ $123\dots$ $1$ $9$ $123\dots$ $u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

Quindi i primi valori sono , i secondi sono , il terzo , ecc. $1 \times 1, 2, 3, \dots, 8, 9$ $12 \times 1, 2, 3, \dots, 8, 9$ $123 \times 1, 2, 3, \dots, 8, 9$

Il tuo compito è prendere un numero costruito come input e produrre la cifra iniziale utilizzata per costruirlo. Puoi presumere che l'input sarà sempre un numero costruito e sarà maggiore di . Può essere una singola cifra, che viene mappata su se stessa. $0$

È possibile accettare input in qualsiasi modo ragionevole, anche come elenco di cifre, come stringa ecc. È accettabile (sebbene non raccomandato) accettare input in modo unario o qualsiasi altra base di propria scelta.

Questo è un code-golf quindi vince il codice più corto!

Casi 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

o come due elenchi:

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

Quando ho pubblicato questa sfida, non mi rendevo conto che potesse essere semplificato così tanto dal metodo utilizzato nella risposta di Grimy , e quindi sarei molto interessato alle risposte che adottano un approccio più matematico per risolvere questo, piuttosto che una "cifra" trucco (ovviamente tutte le risposte valide sono ugualmente valide, proprio quello che mi interesserebbe vedere).

code-golf number sequence

— caird coinheringaahing
fonte

Posta sandbox . Ho una soluzione a 9 byte in Jelly, se qualcuno vuole sfidarlo.

— caird coinheringaahing

26

05AB1E , 7 5 4 byte

>9*н

Provalo online!

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

— Grimmy
fonte

6

Hmm, questo non è di buon auspicio per questa sfida se può essere semplificato così facilmente

— caird coinheringaahing

9

Hai circa 1 byte di codice per 800 byte di spiegazione della sfida. : p

— Arnauld

1

Come trovi la soluzione e perché è corretta?

— Gioele,

7

@Gioca il termine (n-1) della sequenza che inizia con a is a * (((10**n - 1) / 9 - n) / 9). Moltiplicalo per 9 e aggiungi a*n, e otterrai a * ((10**n - 1) / 9), alias il numero, ripetute n volte. Risulta aggiungendo 9 invece di a*nopere per n = 1, e per n maggiore la differenza costante è trascurabile accanto alla crescita esponenziale.

— Grimmy,

3

@Grimy Grazie mille per la spiegazione. Forse puoi metterlo nel tuo post.

— Joel

3

MathGolf , 6 byte

)9*▒├Þ

Provalo online!

Sfortunatamente, non c'è nessuna headoperazione in MathGolf, quindi devo accontentarmi ▒├Þdi convertire in stringa, fare pop da sinistra e scartare tutto tranne lo stack.

— Jo King
fonte

2

Gelatina , 5 byte

‘×9DḢ

Provalo online!

Utilizzando l'approccio di Grimy .

— Erik l'Outgolfer
fonte

2

Stax , 5 byte

^9*Eh

Esegui ed esegui il debug

— Oliver
fonte

2

Japt `-g` , 7 6 5 byte

-1 byte grazie a Shaggy

Accetta l'input come stringa

i°U*9

Provalo | Test di più ingressi

— Oliver
fonte

1

5 byte , prendendo input come stringa.

— Shaggy

2

Carbone , 7 byte

§Ｉ×⁹⊕Ｎ⁰

Provalo online! Il collegamento è alla versione dettagliata del codice. Metodo @ Grimy ovviamente. Ecco un approccio matematico a 27 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Arresti anomali su input non validi. Spiegazione:

Ｎθ

Immettere il numero costruito.

Ｗ¬№Ｅχ×κ↨υχθ

Interpreta l'elenco come numero nella base 10, moltiplica per tutti i numeri da 0a 9e controlla se viene visualizzato il numero costruito.

⊞υＬυ

Spingere la lunghezza della lista su se stessa. L'elenco diventa quindi della forma [0, 1, 2, ..., n].

Ｉ⌕Ｅχ×ι↨υχθ

Ricrea i numeri costruiti ma questa volta trova e visualizza l'indice in cui è apparso il numero di input.

— Neil
fonte

2

Labyrinth , 28 22 20 byte

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

Applica il metodo basato sulle cifre descritto da Grimy ripetendo la divisione di numeri interi per dieci finché non viene trovato zero.

Provalo online!

— Jonathan Allan
fonte

2

Spazio bianco , 108 byte

[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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Porto di @Grimy risposta 05AB1E s' , solo che io non ho un incorporato per ottenere la prima cifra. ;)

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

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
fonte

2

Python 3 , 22 byte

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

Provalo online!

Porto di Grimy 's risposta 05AB1E

Python 3 , 74 byte

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

Provalo online!

Spiegazione

Funzione ricorsiva. Scorre la sequenza per ogni cifra l, iniziando da 1. Se l'ingresso iè uguale all'iterazione corrente j, lviene restituita la cifra corrispondente . Altrimenti, se il valore corrente jnella sequenza supera il valore di input i, aumenterà la cifra le ricomincerà. L'argomento kviene utilizzato per aumentare il fattore di moltiplicazione.

— Jitse
fonte

1

JavaScript (ES6), 16 15 byte

Grazie a @Grimy per aver risolto il vincolo a 32 bit che avevo con la versione precedente.

Usando l'incantesimo magico di Grimy . Accetta l'input come stringa.

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

Provalo online!

JavaScript (ES6), 53 byte

Approccio ingenuo alla forza bruta.

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

Provalo online!

— Arnauld
fonte

-~n*9può essere n*9+9, che è lo stesso bytunt, ma dovrei sbarazzarmi della limitazione a 32 bit se ho capito bene.

— Grimmy,

la forza bruta lavora per un> = 10, come14808

— Nahuel Fouilleul il

1

@NahuelFouilleul se consideriamo a> = 10, la risposta non è più unica (14808 potrebbe essere il 4 ° termine di a = 12 o il primo termine di a = 14808). Se l'output di uno di questi è consentito, n=>nfunziona per tutti gli input.

— Grimmy,

1

Java 8, 23 byte

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

Porto di @Grimy 's risposta 05AB1E , quindi assicuratevi di upvote lui!

Provalo online.

Ma poiché mi sento un po 'male per @cairdCoinheringaahing , qui un approccio a forza bruta con un po' più economico ( 83 byte ):

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

Provalo online.

Spiegazione:

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
fonte

0

PHP , 20 byte

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

Provalo online!

Ancora un'altra porta di risposta di Grimy !

— night2
fonte

0

Gelatina , 8 byte

RRḌ÷@fⱮ9

Provalo online!

Un programma completo che accetta un numero intero e stampa la cifra iniziale. Non usa il metodo intelligente di Grimy! Terribilmente inefficiente per input più grandi. La seguente versione gestisce tutti i casi di test ma è un byte più lungo:

Gelatina , 9 byte

DJRḌ÷@fⱮ9

Provalo online!

— Nick Kennedy
fonte

0

Hy , 44 byte

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

Usa il metodo di Grimy

Provalo online!

— girobuz
fonte

0

Keg `-rr` , 4 byte

⑨9*÷

Provalo online!

Naturalmente, utilizza lo stesso approccio della risposta 05AB1E. Utilizza anche il nuovo -rrflag (reverse e print raw).

Transpiles a:

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
fonte

0

Scricciolo , 30 byte

Solo un porto con la maggior parte delle risposte.

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

Provalo online!

— un'_'
fonte

Cos'è l'antipasto di questo numero costruito?

Casi test

05AB1E , 7 5 4 byte

MathGolf , 6 byte

Gelatina , 5 byte

Stax , 5 byte

Japt -g , 7 6 5 byte

Carbone , 7 byte

Labyrinth , 28 22 20 byte

Spazio bianco , 108 byte

Python 3 , 22 byte

Python 3 , 74 byte

Spiegazione

JavaScript (ES6), 16 15 byte

JavaScript (ES6), 53 byte

Java 8, 23 byte

PHP , 20 byte

Gelatina , 8 byte

Gelatina , 9 byte

Hy , 44 byte

Keg -rr , 4 byte

Scricciolo , 30 byte

Japt `-g` , 7 6 5 byte

Keg `-rr` , 4 byte