Para crescimento exponencial de dígitos e além!

18

Desafio

Dada uma base $1 < b < 10$ e um índice $t \ge 1$ , termo de saída $x_t$ , definido da seguinte forma:

$x_1 = 11_{10}$
$x_{i+1}$ é obtido convertendoem basee reinterpretando seus dígitos na base $x_i$ $b$ $10$
A saída deve estar na base $10$

Uma caminhada pela base 5, termo 5, seria:

$x_1 = 11_{10}$ .
$11_{10} = 21_{5}$ então . $x_2 = 21_{10}$
$21_{10} = 41_{5}$ então $x_3 = 41_{10}$ .
$41_{10} = 131_{5}$ então $x_4 = 131_{10}$ .
$131_{10} = 1011_{5}$ então $x_5 = 1011_{10}$ .
Nós produzimos a string "1011"ou o número inteiro 1011.

Casos de teste

Nota: estes são um indexado

base 2, term 5 --> 1100100111110011010011100010101000011000101001000100011011011010001111011100010000001000010011100011
base 9, term 70 --> 1202167480887
base 8, term 30 --> 4752456545
base 4, term 13 --> 2123103032103331200023103133211223233322200311320011300320320100312133201303003031113021311200322222332322220300332231220022313031200030333132302313012110123012123010113230200132021023101313232010013102221103203031121232122020233303303303211132313213012222331020133

Notas

Não são permitidas brechas padrão
Qualquer método de E / S padrão é permitido
Você pode usar índices diferentes (como 0, 1, 2, etc) para $t$
Você pode emitir os primeiros termos $t$ .
Como se trata de código-golfe , o código mais curto vence para esse idioma

code-golf number

— MilkyWay90
fonte

1

Temos que suportar números maiores ou apenas números de até 2 ^ 31 - 1?

— Modalidade de ignorância

1

@EmbodimentofIgnorance O máximo do seu idioma (Lembre-se da brecha padrão, no entanto!)

— MilkyWay90

Existe um desafio que inclua bases> 10? (Nesse caso, você interpretaria repetidamente 11como se estivesse na base be a converteria novamente na base 10, etc.)

— Neil

@ Neil Eu não incluí bases maiores que 10, já que (por exemplo) 4anão seria um número válido na base 10

— MilkyWay90

Você não entenderia 4a, pois interpretaria os dígitos da base 10 como base be converteria na base 10 a cada vez (isto é, o contrário desta pergunta).

— Neil

Respostas:

6

JavaScript (Node.js) , 40 bytes

Obrigado a @Neil por salvar 5 bytes nesta versão e 2 bytes na versão BigInt

Recebe entrada como (t)(base), onde $t$ é indexado em 1.

n=>g=(b,x=11)=>--n?g(b,+x.toString(b)):x

Experimente online!

JavaScript (Node.js) , 48 bytes (versão BigInt)

Recebe entrada como (t)(base), onde $t$ é indexado em 1. Retorna um BigInt.

n=>g=(b,x=11n)=>--n?g(b,BigInt(x.toString(b))):x

Experimente online!

— Arnauld
fonte

Você precisa evalna primeira versão? +economizaria 5 bytes ...

— Neil

E BigIntsalva dois bytes na segunda versão, porque você não precisa adicionar nà string.

— Neil

(b,t,x=11)=>--t?f(b,t,+x.toString(b)):xé 1 char mais curto

— Qwertiy

@ Qwertiy Na verdade, é 1 byte mais longo, porque precisaríamos acrescentar f=(já que a função está se referenciando).

— Arnauld

@ Arnauld, oops. Então este n=>b=>g=(x=11n)=>--n?g(BigInt(x.toString(b))):x:) Se a chamada f(t)(b)()for permitida.

— Qwertiy

5

05AB1E , 5 bytes

>IF¹B

Experimente online!

Explicação

>       # increment <base>
 IF     # <term> times do:
   ¹B   # convert from base-10 to base-<base>

Observe que não há necessidade de iniciar explicitamente a sequência em 11 .
Iniciar base+1e executar uma iteração extra resultará na primeira iteração fornecendo 11 .

— Emigna
fonte

3

Japonês , 9 bytes

ÆB=sV n
B

(Two inputs, U and V)
Æ            Range [0..U)
 B=          For each, set B (B is preinitialized to 11) to 
   sV          B's previous value converted to base-V
   n           and back to base-10
B            Print out B's final value

— Modalidade de ignorância
fonte

Isso nunca será capaz de gerar o primeiro termo, será?

— Shaggy

@Shaggy Corrigido ao custo de dois bytes

— Modalidade de Ignorância

Bem guardado :) Não teria pensado nisso.

— Shaggy

2

Wolfram Language (Mathematica) , 46 bytes

bNest[FromDigits[#~IntegerDigits~b]&,11,#]&

Experimente online!

Ligue com f[base][t]. Indexado a 0.

— attinat
fonte

2

41 bytes

— Dados expirados

2

Retina , 67 bytes

.+,(\d+)
11,$1*
"$+"{`^\d+
*
)+`(?=_.*,(_+))(\1)*(_*)
$#2*_$.3
,_+

Experimente online!Toma entradas separadas por vírgula $t$ (indexado a 0) e $b$ . Como todos os seus cálculos são unários, o tempo limite para números grandes é excedido. Explicação:

.+,(\d+)
11,$1*

Inicializar $x_0=11$ e converta $b$ em unário.

"$+"{`

Repita $t$ vezes.

^\d+
*

Converta $x_i$ em unário.

)+`(?=_.*,(_+))(\1)*(_*)
$#2*_$.3

Converta para a base $b$ .

,_+

Exclua $b$ da saída.

— Neil
fonte

2

Python 2 , 71 bytes

def f(b,n):h=lambda x:x and x%b+10*h(x/b);return n and h(f(b,n-1))or 11

Experimente online!

Indexado a 0.

— Chas Brown
fonte

2

Clojure , 109 bytes

Crédito para MilkyWay90 por remover 10 bytes, detectando espaços desnecessários Crédito para incorporação de ignorância por outro byte de outro espaço desnecessário

Golfe

(defn f([b t](f b t 11))([b t v](if(= t 1)v(f b(dec t)(read-string(.(new BigInteger(str v))(toString b)))))))

Ungolfed

(defn f
  ([base term] (f base term 11))
  ([base term value] (if (= term 1)
                      value
                      (f base (dec term) (read-string (. (new BigInteger (str value)) (toString base)))))))

Eu acho que o principal local bytes podem ser salvos é a expressão para ... re-mixagem? como quer que isso fosse chamado. Especificamente:

(read-string (. (new BigInteger (str value)) (toString base)))

— user70585
fonte

Você precisa desses espaços? Você pode eliminar espaços?

— MilkyWay90

Nem me ocorreu remover espaços onde eles estavam separando coisas sintaticamente diferenciáveis; parece que Clojure é um pouco mais permissivo do que eu pensava. Obrigado!

— user70585 20/05

Ainda há um espaço desnecessário(if (= t 1)

— Embodiment of Ignorance

Opa, boa captura 👍

— user70585

93 bytes

— Modalidade de ignorância

1

Perl 6 , 28 bytes

{(11,+*.base($^b)...*)[$^t]}

Experimente online!

O índice na sequência é baseado em zero.

— Sean
fonte

1

Geléia , 8 7 bytes

‘b³Ḍ$⁴¡

Experimente online!

$b$ $t$ $b + 1$

Explicação

‘b³Ḍ$⁴¡ | Main link: first argument b, second argument t
‘       | b + 1
    $⁴¡ | Repeat the following t times
 b³     | Convert to base b
   Ḍ    | Convert back from decimal to integer

— Nick Kennedy
fonte

Explicação para aqueles de nós que não conseguem reconhecer átomos rapidamente?

— MilkyWay90

1

K (ngn / k) , 13 bytes

{y(10/x\)/11}

Experimente online!

— Galen Ivanov
fonte

1

Pitão , 8 bytes

uijGQTEh

Experimente online!

— Sok
fonte

1

C # (compilador interativo do Visual C #) , 87 bytes

n=>m=>{int g=11;for(var s="";m-->0;g=int.Parse(s),s="")for(;g>0;g/=n)s=g%n+s;return g;}

Guardado 5 bytes graças a @KevinCruijssen

Experimente online!

— Modalidade de ignorância
fonte

87 bytes , alterando o do-whilepara um loop for regular.

— Kevin Cruijssen

1

cérebro , 270 bytes

++<<++<,+++<-[----->-<]<,,[<-----[->++++++++++<]++>[-<+>],]<[>>>>>>[<<<[->>+<<]>>>>>]<<[[>+<-]>>[-[<++++++++++>-]>+>]<[<<]>>[-<<+>>>+<]>>[-[<-[>>+>>]>>[+[-<<+>>]>[-<]<[>]>++>>>]<<<<<-]+>[-<+<+>>]<<[->>+<<]>>>]<[-]<[[-<+>]<<]<]<[->>+<<]<-]>>>>[>>]<<[>-[-----<+>]<----.<<]

Experimente online!

Indexado a 0. Presume-se que o número de iterações seja no máximo 255.

Explicação

A fita é apresentada da seguinte forma:

num_iterations 0 0 base digit0 0 digit1 0 digit2 ...

Cada dígito é realmente armazenado como esse dígito mais 1, com 0 reservado para "sem mais dígitos". Durante a conversão da base, os dígitos atualmente sendo trabalhados são movidos uma célula para a direita e a base é movida para a esquerda da área de trabalho atual.

++<<++              Initialize initial value 11
<,+++<-[----->-<]   Get single digit as base and subtract 48 to get actual number
<,,[<-----[->++++++++++<]++>[-<+>],]   Read multiple digits as number of iterations
<                   Go to cell containing number of iterations

[                   For each iteration:
  >>>>>>              Go to tens digit cell
  [<<<[->>+<<]>>>>>]  Move base to just before most significant digit
  <<                  Return to most significant digit

  [                   For each digit in number starting at the left (right on tape):
    [>+<-]            Move digit one cell to right (to tell where current digit is later)
    >>[-[<++++++++++>-]>+>]  Multiply each other digit by 10 and move left
    <[<<]>>           Return to base
    [-<<+>>>+<]       Copy base to just before digit (again) and just before next digit to right (left on tape)
    >>[               For each digit at least as significant as this digit:

      -[<-[>>+>>]>>[+[-<<+>>]  Compute "digit" divmod base
      >[-<]<[>]>++    While computing this: add quotient to next digit; initialize digit to "1" (0) first if "0" (null)
      >>>]<<<<<-]     End of divmod routine

      +>[-<+<+>>]     Leave modulo as current digit and restore base
      <<[->>+<<]      Move base to next position
      >>>
    ]

    <[-]<             Delete (now useless) copy of base
    [[-<+>]<<]<       Move digits back to original cells
  ]                   Repeat entire routine for each digit

  <[->>+<<]           Move base to original position
  <-                  Decrement iteration count
]

>>>>[>>]<<[>-[-----<+>]<----.<<]  Output by adding 47 to each cell containing a digit

— Nitrodon
fonte

0

Carvão , 14 bytes

≔11ζＦＮ≔⍘ＩζＩηζζ

$t$ $b$

≔11ζ

$x_0=11$

ＦＮ

$b$

≔⍘ＩζＩηζ

$x_i$

ζ

$x_t$

— Neil
fonte

0

Pari / GP , 50 bytes

(b,n)->x=11;for(i=2,n,x=fromdigits(digits(x,b)));x

Experimente online!

— alefalpha
fonte

0

C (gcc) , 59 bytes

f(t,b){t=t?c(f(t-1,b),b):11;}c(n,b){n=n?c(n/b,b)*10+n%b:0;}

Experimente online!

— attinat
fonte

0

Groovy , 45 bytes

a,b,c=11->a--?f(a,b,a.toString(c as int,b)):c

Experimente online!

Porto da resposta de @ Arnauld

— Dados expirados
fonte

0

PHP , 83 75 bytes

function c($b,$t,$v=11){return $t==1?$v:c($b,$t-1,base_convert($v,10,$b));}

Experimente online!

Este funcionará apenas com números "pequenos" (por exemplo, não nos casos de teste 1 e 4)

— rollstuhlfahrer
fonte

0

Japt , 10 bytes

Indexado a 0. Toma tcomo a primeira entrada, bcomo a segunda.

_ìV ì}gBìC

— Shaggy
fonte

0

Gaia , 8 bytes

Bd
11@↑ₓ

Experimente online!

Leva 0 com base iterationsentão base.

Bd		| helper function: convert to Base b (implicit) then convert to base 10
		| main function:
11		| push 11
  @		| push # of iterations
   ↑ₓ		| do the above function (helper function) that many times as a monad

— Giuseppe
fonte

0

Rubi , 39 bytes

Indexado a zero.

->b,n,x=11{n.times{x=x.to_s(b).to_i};x}

Experimente online!

— Value Ink
fonte

0

Perl 5 `-Mbigint -pa` , 65 bytes

$\=11;map{$p=$\;$\%=0+"@F";$\=($p%"@F").$\while$p/=0+"@F"}2..<>}{

Experimente online!

— Xcali
fonte

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.

Licensed under cc by-sa 3.0 with attribution required.