14

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

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

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

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

\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}$ 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:

${você}_{n} = 10 \times {você}_{n - 1} + n \times uma, {você}_{1} = uma$ $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).

code-golf number sequence

— caird coinheringaahing
fonte

Postagem na caixa de areia . Eu tenho uma solução de 9 bytes no Jelly, se alguém quiser contestar isso.

— caird coinheringaahing 04/04/19

26

05AB1E , 7 5 4 bytes

>9*н

Experimente online!

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

— Grimmy
fonte

6

Hmm, isso não augura nada de bom para este desafio se ele pode ser simplificada tão facilmente

— caird coinheringaahing

9

Você tem aproximadamente 1 byte de código para 800 bytes de explicação do desafio. : p

— Arnauld

1

Como você cria a solução e por que ela está correta?

— Joel

7

@Joel o (n-1) th termo da sequência começando com a é a * (((10**n - 1) / 9 - n) / 9). Multiplique isso por 9 e adicione a*n, e você obtém a * ((10**n - 1) / 9), também conhecido como dígito, um n repetido vezes. Acontece que adicionar 9 em vez de a*ntrabalhar para n = 1 e para n maior a diferença constante é desprezível próximo ao crescimento exponencial.

— Grimmy

3

@ Grimy Muito obrigado pela explicação. Talvez você possa colocá-lo em sua postagem.

— Joel

3

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.

— Brincadeira
fonte

2

Gelatina , 5 bytes

‘×9DḢ

Experimente online!

Usando a abordagem de Grimy .

— Erik, o Outgolfer
fonte

2

Stax , 5 bytes

^9*Eh

Execute e depure

— Oliver
fonte

2

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

— Oliver
fonte

1

5 bytes , tendo entrada como uma string.

— Shaggy

2

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.

— Neil
fonte

2

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!

— Jonathan Allan
fonte

2

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

— Kevin Cruijssen
fonte

2

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.

— Jitse
fonte

1

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!

— Arnauld
fonte

-~n*9pode ser n*9+9, que é o mesmo bytecount, mas deve se livrar da limitação de 32 bits se eu entendi corretamente.

— Grimmy

a força bruta trabalha para um> = 10, como14808

— Nahuel Fouilleul

1

@NahuelFouilleul se considerarmos um> = 10, a resposta não será mais única (14808 poderia ser o quarto termo de a = 12 ou o primeiro termo de a = 14808). Se a saída de qualquer uma dessas opções for permitida, n=>nfuncionará para todas as entradas.

— Grimmy

1

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

— Kevin Cruijssen
fonte

0

PHP , 20 bytes

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

Experimente online!

Mais uma porta de resposta do Grimy !

— Night2
fonte

0

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!

— Nick Kennedy
fonte

0

Hy , 44 bytes

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

Usa o método de Grimy

Experimente online!

— girobuz
fonte

0

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)

— Lyxal
fonte

0

Wren , 30 bytes

Apenas um porto da maioria das respostas.

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

Experimente online!

— uma'_'
fonte

Qual é a partida deste número construído?

Casos de teste

05AB1E , 7 5 4 bytes

MathGolf , 6 bytes

Gelatina , 5 bytes

Stax , 5 bytes

Japonês -g , 7 6 5 bytes

Carvão , 7 bytes

Labirinto , 28 22 20 bytes

Espaço em branco , 108 bytes

Python 3 , 22 bytes

Python 3 , 74 bytes

Explicação

JavaScript (ES6), 16 15 bytes

JavaScript (ES6), 53 bytes

Java 8, 23 bytes

PHP , 20 bytes

Geléia , 8 bytes

Geléia , 9 bytes

Hy , 44 bytes

Barril -rr , 4 bytes

Wren , 30 bytes

Japonês `-g` , 7 6 5 bytes

Barril `-rr` , 4 bytes