Многие языки программирования создают большие целые числа путем «конкатенации» цифры к концу существующего числа. Например, Лабиринт или Адаптировать . Конкатенируя цифру до конца, я имею в виду, что если существующее число равно , а число равно , результирующее число равно .$45$$7$$457\:(45 \times 10 + 7)$

Составное число - это число, которое можно построить таким образом, используя кратные числа из однозначных чисел: $1, 2, 3, 4, 5, 6, 7, 8, 9$ AKA элемент в одной из этих 9 последовательностей:

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

Чтобы дать пример того, как строятся последовательности, вот как $a = 3$ последовательность для 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}$ и включены, чтобы продемонстрировать, когда . Много цифр пунктир за пространство.$u_{34}$$n \times a \ge 100$}

Возможно, до сих пор неясно, как сконструированы эти последовательности, поэтому есть два разных способа их понять:

• Каждая последовательность начинается с одной цифры. Следующий термин определяется путем взятия следующего кратного этой цифры, умножения предыдущего термина на и добавления кратного. В последовательном выражении:$10$

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

  где - это одна цифра (от до )$a$$1$$9$

• Каждый из элементов в любой точке последовательности (например, ) кратен от до , где составляется из$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)$

  Таким образом, первые значения , вторые , третьи и т. д.$1 \times 1, 2, 3, \dots, 8, 9$$12 \times 1, 2, 3, \dots, 8, 9$$123 \times 1, 2, 3, \dots, 8, 9$

Ваша задача - взять построенное число в качестве ввода и вывести начальную цифру, использованную для его построения. Вы можете предположить, что вход всегда будет составным числом и будет больше . Это может быть одна цифра, которая отображается на себя.$0$

Вы можете принимать ввод любым разумным способом, в том числе в виде списка цифр, в виде строки и т. Д. Допустимо (хотя и не рекомендуется) вводить данные в унарной или любой другой базе по вашему выбору.

Это код-гольф, поэтому выигрывает самый короткий код!

Контрольные примеры

       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

или в виде двух списков:

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

---

Когда я опубликовал это задание, я не осознавал, что его можно так сильно упростить с помощью метода, использованного в ответе Грими , и поэтому очень заинтересован в ответах, которые используют более математический подход к решению, а не «цифру». хитрость (очевидно, все действительные ответы одинаково действительны, именно то, что мне было бы интересно увидеть).

05AB1E , 7 5 4 байта

>9*н

Попробуйте онлайн!

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

MathGolf , 6 байтов

)9*▒├Þ

Попробуйте онлайн!

К сожалению, headв MathGolf нет никаких операций, поэтому мне нужно обойтись, ▒├Þчтобы преобразовать в строку, щелкнуть слева и отбросить все, кроме вершины стека.

Желе , 5 байт

‘×9DḢ

Попробуйте онлайн!

Используя подход Грими .

Stax , 5 байт

^9*Eh

Запустите и отладьте его

Japt -g , 7 6 5 байт

-1 байт благодаря Shaggy

Принимает ввод в виде строки

i°U*9

Попробуй это | Проверьте несколько входов

Древесный уголь , 7 байт

§Ｉ×⁹⊕Ｎ⁰

Попробуйте онлайн! Ссылка на подробную версию кода. @ Конечно, метод Грими. Вот 27-байтовый математический подход:

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

Попробуйте онлайн! Ссылка на подробную версию кода. Сбои на неверных входах. Объяснение:

Ｎθ

Введите построенное число.

Ｗ¬№Ｅχ×κ↨υχθ

Интерпретируйте список как число в базе 10, умножьте его на все числа от 0до 9и посмотрите, появляется ли построенное число.

⊞υＬυ

Выдвиньте список длины к себе. Таким образом, список становится в форме [0, 1, 2, ..., n].

Ｉ⌕Ｅχ×ι↨υχθ

Создайте заново построенные числа, но на этот раз найдите и выведите индекс, по которому появилось введенное число.

Лабиринт ,  28 22  20 байт

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

Применяет основанный на цифрах метод, описанный Грими путем повторного целочисленного деления на десять, пока не будет найден ноль.

Попробуйте онлайн!

Пробел , 108 байт

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

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.
[..._some_action]добавлено только в качестве объяснения.

Порт ответа @Grimy 's 05AB1E , за исключением того, что у меня нет встроенной функции для получения первой цифры. ;)

Попробуйте онлайн (только с пробелами, вкладками и новыми строками).

Объяснение в псевдокоде:

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 байта

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

Попробуйте онлайн!

Порт грязного «s 05AB1E ответа

---

Python 3 , 74 байта

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

Попробуйте онлайн!

объяснение

Рекурсивная функция. Перебирает последовательность для каждой цифры l, начиная с 1. Если входное значение iравно текущей итерации j, lвозвращается соответствующая цифра . Иначе, если текущее значение jв последовательности превышает входное значение i, оно будет увеличивать цифру lи начинать заново. Аргумент kиспользуется для увеличения коэффициента умножения.

JavaScript (ES6),  16  15 байт

Спасибо @Grimy за снятие 32-битного ограничения, которое у меня было с предыдущей версией.

Используя магическое заклинание Грими . Принимает ввод в виде строки.

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

Попробуйте онлайн!

---

JavaScript (ES6), 53 байта

Наивный подход грубой силы.

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

Попробуйте онлайн!

Java 8, 23 байта

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

Port of @Grimy 's 05AB1E answer , так что обязательно проголосуйте за него!

Попробуйте онлайн.

Но из-за того , что я немного расстроен из- за @cairdCoinheringaahing , здесь грубый метод с немного большим количеством денег ( 83 байта ):

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

Попробуйте онлайн.

Объяснение:

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 байт

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

Попробуйте онлайн!

Еще один порт ответа Грими !

Желе , 8 байт

RRḌ÷@fⱮ9

Попробуйте онлайн!

Полная программа, которая принимает целое число и печатает начальную цифру. Не использует умный метод Грими! Ужасно неэффективно для большего ввода. Следующая версия обрабатывает все тестовые случаи, но на байт длиннее:

Желе , 9 байт

DJRḌ÷@fⱮ9

Попробуйте онлайн!

Hy , 44 байта

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

Использует метод Грими

Попробуйте онлайн!

Бочонок -rr , 4 байта

⑨9*÷

Попробуйте онлайн!

Конечно, используется тот же подход, что и в ответе 05AB1E. Также используется новый -rrфлаг (обратный и печатный).

Транспортирует к:

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)

Рен , 30 байт

Просто порт большинства ответов.

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

Попробуйте онлайн!