14

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

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

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

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

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

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

где - это одна цифра (от до ) $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]

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

code-golf number sequence

— Кэрд
источник

Песочница пост . У меня есть 9-байтовое решение в Jelly, если кто-то хочет это оспорить.

— Caird Coneheringaahing

26

05AB1E , 7 5 4 байта

>9*н

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

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

— Grimmy
источник

6

Хм, это не сулит ничего хорошего для этой задачи, если ее можно так легко упростить

— caird coinheringaahing

9

У вас есть приблизительно 1 байт кода для 800 байтов объяснения вызова. : p

— Арно

1

Как вы пришли к решению и почему оно правильно?

— Джоэл

7

@Joel (n-1) -й член последовательности, начинающейся с a is a * (((10**n - 1) / 9 - n) / 9). Умножьте это на 9 и добавьте a*n, и вы получите a * ((10**n - 1) / 9)aka цифру, повторенную n раз. Оказывается, добавление 9 вместо a*nработ для n = 1, а для больших n постоянная разница незначительна рядом с экспоненциальным ростом.

— Grimmy

3

@ Грими Большое спасибо за объяснение. Может быть, вы можете поместить это в свой пост.

— Джоэл

3

MathGolf , 6 байтов

)9*▒├Þ

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

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

— Джо Кинг
источник

2

Желе , 5 байт

‘×9DḢ

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

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

— Эрик Outgolfer
источник

2

Stax , 5 байт

^9*Eh

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

— Оливер
источник

2

Japt `-g` , 7 6 5 байт

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

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

i°U*9

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

— Оливер
источник

1

5 байтов , принимая входные данные в виде строки.

— Лохматый

2

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

§Ｉ×⁹⊕Ｎ⁰

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

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

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

Ｎθ

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

Ｗ¬№Ｅχ×κ↨υχθ

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

⊞υＬυ

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

Ｉ⌕Ｅχ×ι↨υχθ

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

— Нил
источник

2

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

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

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

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

— Джонатан Аллан
источник

2

Пробел , 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

— Кевин Круйссен
источник

2

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используется для увеличения коэффициента умножения.

— Jitse
источник

1

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)

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

— Arnauld
источник

-~n*9может быть n*9+9, это то же самое bytecount, но следует избавиться от 32-битного ограничения, если я правильно понял.

— Grimmy

грубая сила работает для> = 10, как14808

— Nahuel Fouilleul

1

@NahuelFouilleul, если мы рассмотрим a> = 10, ответ больше не является уникальным (14808 может быть либо четвертым членом a = 12, либо первым членом a = 14808). Если вывод любого из них разрешен, n=>nработает для всех входов.

— Grimmy

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

— Кевин Круйссен
источник

0

PHP , 20 байт

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

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

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

— night2
источник

0

Желе , 8 байт

RRḌ÷@fⱮ9

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

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

Желе , 9 байт

DJRḌ÷@fⱮ9

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

— Ник Кеннеди
источник

0

Hy , 44 байта

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

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

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

— girobuz
источник

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)

— Lyxal
источник

0

Рен , 30 байт

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

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

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

Что это за сконструированное число?

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

05AB1E , 7 5 4 байта

MathGolf , 6 байтов

Желе , 5 байт

Stax , 5 байт

Japt -g , 7 6 5 байт

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

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

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

Python 3 , 22 байта

Python 3 , 74 байта

объяснение

JavaScript (ES6), 16 15 байт

JavaScript (ES6), 53 байта

Java 8, 23 байта

PHP , 20 байт

Желе , 8 байт

Желе , 9 байт

Hy , 44 байта

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

Рен , 30 байт

Japt `-g` , 7 6 5 байт

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