Dado un número entero positivo n, genera la base más pequeña b >= 2donde la representación de nin base bsin ceros a la izquierda no contiene a 0. Puede suponer eso b <= 256para todas las entradas.

Casos de prueba

1 -> 2 (1)
2 -> 3 (2)
3 -> 2 (11)
4 -> 3 (11)
5 -> 3 (12)
6 -> 4 (12)
7 -> 2 (111)
10 -> 4 (22)
17 -> 3 (122)
20 -> 6 (32)
50 -> 3 (1212)
100 -> 6 (244)
777 -> 6 (3333)
999 -> 4 (33213)
1000 -> 6 (4344)
1179360 -> 23 ([12, 9, 21, 4, 4])
232792560 -> 23 ([15, 12, 2, 20, 3, 13, 1])
2329089562800 -> 31 ([20, 3, 18, 2, 24, 9, 20, 22, 2])
69720375229712477164533808935312303556800 -> 101 ([37, 17, 10, 60, 39, 32, 21, 87, 80, 71, 82, 14, 68, 99, 95, 4, 53, 44, 10, 72, 5])
8337245403447921335829504375888192675135162254454825924977726845769444687965016467695833282339504042669808000 -> 256 ([128, 153, 236, 224, 97, 21, 177, 119, 159, 45, 133, 161, 113, 172, 138, 130, 229, 183, 58, 35, 99, 184, 186, 197, 207, 20, 183, 191, 181, 250, 130, 153, 230, 61, 136, 142, 35, 54, 199, 213, 170, 214, 139, 202, 140, 3])

Pyth , 6 bytes

f*FjQT

Verifique todos los casos de prueba.

Cómo funciona

f * FjQT ~ Programa completo.

f ~ Primer entero positivo donde la condición es verdadera.
   jQT ~ La entrada convertida a la base del elemento actual.
 * F ~ Producto. Si la lista contiene 0, entonces es 0, de lo contrario es estrictamente positivo.
          0 -> Falsy; > 0 -> Verdad.
        ~ Salida del resultado implícitamente.

Aunque Pyth's fopera en 1, 2, 3, 4, ...(comenzando en 1), Pyth trata los números en la base 1 (unario) como un montón de ceros, por lo que la base 1 se ignora.

C,  52  50 bytes

i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;return i;}

Pruébalo en línea!

C (gcc),  47  45 bytes

i,k;f(n){for(i=2,k=n;k;)k=k%i++?k/--i:n;n=i;}

Pruébalo en línea!

¡Dos bytes guardados gracias a la sugerencia de @ Nevay sobre la respuesta de @Kevin Cruijssen!

Haskell , 56 52 48 bytes

b#n=n<1||mod n b>0&&b#div n b
f n=until(#n)(+1)2

Pruébalo en línea!

Bastante básico pero no se me ocurren buenas maneras de acortarlo

EDITAR: ¡Gracias a Laikoni por salvarme 4 bytes! No sé por qué nunca pensé !!0. Probablemente debería haber intentado eliminar esos paréntesis, pero tengo vagos recuerdos de algún error extraño cuando intentas usarlos ||y &&juntos. Tal vez lo estoy confundiendo con los operadores de igualdad.

EDIT 2: ¡Gracias @Lynn por afeitar otros 4 bytes! No sé cómo nunca supe untilantes.

Wolfram Language (Mathematica) , 33 bytes

2//.i_/;DigitCount[#,i,0]>0:>i+1&

Pruébalo en línea!

Casco , 7 bytes

→V▼MBtN

Pruébalo en línea!

Explicación

→V▼MBtN
     tN    list of natural numbers starting from 2
   MB      convert the (implicit) input to each of those bases
 V▼        find the (1-based) index of the first result where the minimum digit is truthy
→          add 1 to this index

Python 2 , 57 bytes

n=x=input()
b=2
while x:z=x%b<1;b+=z;x=[x/b,n][z]
print b

Pruébalo en línea!

Este es un byte más corto que una función recursiva:

f=lambda n,b=1,x=1:b*(x<1)or f(n,b+(x%b<1),[x/b,n][x%b<1])

Jalea , 7 bytes

2b@Ạ¥1#

Pruébalo en línea!

05AB1E , 6 bytes

-4 bytes gracias a Adnan

1µNвPĀ

Pruébalo en línea!

Casco , 9 bytes

←foΠ`B⁰tN

Pruébalo en línea!

Explicación

            -- input N
        tN  -- tail of [1..] == [2..]
←f(    )    -- filter with the following:
    `B⁰     --   convert N to that base
   Π        --   product (0 if it contains 0)
←           -- only keep first element

Java 8, 61 56 54 bytes

n->{int b=2,t=n;for(;t>0;)t=t%b++<1?n:t/--b;return b;}

Pruébalo aquí

Explicación:

n->{            // Method with integer as both parameter and return-type
  int b=2,      //  Base-integer, starting at 2
      t=n;      //  Temp-integer, copy of the input
  for(;t>0;)    //  Loop as long as `t` is not 0
    t=t%b++<1?  //   If `t` is divisible by the base `b`
                //   (and increase the base `b` by 1 afterwards with `b++`)
       n        //    Set `t` to the input `n`
      :         //   Else:
       t/--b;   //    Divide `t` by the `b-1`
                //    (by decreasing the base `b` by 1 first with `--b`)
                //  End of loop (implicit / single-line body)
  return b;     //  Return the resulting base
}               // End of method

Tengo la sensación de que esto se puede jugar utilizando un enfoque aritmético. De hecho, puede, con un puerto de respuesta @Steadybox 'C , y luego jugar golf por 2 bytes gracias a @Nevay .

Respuesta anterior ( 61 bytes ):

n->{int b=1;for(;n.toString(n,++b).contains("0"););return b;}

Pruébalo aquí

Explicación:

n->{         // Method with Integer as both parameter and return-type
  int b=1;   //  Base-integer, starting at 1
  for(;n.toString(n,++b).contains("0"););
             //  Loop as long as the input in base-`b` does contain a 0,
             //  after we've first increased `b` by 1 before every iteration with `++b`
  return b;  //  Return the resulting base
}            // End of method

Japt , 8 bytes

@ìX e}a2

Pruébalo en línea!

Explicación

@    }a2

Devuelve el primer número ( X) para pasar la función, comenzando en2

ìX

Convierta el número de entrada en una matriz de Xdígitos base .

e

Verifique si todos los dígitos son verdaderos.

JavaScript (ES6), 43 41 37 bytes

n=>(g=x=>x?g(x%b++?x/--b|0:n):b)(b=1)

Casos de prueba

let f =

n=>(g=x=>x?g(x%b++?x/--b|0:n):b)(b=1)

console.log(f(1   )) // 2 (1)
console.log(f(2   )) // 3 (2)
console.log(f(3   )) // 2 (11)
console.log(f(4   )) // 3 (11)
console.log(f(5   )) // 3 (12)
console.log(f(6   )) // 4 (12)
console.log(f(7   )) // 2 (111)
console.log(f(10  )) // 4 (22)
console.log(f(17  )) // 3 (122)
console.log(f(20  )) // 6 (32)
console.log(f(50  )) // 3 (1212)
console.log(f(100 )) // 6 (244)
console.log(f(777 )) // 6 (3333)
console.log(f(999 )) // 4 (33213)
console.log(f(1000)) // 6 (4344)

Brachylog , 11 bytes

;.≜ḃ₎¬∋0∧1¬

Pruébalo en línea!

Explicación

;.≜ḃ₎           The Input represented in base Output…
     ¬∋0        …contains no 0
        ∧1¬     And Output ≠ 1

Python 2 , 57 bytes

n=m=input()
b=2
while m:c=m%b<1;b+=c;m=(m/b,n)[c]
print b

Pruébalo en línea!

-1 gracias a Felipe Nardi Batista .
-2 gracias a Lynn (y ahora este es un engaño de su solución: D)

APL (Dyalog) , 20 19 bytes

1+⍣{~0∊⍺⊥⍣¯1⊢n}≢n←⎕

Pruébalo en línea!

Como de costumbre, gracias a @ Adám por ayudar en el chat y hacer que el código funcione en TIO. Además, ahorrando 1 byte.

Esto se tradfn ( trad itional f unctio n ) cuerpo. Para usarlo, debe asignarle un nombre (que está en el campo de encabezado de TIO), encerrarlo en ∇s (uno antes del nombre y otro en el campo de pie de página de TIO), y luego llamarlo usando su nombre. Como usa un quad ( ⎕) para tomar la entrada del usuario, se llama como en f \n inputlugar de lo habitualf input

¿Cómo?

1+⍣{~0∊⍺⊥⍣¯1⊢n}≢n←⎕  ⍝ Main function.
                  n←⎕ ⍝ Assigns the input to the variable n
1+⍣{           }≢     ⍝ Starting with 1, add 1 until the expression in braces is truthy
    ~0∊               ⍝ returns falsy if 0 "is in"
        ⊥             ⍝ convert
            ⊢n        ⍝ the input
         ⍣¯1          ⍝ to base
       ⍺              ⍝ left argument (which starts at 1 and increments by 1)

La función luego devuelve la base resultante.

Protón , 40 bytes

x=>filter(y=>all(digits(y,x)),2..x+3)[0]

Pruébalo en línea!

R , 79 71 66 63 65 bytes

function(n){while(!{T=T+1;all(n%/%T^(0:floor(log(n,T)))%%T)})T
T}

Pruébalo en línea!

Esta respuesta se basa en la reorganización de Giuseppe en un solo bucle.

Guardado 8 bytes gracias a JDL, y 6 bytes gracias a Giuseppe.

MATL , 13 12 bytes

`G@Q_YAA~}@Q

Pruébalo en línea!

-1 byte gracias a Luis Mendo. Este programa no maneja casos de prueba mayores de 2 ^ 53 ( flintmaxel número entero consecutivo máximo representable por un tipo de punto flotante), ya que el tipo de datos predeterminado está doubleen MATL. Sin embargo, debería poder encontrar cualquier base cero arbitraria debajo de ese número.

`            % Do while
 G           %  Push input
  @ _        %  Outputs the iteration number, negate.
     YA      %  Convert input to base given by the iteration number, the negative number is to instruct MATL we want an arbitrary high base with a integer vector rather than the default character vector we know from hexadecimal
       A~    %  If they're not all ones, repeat
         }   % But if they are equal, we finally
          @  %  Push the last base
   Q       Q %  As base 1 makes no sense, to prevent MATL from errors we always increase the iteration number by one.

PHP, 59 + 1 bytes

usando incorporados , base máxima 36:

for($b=1;strpos(_.base_convert($argn,10,++$b),48););echo$b;

sin construcciones, 63 60 + 1 bytes , cualquier base:

for($n=$b=1;$n&&++$b;)for($n=$argn;$n%$b;$n=$n/$b|0);echo$b;

Ejecutar como tubería -nRo probarlos en línea .

En realidad ,  12  11 bytes

╗1⌠╜¡m'0<⌡╓

Pruébalo en línea!

Utiliza este consenso . Gracias a Mego por la ayuda para guardar bytes en el chat .

J 26 bytes

]>:@]^:(0 e.]#.inv[)^:_ 2:

Me encantaría saber si esto se puede mejorar.

El verbo principal es una frase diádica:

>:@]^:(0 e.]#.inv[)^:_

que recibe la entrada a la izquierda y la constante 2 a la derecha. Esa frase verbal principal usa J's Do..Mientras construye, incrementando el argumento y derecho siempre que 0 sea un elemento del e.argumento original en base y.

Pruébalo en línea!

Lua , 77 76 bytes

b=2n=...N=n
while~~N>0 do
if N%b<1then
b=b+1N=n
else
N=N//b
end
end
print(b)

Pruébalo en línea!

Vía Láctea , 38 bytes

^^'%{255£2+>:>R&{~^?{_>:<;m_+¡}}^^^}

uso: ./mw base.mwg -i 3

Explicación

code                                 explanation                    stack layout

^^                                   clear the preinitialized stack []
  '                                  push the input                 [input]
   %{                              } for loop
     255£                             push next value from 0..254   [input, base-2]
         2+                           add 2 to the get the base     [input, base]
           >                          rotate stack right            [base, input]
            :                         duplicate ToS                 [base, input, input]
             >                        rotate stack right            [input, base, input]
              R                       push 1                        [input, base, input, 1]
               &{~             }      while ToS (=remainder) is true ...
                  ^                    pop ToS                      [input, base, number]
                   ?{         }        if ToS (=quotient) ...
                     _>:<;              modify stack                [input, base, number, base]
                           m            divmod                      [input, base, quotient, remainder]
                           _+¡         else: output ToS (0) + SoS and exit
                                ^^^   pop everything but the input.

Estoy seguro de que esto se puede acortar usando un ciclo while en lugar de un ciclo for, pero no pude hacerlo funcionar.

Apilado , 23 bytes

{!2[1+][n\tb all]until}

Pruébalo en línea!

Esto incrementa ( [1+]) J a partir de dos ( 2) mientras que la representación _J base de la entrada no tiene ceros ( ally until).

Perl 5 , 52 + 2 ( -pa) = 54 bytes

$\=1;while($_&&=$F[0]){$\++;$_=int$_/$\while$_%$\}}{

Pruébalo en línea!