Encuentra el dígito de repetición más largo

17

Su tarea es tomar un número positivo como entrada, n , y generar la longitud de la representación más larga de rep-dígitos de n en cualquier base. Por ejemplo, 7 puede representarse como cualquiera de los siguientes

111_2
21_3
13_4
12_5
11_6
10_7
7_8

Los dígitos de rep son 111_2y 11_6, 111_2es más largo, por lo que nuestra respuesta es 3.

Esta es una pregunta de , por lo que las respuestas se puntuarán en bytes, con menos bytes mejor.

Casos de prueba

1   -> 1
2   -> 1
3   -> 2
4   -> 2
5   -> 2
6   -> 2
7   -> 3
8   -> 2
9   -> 2
10  -> 2
11  -> 2
26 -> 3
63  -> 6
1023-> 10

Implementación de muestra

Aquí hay una implementación en Haskell que puede usarse para generar más casos de prueba.

f 0 y=[]
f x y=f(div x y)y++[mod x y]
s x=all(==x!!0)x
g x=maximum$map(length.f x)$filter(s.f x)[2..x+1]

Pruébalo en línea!

Post Rock Garf Hunter
fuente
1
Asumiendo base > 1?
H.PWiz
2
puede agregar casos de prueba 63-> 6 y 1023-> 10 si lo desea
J42161217
1
@WheatWizard Creo que 26 lo hace, por ejemplo, está 222en la base 3.
xnor
1
¿Pueden las bases superar los 10? Si es así, para bases> 10, ¿deberíamos incluir los caracteres az? ¿Qué pasa con las bases> 36?
Rick Hitchcock
66
@RickHitchcock Las bases pueden ir arbitrariamente altas. Como no tiene que generar ningún número en ninguna base que no sea 10, no me importa cómo represente otras bases, pero deberían funcionar para bases mayores que 36.
Post Rock Garf Hunter

Respuestas:

9

Jalea , 9 bytes

b‘Ḋ$EÐfZL

Un enlace monádico que acepta y devuelve números

Pruébalo en línea! o ver un conjunto de pruebas (entradas 1 a 32 inclusive).

¿Cómo?

b‘Ḋ$EÐfZL - Link: number, n
   $      - last two links as a monad:
 ‘        -   increment = n+1
  Ḋ       -   dequeue (with implicit range build) = [2,3,4,...,n+1]
b         - convert to those bases
     Ðf   - filter keep if:
    E     -   all elements are equal
       Z  - transpose
        L - length (note:  length of the transpose of a list of lists is the length of the
          -                longest item in the original list, but shorter than L€Ṁ)

... o tal vez debería haber hecho:

bḊEÐfZLo1

Por la Lo1z.

Jonathan Allan
fuente
Entonces ... no soy el único que ha descubierto que ZLes más corto que L€Ṁ...
Erik the Outgolfer
8

JavaScript (ES6), 62 bytes

f=(n,b=2,l=0,d=n)=>d?n%b<1|n%b-d%b?f(n,b+1):f(n,b,l+1,d/b|0):l
<input oninput=o.textContent=f(this.value)><pre id=o>

Neil
fuente
2
Me encanta el HTML de prueba innecesariamente golfizado
Jakob
6

Haskell , 86 81 79 bytes

2 bytes guardados gracias a Laikoni

0!y=[]
x!y=mod x y:div x y!y
length.head.filter(all=<<(==).head).(<$>[2..]).(!)

Pruébalo en línea!

Como esto se ha calmado un poco, aquí está mi enfoque. Es una versión de golf del código de muestra que hice para la pregunta. Creo que definitivamente puede ser más corto. Solo pensé en ponerlo ahí afuera.

Post Rock Garf Hunter
fuente
Pointfree es un poco más corto: length.head.filter(all=<<(==).head).(<$>[2..]).(!).
Laikoni
@Laikoni ¡Gracias! Por alguna razón no pude encontrar la manera de ponerlo en notación sin puntos.
Post Rock Garf Hunter
Puedo recomendar pointfree.io que se basa en el convertidor de lambdabot sin puntos.
Laikoni
@Laikoni, uso bastante pointfree.io. No debo haberlo intentado aquí. Sin embargo, generalmente obtengo resultados bastante buenos.
Post Rock Garf Hunter
5

Casco , 13 11 bytes

-2 bytes gracias a zgarb

L←fȯ¬tuMBtN

Pruébalo en línea!

H.PWiz
fuente
mmpuede ser My ṠoΛ=←puede ser ȯ¬tu. Todavía no hay una función integrada para verificar que todos los elementos de una lista sean iguales ...
Zgarb
M aún ni siquiera está en la wiki :(
H.PWiz
ΓoΛ=también funciona como cuatro bytes
H.PWiz
1
Vaya, Mdebería estar en los documentos, ya que lo hemos tenido por un tiempo. Debería arreglar eso. Pero es básicamente el dual de .
Zgarb
3

Mathematica, 71 bytes

Max[L/@Select[Array[a~IntegerDigits~#&,a=#,2],(L=Length)@Union@#==1&]]&

Pruébalo en línea!

J42161217
fuente
3

05AB1E , 8 bytes

L>вʒË}нg

Pruébalo en línea!

-1 gracias a kalsowerus .

Erik el Outgolfer
fuente
L>вʒË}нgpara 8 bytes
kalsowerus
@kalsowerus No sabía que podía usar listas así ... ¡gracias!
Erik the Outgolfer
2

Python 3 , 92 87 bytes

5 bytes gracias a Halvard Hummel.

g=lambda n,b,s=1:s*(n<b)or(n%b**2%-~b<1)*g(n//b,b,s+1)
f=lambda n,b=2:g(n,b)or f(n,b+1)

Pruébalo en línea!

Monja permeable
fuente
-5 bytes
Halvard Hummel
1

Mathematica, 58 bytes

FirstCase[#~IntegerDigits~Range[#+1],l:{a_ ..}:>Tr[1^l]]&

Lanza un error (porque base-1 no es una base válida), pero es seguro ignorarlo.

Por supuesto, está bien tomar la longitud del primer repdigit ( FirstCase), ya que los números en bases más bajas no pueden ser más cortos que en bases más altas.

JungHwan Min
fuente
1

CJam (17 bytes)

{_,2>3+fb{)-!}=,}

Conjunto de pruebas en línea . Este es un bloque anónimo (función) que toma un número entero en la pila y deja un número entero en la pila.

Funciona con fuerza bruta, utilizando 3como base de respaldo para manejar los casos especiales (entrada 1o 2).

Peter Taylor
fuente
1

Perl 6 , 49 bytes

{+first {[==] $_},map {[.polymod($^b xx*)]},2..*}

Pruébalo en línea!

Explicación

{                                               }  # A lambda.
                  map {                   },2..*   # For each base from 2 to infinity...
                        .polymod($^b xx*)          #   represent the input in that base,
                       [                 ]         #   and store it as an array.
  first {[==] $_},                                 # Get the first array whose elements
                                                   # are all the same number.
 +                                                 # Return the length of that array.

El método polymod es una generalización de Python divmod: realiza una división entera repetida utilizando una lista dada de divisores y devuelve los restos intermedios.
Se puede usar para descomponer una cantidad en varias unidades:

my ($sec, $min, $hrs, $days, $weeks) = $seconds.polymod(60, 60, 24, 7);

Al pasar una secuencia perezosa como la lista de divisores, se polymoddetiene cuando el cociente llega a cero. Por lo tanto, al darle una repetición infinita del mismo número, descompone la entrada en dígitos de esa base:

my @digits-in-base-37 = $number.polymod(37 xx *);

Lo uso aquí porque permite bases arbitrariamente altas, en contraste con el .basemétodo basado en cadenas que solo admite hasta la base 36.

smls
fuente
Puede eliminar el []entorno polymodcambiando $_a@_
Jo King
1

TI-BASIC, 37 bytes

Input N
For(B,2,2N
int(log(NB)/log(B
If fPart(N(B-1)/(B^Ans-1
End

Solicita N, devuelve la salida en Ans.

Explicación

Como resumen, para cada posible base B en secuencia, primero calcula el número de dígitos de N cuando se representa en la base B, luego verifica si N es divisible por el valor representado por ese mismo número de 1 dígitos en la base B.

Input N            Ask the user for the value of N.
For(B,2,2N         Loop from base 2 to 2N. We are guaranteed a solution
                   at base N+1, and this suffices since N is at least 1.
int(log(NB)/log(B  Calculate the number of digits of N in base B,
                   placing the result in Ans.
                   This is equivalent to floor(log_B(N))+1.
          (B-1)/(B^Ans-1   The value represented by Ans consecutive
                           1-digits in base B, inverted.
If fpart(N         Check whether N is divisible by the value with Ans
                   consecutive 1-digits, by multiplying it by the inverse
                   and checking its fractional part.
                   Skips over the End if it was divisible.
End                Continue the For loop, only if it was not divisible.
                   The number of digits of N in base B is still in Ans.
calc84maniac
fuente
0

Java 8, 111 bytes

n->{int r=0,i=1,l;for(String t;++i<n+2;r=(l=t.length())>r&t.matches("(.)\\1*")?l:r)t=n.toString(n,i);return r;}

El número de bytes de 111 también es un dígito de repetición. ;)

Explicación:

Pruébalo aquí

n->{                            // Method with Integer as parameter return-type
  int r=0,                      //  Result-integer
      i=1,                      //  Index-integer
      l;                        //  Length-integer
  for(String t;                 //  Temp-String
      ++i<n+2;                  //  Loop from 2 to `n+2` (exclusive)
      r=                        //    After every iteration, change `r` to:
        (l=t.length())>r        //     If the length of `t` is larger than the current `r`
        &t.matches("(.)\\1*")?  //     and the current `t` is a rep-digit:
         l                      //      Change `r` to `l` (the length of the rep-digit)
        :                       //     Else:
         r)                     //      Leave `r` as is
    t=n.toString(n,i);          //   Set String representation of `n` in base-`i` to `t`
                                //  End of loop (implicit / single-line body)
  return r;                     //  Return the result-integer
}                               // End of method
Kevin Cruijssen
fuente
Las Lambdas se introdujeron en Java 8.
Jakob
1
@Jakob Woops ... No estoy seguro de por qué escribí 7 ... Ya sea porque recientemente miré una respuesta mía de Java 7, o simplemente un error tipográfico ... Gracias por la corrección de cualquier manera, por supuesto debería haber sido 8 ...> .>
Kevin Cruijssen
0

Java 8, 79 bytes

Una lambda de Integera Integer.

n->{int m,b=2,l;for(;;b++){for(m=n,l=0;m>0&m%b==n%b;l++)m/=b;if(m<1)return l;}}

Lambda sin golf

n -> {
    int m, b = 2, l;
    for (; ; b++) {
        for (m = n, l = 0; m > 0 & m % b == n % b; l++)
            m /= b;
        if (m < 1)
            return l;
    }
}

Comprueba las radios en orden creciente desde 2 hasta que se encuentra una raíz de dígitos rep. Se basa en el hecho de que la raíz más pequeña corresponderá a una representación con la mayor cantidad de dígitos.

mes una copia de la entrada, bes la raíz y les el número de dígitos marcados (y, en última instancia, la longitud de la brepresentación de la raíz ).

Jakob
fuente
0

Burlesque, 24 bytes

(ver la solución correcta a continuación)

J2jr@jbcz[{dgL[}m^>]

Ver en acción .

J2jr@ -- boiler plate to build a list from 2..N
jbcz[ -- zip in N
{dgL[}m^ -- calculate base n of everything and compute length
>]    -- find the maximum.

Al menos si mi intuición es correcta, ¿una representación de dígitos de repetición siempre será más larga? De lo contrario, uhm ...

J2jr@jbcz[{dg}m^:sm)L[>]

:sm -- filter for "all elements are the same"
mroman
fuente
1
La representación de base 2 siempre será más larga, intente, por ejemplo, con la entrada 26 y verá que su primera solución es incorrecta
Leo