Défi

Étant donné une base $1 < b < 10$ et un indice $t \ge 1$ , le terme de sortie $x_t$ , défini comme suit:

• $x_1 = 11_{10}$
• $x_{i+1}$ est obtenu en convertissant$x_i$ en base$b$ puis en réinterprétant ses chiffres en base$10$
• La sortie doit être en base $10$

Une marche à suivre pour la base 5, terme 5 serait:

• $x_1 = 11_{10}$ .
• $11_{10} = 21_{5}$ donc$x_2 = 21_{10}$ .
• $21_{10} = 41_{5}$ donc$x_3 = 41_{10}$ .
• $41_{10} = 131_{5}$ donc$x_4 = 131_{10}$ .
• $131_{10} = 1011_{5}$ donc$x_5 = 1011_{10}$ .
• Nous sortons la chaîne "1011"ou l'entier 1011.

Cas de test

Remarque: ce sont un indexé

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

Remarques

• Les échappatoires standard ne sont pas autorisées
• Toute méthode d'E / S par défaut est autorisée
• Vous pouvez utiliser différents index (tels que 0, 1, 2, etc.) pour $t$
• Vous pouvez sortir le premier $t$termes.
• Comme c'est du golf de code , code le plus court gagne pour cette langue

JavaScript (Node.js) , 40 octets

Merci à @Neil d'avoir économisé 5 octets sur cette version et 2 octets sur la version BigInt

Prend l'entrée comme (t)(base), où $t$ est indexé sur 1.

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

Essayez-le en ligne!

JavaScript (Node.js) , 48 octets (version BigInt)

Prend l'entrée comme (t)(base), où $t$ est indexé sur 1. Renvoie un BigInt.

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

Essayez-le en ligne!

05AB1E , 5 octets

>IF¹B

Essayez-le en ligne!

Explication

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

Notez qu'il n'est pas nécessaire de démarrer explicitement la séquence à 11 .
Commencer base+1et faire une itération supplémentaire entraînera la première itération donnant 11 .

Japt , 9 octets

ÆB=sV n
B

Essayez-le

(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

Wolfram Language (Mathematica) , 46 octets

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

Essayez-le en ligne!

Appelez avec f[base][t]. 0 indexé.

Rétine , 67 octets

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

Essayez-le en ligne! Prend les entrées séparées par des virgules $t$ (indexées 0) et $b$ . Effectue tous ses calculs en unaire, donc expire pour les grands nombres. Explication:

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

Initialisez $x_0=11$ et convertissez $b$ en unaire.

"$+"{`

Répétez $t$ fois.

^\d+
*

Convertissez $x_i$ en unaire.

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

Convertir en base $b$ .

,_+

Supprimez $b$ de la sortie.

Python 2 , 71 octets

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

Essayez-le en ligne!

0 indexé.

Clojure , 109 octets

Crédit à MilkyWay90 pour avoir supprimé 10 octets en repérant des espaces inutiles. Crédit à Incarnation of Ignorance pour un autre octet d'un autre espace inutile.

Golfé

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

Non golfé

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

Je pense que les octets principaux peuvent être enregistrés est l'expression de ... retradixing? quel que soit le nom. Plus précisément:

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

Perl 6 , 28 octets

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

Essayez-le en ligne!

L'index dans la séquence est basé sur zéro.

Gelée , 8 7 octets

‘b³Ḍ$⁴¡

Essayez-le en ligne!

Un programme complet qui prend $b$ comme premier argument et indexé 1 $t$comme deuxième argument. Renvoie l'entier du terme pertinent (et imprime implicitement). Utilise l'observation de @Emigna concernant le début de$b + 1$.

Explication

‘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

K (ngn / k) , 13 octets

{y(10/x\)/11}

Essayez-le en ligne!

Pyth , 8 octets

uijGQTEh

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 87 octets

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

5 octets enregistrés grâce à @KevinCruijssen

Essayez-le en ligne!

brainfuck , 270 octets

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

Essayez-le en ligne!

0 indexé. Le nombre d'itérations est supposé être au maximum de 255.

Explication

La bande est présentée comme suit:

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

Chaque chiffre est en fait stocké en tant que chiffre plus 1, 0 étant réservé pour "plus de chiffres". Pendant la conversion de la base, les chiffres en cours de travail sont déplacés d'une cellule vers la droite et la base est déplacée vers la gauche de la zone de travail actuelle.

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

Fusain , 14 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend les entrées comme$t$ (Indexé 0) et $b$. Explication:

≔11ζ

$x_0=11$.

ＦＮ

Boucle $b$ fois.

≔⍘ＩζＩηζ

Calculer $x_i$.

ζ

Production $x_t$.

Pari / GP , 50 octets

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

Essayez-le en ligne!

C (gcc) , 59 octets

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

Essayez-le en ligne!

Groovy , 45 octets

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

Essayez-le en ligne!

Port of @ Arnauld's answer

PHP , 83 75 octets

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

Essayez-le en ligne!

Celui-ci ne fonctionnera qu'avec des "petits" nombres (par exemple pas les cas de test 1 et 4)

Japt , 10 octets

0 indexé. Prend tcomme première entrée, bcomme seconde.

_ìV ì}gBìC

Essayez-le

Gaia , 8 octets

Bd
11@↑ₓ

Essayez-le en ligne!

Prend iterationsalors sur la base de 0 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

Rubis , 39 octets

Zéro indexé.

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

Essayez-le en ligne!

Perl 5 -Mbigint -pa , 65 octets

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

Essayez-le en ligne!