Encontre o dígito de repetição mais longo


17

Sua tarefa é pegar um número positivo como entrada, n , e gerar o comprimento da representação mais longa de dígitos em n em qualquer base. Por exemplo, 7 pode ser representado como qualquer um dos seguintes

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

Como os dígitos repetidos são 111_2e 11_6, 111_2é maior, nossa resposta é 3.

Esta é uma questão de para que as respostas sejam pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

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

Implementação de amostra

Aqui está uma implementação no Haskell que pode ser usada para gerar mais casos de teste.

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]

Experimente online!


11
Asuming base > 1?
H.PWiz

2
você pode adicionar casos de teste 63-> 6 e 1023-> 10 se você gosta
J42161217

11
@WheatWizard Eu acho que 26 faz isso, por exemplo, é 222na base 3.
xnor

11
As bases podem ir acima de 10? Nesse caso, para bases> 10, devemos incluir os caracteres az? E as bases> 36?
21717 Rick Stallone

6
As bases @RickHitchcock podem subir arbitrariamente. Como você não precisa gerar números em nenhuma base além de 10, não me importo como você representa outras bases, mas elas devem funcionar para bases maiores que 36.
Post Rock Garf Hunter

Respostas:


9

Geléia , 9 bytes

b‘Ḋ$EÐfZL

Um link monádico que aceita e retorna números

Experimente online! ou consulte uma suíte de testes (entradas de 1 a 32 inclusive).

Quão?

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€Ṁ)

... ou talvez eu devesse ter feito:

bḊEÐfZLo1

Para o Lo1z.


Então ... eu não sou o único a ter descoberto ZLé menor do que L€Ṁ...
Erik o 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>


2
Eu amo o teste desnecessariamente jogado HTML
Jakob

6

Haskell , 86 81 79 bytes

2 bytes salvos graças a Laikoni

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

Experimente online!

Como isso diminuiu um pouco, aqui está minha abordagem. É uma versão em golf do código de amostra que fiz para a pergunta. Eu acho que definitivamente pode ser mais curto. Eu apenas pensei em colocá-lo lá fora.


Pointfree é um pouco menor: length.head.filter(all=<<(==).head).(<$>[2..]).(!).
Laikoni

@Laikoni Thanks! Por alguma razão, não fui capaz de descobrir como inseri-lo em notação sem sentido.
Post Rock Garf Hunter

Posso recomendar o pointfree.io, que é baseado no conversor sem pontos do lambdabot.
Laikoni

@Laikoni Eu uso o pointfree.io um pouco. Eu não devo ter tentado aqui. Normalmente, eu obtenho bons resultados.
Post Rock Garf Hunter

5

Casca , 13 11 bytes

-2 bytes graças ao zgarb

L←fȯ¬tuMBtN

Experimente online!


mmpode ser Me ṠoΛ=←pode ser ȯ¬tu. Ainda não é um built-in para verificar que todos os elementos de uma lista são iguais ...
Zgarb

M ainda não está no wiki :(
H.PWiz 6/17/17

ΓoΛ=também funciona como quatro bytes
H.PWiz

11
Ops, isso Mdeve estar nos documentos, já que já há algum tempo. Eu deveria consertar isso. Mas é basicamente o dual de .
Zgarb 6/08/19





1

Mathematica, 58 bytes

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

Lança um erro (porque a base-1 não é uma base válida), mas é seguro ignorar.

Obviamente, não há problema em assumir o comprimento do primeiro repdigit ( FirstCase), pois os números nas bases inferiores não podem ser mais curtos do que nas bases superiores.


1

CJam (17 bytes)

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

Conjunto de testes online . Este é um bloco anônimo (função) que pega um número inteiro na pilha e deixa um número inteiro na pilha.

Funciona com força bruta, usando 3como base de fallback para lidar com casos especiais (entrada 1ou 2).


1

Perl 6 , 49 bytes

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

Experimente online!

Explicação

{                                               }  # 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.

O método polymod é uma generalização do Python divmod: ele executa divisão inteira repetida usando uma determinada lista de divisores e retorna os restantes intermediários.
Pode ser usado para decompor uma quantidade em várias unidades:

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

Ao passar uma sequência lenta como a lista de divisores, polymodpára quando o quociente chega a zero. Assim, dando-lhe uma repetição infinita do mesmo número, decompõe a entrada em dígitos dessa base:

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

Eu uso isso aqui porque permite bases arbitrariamente altas, em contraste com o .basemétodo baseado em string, que suporta apenas a base 36.


Você pode remover o []torno polymodmudando $_para@_
Jo rei

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, retorna a saída em Ans.

Explicação

Como uma visão geral, para cada possível base B em seqüência, ele primeiro calcula o número de dígitos de N quando representado na base B, depois verifica se N é divisível pelo valor representado pelo mesmo número de 1 dígito na 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.


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

A contagem de bytes de 111 também é um dígito repetitivo. ;)

Explicação:

Experimente aqui.

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

Lambdas foram introduzidos no Java 8.
Jakob

11
@Jakob Woops .. Não sei por que digitei 7 .. Ou porque recentemente olhei para trás para uma resposta minha do Java 7, ou apenas um erro de digitação .. Obrigado pela correção de qualquer maneira, é claro que deveria ter sido 8 ...> .>
Kevin Cruijssen

0

Java 8, 79 bytes

Um lambda de Integerpara 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 ungolfed

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

Verifica as radições em ordem crescente de 2 até que uma raiz de dígitos repetidos seja encontrada. Baseia-se no fato de que a menor raiz desse tipo corresponderá a uma representação com mais dígitos.

mé uma cópia da entrada, bé a raiz e lé o número de dígitos verificados (e, finalmente, o comprimento da brepresentação da raiz ).


0

Burlesco, 24 bytes

(veja a solução correta abaixo)

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

Veja em ação .

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.

Pelo menos se minha intuição estiver certa de que uma representação de dígito repetitivo sempre será mais longa? Caso contrário, uhm ...

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

:sm -- filter for "all elements are the same"

11
Base-2 representação será sempre mais longa, tente por exemplo, com a entrada de 26 e você verá que a sua primeira solução é incorreta
Leo
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.