Várias linguagens de programação constroem números inteiros grandes 'concatenando' o dígito até o final do número existente. Por exemplo, Labirinto ou Adapt . Concatenando o dígito até o final, quero dizer que, se o número existente for $45$ e o dígito for $7$ , o número do resultado será $457\:(45 \times 10 + 7)$ .

Um número construído é um número que pode ser construído dessa maneira através do uso de múltiplos de números de um dígito: $1, 2, 3, 4, 5, 6, 7, 8, 9$ AKA um elemento em uma destas 9 sequências:

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

Para fornecer um exemplo de como as seqüências são construídas, veja como a sequência de $a = 3$ construída:

$$\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{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$u_{34}$ incluídos para demonstrar quando$n \times a \ge 100$ . Ummontede dígitos pontilhada para fora para o espaço.}

Ainda não está claro como essas seqüências são construídas; portanto, existem duas maneiras diferentes de entendê-las:

• Cada sequência começa no dígito único. O próximo termo é encontrado pegando o próximo múltiplo desse dígito, multiplicando o termo anterior por $10$ e adicionando o múltiplo. Em termos de sequência:

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

  onde $a$ é um único dígito ( $1$ a $9$ )

• Cada um dos $9$ elementos em qualquer ponto da sequência ( por exemplo, $n = 3$ ) são múltiplos de $123\dots$ de $1$ a $9$ , em que $123\dots$ é construído por $u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

  Portanto, os primeiros valores são $1 \times 1, 2, 3, \dots, 8, 9$ , o segundo é $12 \times 1, 2, 3, \dots, 8, 9$ , o terceiro $123 \times 1, 2, 3, \dots, 8, 9$ , etc.

Sua tarefa é pegar um número construído como entrada e gerar o dígito inicial usado para construí-lo. Você pode assumir que a entrada sempre será um número construído e será maior que $0$ . Pode ser um dígito, que mapeia de volta para si mesmo.

Você pode receber informações de qualquer maneira razoável, inclusive como uma lista de dígitos, como uma seqüência de caracteres etc. É aceitável (embora não recomendado) receber informações de forma unária ou qualquer outra base de sua escolha.

Este é um código de golfe, portanto o código mais curto vence!

Casos de teste

       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 como duas listas:

[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 publiquei esse desafio, não percebi que isso poderia ser simplificado tanto pelo método usado na resposta de Grimy e, portanto, estaria muito interessado em respostas que adotassem uma abordagem mais matemática para resolver isso, em vez de um 'dígito' truque (obviamente todas as respostas válidas são igualmente válidas, exatamente o que eu estaria interessado em ver).

05AB1E , 7 5 4 bytes

>9*н

Experimente online!

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

MathGolf , 6 bytes

)9*▒├Þ

Experimente online!

Infelizmente, não há headoperação no MathGolf, então eu tenho que me contentar ▒├Þem converter em string, pop da esquerda e descartar tudo, exceto o topo da pilha.

Gelatina , 5 bytes

‘×9DḢ

Experimente online!

Usando a abordagem de Grimy .

Stax , 5 bytes

^9*Eh

Execute e depure

Japonês -g , 7 6 5 bytes

-1 byte graças a Shaggy

Recebe entrada como uma string

i°U*9

Experimente | Teste várias entradas

Carvão , 7 bytes

§Ｉ×⁹⊕Ｎ⁰

Experimente online! Link é a versão detalhada do código. @ Grimy é claro. Aqui está uma abordagem matemática de 27 bytes:

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

Experimente online! Link é a versão detalhada do código. Falha em entradas inválidas. Explicação:

Ｎθ

Insira o número construído.

Ｗ¬№Ｅχ×κ↨υχθ

Interprete a lista como um número na base 10, multiplique por todos os números de 0até 9e veja se o número construído aparece.

⊞υＬυ

Empurre o comprimento da lista para si mesmo. A lista torna-se, portanto, do formulário [0, 1, 2, ..., n].

Ｉ⌕Ｅχ×ι↨υχθ

Recrie os números construídos, mas desta vez encontre e produza o índice no qual o número de entrada apareceu.

Labirinto ,  28 22  20 bytes

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

Aplica o método baseado em dígitos descrito por Grimy por divisão inteira repetida por dez até zero ser encontrado.

Experimente online!

Espaço em branco , 108 bytes

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

Letras S(espaço), T(guia) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Porto de @Grimy resposta 05AB1E 's , exceto que eu não tenho um builtin para obter o primeiro dígito. ;)

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-código:

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

Python 3 , 22 bytes

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

Experimente online!

Porto de Grimy 's resposta 05AB1E

---

Python 3 , 74 bytes

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

Experimente online!

Explicação

Função recursiva. Repete a sequência de cada dígito l, iniciando em 1. Se a entrada ifor igual à iteração atual j, o dígito correspondente lserá retornado. Caso contrário , se o valor atual jna sequência exceder o valor de entrada i, ele aumentará o dígito le começará novamente. O argumento ké usado para aumentar o fator de multiplicação.

JavaScript (ES6),  16  15 bytes

Agradeço ao @Grimy por levantar a restrição de 32 bits que tive com a versão anterior.

Usando o encantamento mágico de Grimy . Recebe a entrada como uma sequência.

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

Experimente online!

---

JavaScript (ES6), 53 bytes

Abordagem ingênua de força bruta.

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

Experimente online!

Java 8, 23 bytes

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

Porto de @Grimy resposta 05AB1E 's , por isso, certifique-se de upvote-lo!

Experimente online.

Mas como eu me sinto mal por @cairdCoinheringaahing , aqui uma abordagem de força bruta com um pouco mais de recursos ( 83 bytes ):

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

Experimente online.

Explicação:

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

PHP , 20 bytes

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

Experimente online!

Mais uma porta de resposta do Grimy !

Geléia , 8 bytes

RRḌ÷@fⱮ9

Experimente online!

Um programa completo que pega um número inteiro e imprime o dígito inicial. Não usa o método inteligente de Grimy! Terrivelmente ineficiente para maior entrada. A versão a seguir lida com todos os casos de teste, mas é um byte mais longo:

Geléia , 9 bytes

DJRḌ÷@fⱮ9

Experimente online!

Hy , 44 bytes

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

Usa o método de Grimy

Experimente online!

Barril -rr , 4 bytes

⑨9*÷

Experimente online!

Obviamente, usa a mesma abordagem que a resposta 05AB1E. Também usa o novo-rr sinalizador (reverter e imprimir bruto).

Transpiles para:

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)

Wren , 30 bytes

Apenas um porto da maioria das respostas.

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

Experimente online!