Um repdigit é um número natural que pode ser gravado apenas repetindo o mesmo dígito. Por exemplo, 777é um re-dígito, pois é composto exclusivamente pelo dígito 7repetido três vezes.

Isso não se limita a números decimais (base 10), no entanto:

• Todo número de Mersenne (no formato M _n = 2 ⁿ -1 ) é um re-dígito quando escrito em binário (base 2).
• Todo número é trivialmente um repdigit quando escrito em unário (base 1).
• Cada número ntambém pode ser trivialmente escrito como o repdigit 11na base n-1(por exemplo, 17quando escrito em hexadecimal (base 16) 11, e 3quando escrito em binário (base 2) também 11).

O desafio aqui é encontrar outras bases nas quais o número de entrada possa ser um re-dígito.

Entrada

Um número inteiro positivo x > 3, em qualquer formato conveniente.

Saída

Um número inteiro positivo bem (x-1) > b > 1que a representação de xna base bé um re-dígito.

• Se não bexistir, saída 0ou algum valor falsey .
• Se bexistirem vários , você pode gerar um ou todos eles.

Regras

• A (x-1) > b > 1restrição é impedir as conversões triviais em unárias ou na base "subtrair uma". O número de saída pode ser escrito em uma base unária ou em qualquer base conveniente, mas a base em si não deve ser uma das conversões triviais.
• A entrada / saída pode ser feita por qualquer método adequado .
• Aplicam-se restrições de brecha padrão .

Exemplos

In --> Out
11 --> 0            (or other falsey value)
23 --> 0            (or other falsey value)
55 --> 10           (since 55 is 55 in base 10)
90 --> 14           (since 90 is 66 in base 14 ... 17, 29, 44 also allowed)
91 --> 9            (since 91 is 111 in base 9 ... 12 also allowed)

Geléia, 11 9 bytes

bRI¬P€TḊṖ

Retorna uma lista de bases, que está vazia (falsy) se não houver nenhuma. Experimente online!

Como funciona

bRI¬P€TḊṖ  Main link. Argument: x (number)

 R         Range; yield [1, ..., x].
b          Base; convert x to base n, for each n in the range.
  I        Compute the increment (differences of successive values) of each array
           of base-n digits. This yields only 0's for a repdigit.
   ¬       Apply logical NOT to each increment.
    P€     Compute the product of all lists of increments.
      T    Get the indices of all truthy products.
       Ḋ   Discard the first index (1).
        Ṗ  Discard the last index (x - 1).

Pyth, 11 10

fqjQT)r2tQ

Aparentemente, o unário de Pyth qverifica se há uma lista com todos os valores únicos há cerca de 10 dias. Aparentemente, investigar os erros do Pyth melhora a pontuação do golfe.

Filtra a lista [2..input-1)se o conjunto exclusivo de dígitos da entrada nessa base for o comprimento 1.

Suíte de teste

Explicação:

r2tQ     ##  generate the python range from 2 to the input (Q) - 1
         ##  python range meaning inclusive lower and exclusive upper bounds
f        ##  filter that list with lambda T:
  jQT    ##  convert the input to base T
 q    )  ##  true if the resulting list digits has all equal elements

Ruby, 87 69 63 bytes

->x{(2..x-2).find{|b|y=x;a=y%b;a=0if a!=y%b while(y/=b)>0;a>0}}

Eu tive que implementar a conversão de base manualmente, já que os componentes internos do Ruby só chegam à base 36 ...

Retorna nilpara não encontrado.

->x{      # anonymous lambda that takes one argument
(2..x-2)  # range of the possible bases to search over
.find{    # return the first element that satisfies the block, or nil if none
|b|       # b represents the base currently being tested
y=x;      # a temporary value to avoid mutating the original value of x
a=y%b;    # the first (well, last) digit in base b, which will be compared to

                   y/=b      # divide the number by the base
   if a!=y%b                 # if this digit does not match (is different)...
a=0                          # set a to a value representing "failure"
             while(    )>0;  # keep doing this until we get zero (no digits left)

a>0       # return whether a has maintained its original value (no digit change)
}}        # find then returns the first element for which this is true (or nil)

Python, 71 72 78 bytes

lambda x:{b for b in range(2,x-1)for d in range(x)if x*~-b==x%b*~-b**d}

Sem recursão, apenas tenta todas as bases e gera um conjunto daquelas que funcionam.

É tentador codificar be dem um único número, mas são necessárias muitas expressões entre parênteses para extraí-las. 77 bytes:

lambda x:{k/x for k in range(2*x,x*x-x))if x*~-(k/x)==x%(k/x)*~-(k/x)**(k%x)}

72 bytes:

f=lambda x,b=2:b*any(x*~-b==x%b*~-b**d for d in range(x))or f(x,b+1)%~-x

Produz o primeiro bque funciona, ou 0se não houver.

Um representante-unidade xde ddígitos de cem base de btem valor x==c*(b**d-1)/(b-1). Equivalentemente x*(b-1)==c*(b**d-1).

O valor cdeve ser x%bo último dígito. Não vejo uma maneira de determinar daritmeticamente, então o código tenta todas as possibilidades para ver se algum deles funciona.

Salvo 5 bytes, copiando o truque de Dennis de dar uma saída Falsey quando balcances x-1tomando o módulo de saída x-1. Outro byte salvo de Dennis me lembrando que a exponenciação inexplicavelmente tem maior precedência disso ~.

Uma solução de comprimento igual com em invez de any.

f=lambda x,b=2:b*(x*~-b in[x%b*~-b**d for d in range(x)])or f(x,b+1)%~-x

Ruby, 50 bytes

->n{(2..n-2).find{|b,i=n|i%b==(i/=b)%b ?redo:i<1}}

Eu realmente gostaria de remover esse espaço irritante, mas como novato em ruby, ainda não estou familiarizado com suas peculiaridades sintáticas.

Emojicode , 214 bytes

(77 caracteres):

🐇🐹🍇🐇🐖🏁➡🚂🍇🍦b🍺🔲🗞🔷🔡😯🔤🔤🚂🍮i 2🍮n 0🔁◀i➖b 1🍇🍦v🔷🔡🚂b i🍊▶🐔🔫v🔪v 0 1📏v🍇🍮n i🍉🍫i🍉😀🔷🔡🚂n 9🍎0🍉🍉

Imprime os resultados na base 9.

Estou pensando em fazer um código de golfe com emojicode há algumas semanas, mas o idioma só recentemente se tornou estável o suficiente para realmente trabalhar com 😉. Como um bônus, esta pergunta faz uso da única parte da funcionalidade emojicode que é realmente boa: representar números inteiros em outras bases.

Ungolfed (👴 é um comentário de linha no emojicode)

🐇🐹🍇         👴 define main class "🐹"
  🐇🐖🏁➡🚂🍇  👴 define main method

    👴 read an integer from stdin, store it in frozen variable "b"
    🍦 b 🍺 🔲 🗞 🔷🔡😯🔤🔤 🚂

    🍮 i 2  👴 i = 2
    🍮 n 0  👴 n = 0

    🔁◀i➖b 1🍇     👴 while i < b - 1
      🍦 v 🔷🔡🚂b i  👴 v = the string representation of b in base i

      👴 Split v on every instance of the first character of v.
      👴 If the length of that list is greater than the actual length of v,
      👴 n = i
      🍊▶🐔🔫v🔪v 0 1📏v🍇
        🍮 n i
      🍉

      🍫 i  👴 increment i
    🍉
    😀 🔷🔡🚂 n 9  👴 represent n in base 9 instead of 10, to save a byte 😜
    🍎 0          👴 return error code 0
  🍉
🍉

Python 2, 79 bytes

f=lambda x,b=2:~-b*x in[i%b*~-b**(i/b)for i in range(b*x)]and b or f(x,-~b)%~-x

Experimente em Ideone .

Idéia

Qualquer repdigito x da base b> 1 e dígito d <b satisfaz o seguinte.

Como d <b , o mapa (b, d) ↦ cb + d é injetivo.

Além disso, como b, x> 1 , temos c <x , então cb + d <cb + b = (c + 1) b ≤ xb .

Isso significa que, para encontrar valores adequados para c e d para uma dada base b , podemos iterar todo o i em [0,…, bx) e verificar se (b - 1) x == (i% b) (b ^{i / b} - 1) .

Código

O teste lambda f nomeado se (b - 1) x está no conjunto {(i% b) (b ^{i / b} - 1) | 0 ≤ i <bx} , começando com o valor b = 2 .

• Se o teste foi bem sucedido, retornamos b .

• Else, chamamos f novamente, com a mesma x e b incrementado por 1 .

Como b pode eventualmente chegar a x - 1 , tomamos o resultado final do módulo x - 1 para retornar 0 neste caso. Observe que isso não acontecerá se b = 2 satisfizer a condição, pois ela é retornada sem repetir. No entanto, a questão garante que b = 2 <x - 1 neste caso.

Perl 6, 45 43 42 bytes

{grep 2..$^x-2: {[==] $x.polymod($_ xx*)}}

Explicado (mais ou menos)

Para referência, uma variável $^xin { ... }é igual a fazer-> $x { ... }

{grep 2..$^x-2: {[==] $x.polymod($_ xx*)}}
{                                          # Anonymous function taking $x
 grep                                      # Return the all values in
      2..$^x-2: {                          # Range from 2 to $x - 2 satisfying:
                 [==]                      #     Reduce with ==:
                      $x.polymod(          #         (See below for polymod)
                                 $_ xx*    #         An infinite list containing
                                           #         the current value
                                       )}}

Polymod (TL; DR): $n.polymod($b xx *)fornece uma lista invertida de dígitos / 'dígitos' $nna base$b

Polymod (de verdade): O método polymod é quase como uma versão mais poderosa da divmodfunção do python . $n.polymod(*@args)divide $ n por cada valor em * @ args, adicionando o restante ( $n mod $x) à lista que ele retorna e usando o quociente para a próxima divisão. Eu sinto que expliquei mal, então aqui estão alguns exemplos (escritos em perl 6, mas limpos o suficiente para serem entendidos pela maioria dos que espero):

12.polymod(7)    # returns (5, 1)
# Roughly equivalent to:
(12 mod 7, 12 div 7)

86400.polymod(60,60,24) # returns (0, 0, 0, 1)
# Roughly equivalent to (this will give you an array rather than a list):
my $n = 86400;
my @remainders; # Here lies the end result
for (60, 60, 24) -> $divisor {
    @remainders.push( $n mod $divisor );
    $n div= $divisor;
}
@remainders.push($n)

# This is essentially the base conversion algorithm everyone
# knows and loves rolled into a method.
# Given an infinite list of divisors, polymod keeps going until
# the remainder given is 0.     
0xDEADBEEF.polymod(16 xx *) # returns (15 14 14 11 13 10 14 13)
# Roughly equivalent to (but gives an array rather than a list):
my $n = 0xDEADBEEF;
my @remainders; # Here lies the end result
while $n > 0 {
    @remainders.push( $n mod 16 );
    $n div= 16;
}

Dyalog APL , 28 bytes

 {b/⍨⍵{1=≢∪⍵⊥⍣¯1⊢⍺}¨b←1+⍳⍵-3}

{... ⍵... }função anónimo a ser aplicada a x(representado por ⍵)
b←1+⍳⍵-3inteiros a partir de 2 - ⍵-2 armazenados como b
⍵{... }¨para cada elemento b ( ⍵), aplicar a função {... }com X como argumento esquerda ⍺
⍵⊥⍣¯1⊢⍺convertido x para que a base
1=≢∪é um igual à contagem de dígito único?
b/⍨elementos de b onde verdadeiro (que existe apenas um dígito único).

Casos de exemplo

Se não houver base, a saída está vazia (o que é falsey), como pode ser demonstrado por este programa:

 WhatIsEmpty
 →''/TRUE ⍝ goto (→) TRUE: if (/) emptystring ('')
 'False'
 →END       
TRUE:       
 'True'     
END:        

Isso imprime 'False'

Pitão, 26 19 bytes

hMfql{eT1m,djQdr2tQ

Experimente aqui!

Adicionará uma explicação depois que eu jogar isso. Veja esta resposta para uma implementação e explicação mais curtas.

MATL , 15 14 bytes

3-:Q"G@:YAd~?@

Isso funciona com a versão atual (14.0.0) do idioma / compilador.

Se não houver base, a saída está vazia (que é falsey).

Experimente online!

3-:Q    % take input x implicitly. Generate range of possible bases: [2,3,...,x-2]
"       % for each base b
  G     %   push input again
  @:    %   generate vector of (1-based) digits in base b: [1,2,...,b]
  YA    %   convert to that base
  d~    %   differences between consecutive digits; negate
  ?     %   if all values are true (that is, if all digits were equal)
    @   %     push that base
        %   end if implicitly
        % end for each implicitly
        % display implicitly

Mathematica, 55 bytes

Cases[4~Range~#-2,a_/;Equal@@#~IntegerDigits~a]/.{}->0&

Função anônima, não muito complicada. Apenas filtra as bases com base no repdigit-ness.

Python 2, 75 bytes

n=input()
b=1
while b<n-2:
 i=n;b+=1
 while i%b==i/b%b:i/=b
 if i<b:print b

Um porto da minha resposta rubi. Imprime todas as bases válidas, se houver alguma.

Julia, 45 bytes

n->filter(b->endof(∪(digits(n,b)))<2,2:n-2)

Esta é uma função anônima que aceita um número inteiro e retorna uma matriz inteira. Para chamá-lo, atribua-o a uma variável. Ele retornará todas as bases aplicáveis ​​ou uma matriz vazia. Não há problemas com grandes bases.

Primeiro, geramos o intervalo inclusivo [2, n - 2], onde n é a entrada. Em seguida, filterlistamos apenas números inteiros b para os quais n na base b tem menos de 2 dígitos únicos. Para fazer isso, para cada número inteiro b no intervalo, obtemos os dígitos de n na base b como uma matriz usando digits, obtemos itens exclusivos usando ∪e obtemos o índice do último elemento (ou seja, o comprimento) usando endof.

Braquilog , 12 bytes

>>.ℕ₂≜&ḃ↙.=∧

Experimente online! (como um gerador!)

Leva a entrada através da variável de entrada e gera uma base através da variável de saída, caso isso seja possível, caso contrário, falhará. Ao mesmo tempo, também funciona como um gerador que gera uma lista de todas as bases, onde essa lista pode estar vazia.

Idealmente, isso poderia parecer algo como ḃ↙.=&>>, possivelmente sacrificando a funcionalidade do gerador dessa forma ou semelhante (uma vez que eventualmente chegaria a ser unário), mas a partir de agora 12 bytes é o mais curto que eu sei como obtê-lo.

     ≜          Assign an integer value to
  .             the output variable
   ℕ₂           which is greater than or equal to 2
 >              and less than a number
>               which is less than the input.
      &         The input
       ḃ↙.      in base-(the output)
          =     is a repdigit.
           ∧    (which is not necessarily the output)

Ruby , 46 43 bytes

Utiliza a função Número inteiro # dígitos introduzida no Ruby 2.4 para evitar a necessidade de dividir manualmente.

-3 bytes graças a @Jordan.

->n{(2..n-2).find{|i|!n.digits(i).uniq[1]}}

Experimente online!

05AB1E , 7 bytes

ÍL¦ʒвÙg

Produz todos os valores possíveis ou uma lista vazia como valor de falsey (embora as saídas tecnicamente válidas também sejam falsey, pois somente 1é verdade em 05AB1E e todo o resto é falsey).

Experimente online ou verifique todos os casos de teste .

Explicação:

Í        # Decrease the (implicit) input-integer by 2
 L       # Create a list in the range [1, input-2]
  ¦      # Remove the first value to make the range [2, input-2]
   ʒ     # Filter this list by:
    в    #  Convert the (implicit) input to the base of the number we're filtering
     Ù   #  Uniquify it, leaving only distinct digits
      g  #  Get the length of this, which is truthy (1) if all digits were the same
         # (and then output the filtered list implicitly as result)

Perl 5 -Minteger -na , 63 bytes

map{$r=$,=($c="@F")%$_;$r*=$c%$_==$,while$c/=$_;$r&&say}2..$_-2

Experimente online!

Produz todas as respostas possíveis ou nada, se não houver solução.