Varios lenguajes de programación construyen enteros grandes mediante la 'concatenación' del dígito al final del número existente. Por ejemplo, Labyrinth o Adapt . Al concatenar el dígito hasta el final, quiero decir que, si el número existente es $45$ y el dígito es $7$ , el número resultante es $457\:(45 \times 10 + 7)$ .

Un número construido es un número que se puede construir de esta manera mediante el uso de múltiplos de números de un solo dígito: $1, 2, 3, 4, 5, 6, 7, 8, 9$ AKA un elemento en una de estas 9 secuencias:

$$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 proporcionar un ejemplo de cómo se construyen las secuencias, así es como se construye la secuencia para $a = 3$ :

$$\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}$ incluyen u 33 y$u_{34}$ para demostrar cuándo$n \times a \ge 100$ . Unmontónde dígitos punteados por espacio.}

Puede que aún no esté claro cómo se construyen estas secuencias, por lo que aquí hay dos formas diferentes de entenderlas:

• Cada secuencia comienza desde el único dígito. El siguiente término se encuentra tomando el siguiente múltiplo de ese dígito, multiplicando el término anterior por$10$ y sumando el múltiplo. En términos de secuencia:

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

  donde $a$ es un solo dígito ( $1$ a $9$ )

• Cada uno de los $9$ elementos en cualquier punto de la secuencia (tome $n = 3$ por ejemplo) son los múltiplos de $123\dots$ del $1$ al $9$ , donde $123\dots$ se construye por $u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

  Entonces, los primeros valores son $1 \times 1, 2, 3, \dots, 8, 9$ , los segundos son $12 \times 1, 2, 3, \dots, 8, 9$ , los terceros $123 \times 1, 2, 3, \dots, 8, 9$ , etc.

Su tarea es tomar un número construido como entrada y generar el dígito inicial utilizado para construirlo. Puede suponer que la entrada siempre será un número construido y será mayor que $0$ . Puede ser un solo dígito, que se asigna a sí mismo.

Puede tomar datos de cualquier manera razonable, incluso como una lista de dígitos, como una cadena, etc. Es aceptable (aunque no recomendado) tomar los datos de manera individual o en cualquier otra base de su elección.

Este es un código de golf, por lo que gana el código más corto.

Casos de prueba

       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 como dos 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]

---

Cuando publiqué este desafío, no me di cuenta de que podría simplificarse tanto por el método utilizado en la respuesta de Grimy , por lo que estaría muy interesado en respuestas que tengan un enfoque más matemático para resolver esto, en lugar de un 'dígito' truco (Obviamente, todas las respuestas válidas son igualmente válidas, justo lo que me gustaría ver).

05AB1E , 7 5 4 bytes

>9*н

Pruébalo en línea!

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

MathGolf , 6 bytes

)9*▒├Þ

Pruébalo en línea!

Desafortunadamente, no hay ninguna headoperación en MathGolf, así que tengo que conformarme con ▒├Þconvertir a cadena, hacer pop desde la izquierda y descartar todo menos la parte superior de la pila.

Jalea , 5 bytes

‘×9DḢ

Pruébalo en línea!

Usando el enfoque de Grimy .

Stax , 5 bytes

^9*Eh

Ejecutar y depurarlo

Japt -g , 7 6 5 bytes

-1 byte gracias a Shaggy

Toma la entrada como una cadena

i°U*9

Pruébalo | Probar múltiples entradas

Carbón de leña , 7 bytes

§Ｉ×⁹⊕Ｎ⁰

Pruébalo en línea! El enlace es a la versión detallada del código. El método de @ Grimy, por supuesto. Aquí hay un enfoque matemático de 27 bytes:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Se bloquea en entradas no válidas. Explicación:

Ｎθ

Ingrese el número construido.

Ｗ¬№Ｅχ×κ↨υχθ

Interprete la lista como un número en la base 10, multiplique por todos los números desde 0hasta 9y vea si aparece el número construido.

⊞υＬυ

Empuje la longitud de la lista a sí misma. La lista por lo tanto se hace de la forma [0, 1, 2, ..., n].

Ｉ⌕Ｅχ×ι↨υχθ

Recrea los números construidos pero esta vez encuentra y genera el índice en el que apareció el número de entrada.

Laberinto ,  28 22  20 bytes

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

Aplica el método basado en dígitos descrito por Grimy por división entera repetida por diez hasta encontrar cero.

Pruébalo en línea!

Espacio en blanco , 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Puerto de @Grimy respuesta 05AB1E 's , excepto que no tengo una orden interna para obtener el primer dígito. ;)

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocó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]

Pruébalo en línea!

La respuesta 05AB1E del puerto de Grimy

---

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

Pruébalo en línea!

Explicación

Función recursiva. Itera sobre la secuencia de cada dígito l, comenzando en 1. Si la entrada ies igual a la iteración actual j, lse devuelve el dígito correspondiente . De lo contrario, si el valor actual jen la secuencia excede el valor de entrada i, incrementará el dígito ly comenzará de nuevo. El argumento kse usa para incrementar el factor de multiplicación.

JavaScript (ES6),  16  15 bytes

Gracias a @Grimy por levantar la restricción de 32 bits que tenía con la versión anterior.

Usando el encantamiento mágico de Grimy . Toma la entrada como una cadena.

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

Pruébalo en línea!

---

JavaScript (ES6), 53 bytes

Enfoque ingenuo de la fuerza bruta.

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

Pruébalo en línea!

Java 8, 23 bytes

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

Puerto de @Grimy 's respuesta 05AB1E , así que asegúrese de que le upvote!

Pruébalo en línea.

Pero debido a que me siento un poco mal por @cairdCoinheringaahing , aquí un enfoque de fuerza bruta con un poco más de precio ( 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;}

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

¡Otro puerto de respuestas de Grimy !

Jalea , 8 bytes

RRḌ÷@fⱮ9

Pruébalo en línea!

Un programa completo que toma un número entero e imprime el dígito de inicio. ¡No usa el método inteligente de Grimy! Terriblemente ineficiente para una entrada mayor. La siguiente versión maneja todos los casos de prueba pero es un byte más largo:

Jalea , 9 bytes

DJRḌ÷@fⱮ9

Pruébalo en línea!

Hy , 44 bytes

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

Utiliza el método de Grimy

Pruébalo en línea!

Barril -rr , 4 bytes

⑨9*÷

Pruébalo en línea!

Por supuesto, utiliza el mismo enfoque que la respuesta 05AB1E. También usa el nuevo-rr bandera (revertir e imprimir sin formato).

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)

Wren , 30 bytes

Solo un puerto de la mayoría de las respuestas.

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

Pruébalo en línea!