Un repdigit è un numero naturale che può essere scritto solo ripetendo la stessa cifra. Ad esempio, 777è una modifica, poiché è composta esclusivamente dalla cifra 7ripetuta tre volte.

Questo non si limita ai soli numeri decimali (base 10), tuttavia:

• Ogni numero di Mersenne (nella forma M _n = 2 ⁿ -1 ) è un riporto se scritto in binario (base 2).
• Ogni numero è banalmente una riprogettazione quando scritto in unario (base 1).
• Ogni numero npuò anche essere banalmente scritto come repdigit 11in base n-1(per esempio, 17quando è scritto in esadecimale (base 16) 11e 3quando è scritto anche in binario (base 2) 11).

La sfida qui è trovare altre basi in cui il numero di input può essere una modifica.

Ingresso

Un numero intero positivo x > 3, in qualsiasi formato conveniente.

Produzione

Un numero intero positivo bcon (x-1) > b > 1cui la rappresentazione delle xdella base bè un numero a cifra ripetuta.

• Se non besiste, output 0o un valore di falso .
• Se ne besistono più di uno, è possibile emetterne uno o tutti.

Regole

• La (x-1) > b > 1restrizione è impedire le banali conversioni alla base unaria o "sottrarre una". Il numero di output può essere scritto in unario o in qualsiasi base conveniente, ma la base stessa non deve essere una delle conversioni banali.
• L'ingresso / uscita può avvenire con qualsiasi metodo adatto .
• Si applicano le restrizioni standard sulle scappatoie .

Esempi

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)

Gelatina, 11 9 byte

bRI¬P€TḊṖ

Restituisce un elenco di basi, che è vuoto (falsy) se non ce n'è. Provalo online!

Come funziona

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

Apparentemente l'Unario di Pyth qcontrolla un elenco che ha tutti i valori univoci circa 10 giorni fa. Apparentemente investigare i bug di Pyth migliora i punteggi di golf.

Filtra l'elenco [2..input-1)su se l'insieme univoco di cifre dell'input in quella base è lunghezza 1.

Test Suite

Spiegazione:

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

Rubino, 87 69 63 byte

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

Ho dovuto implementare la conversione di base a mano, poiché i builtin di Ruby vanno solo alla base 36 ...

Restituisce nilper non trovato.

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

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

Nessuna ricorsione, prova solo tutte le basi e genera un insieme di quelli che funzionano.

È allettante codificare be din un singolo numero, ma ci vogliono troppe espressioni tra parentesi per estrarle. 77 byte:

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 byte:

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

Emette il primo bche funziona, o 0se nessuno lo fa.

Un'unità rep xdi dcifre cin base bha valore x==c*(b**d-1)/(b-1). Equivalentemente, x*(b-1)==c*(b**d-1).

Il valore cdeve essere x%b, l'ultima cifra. Non vedo un modo per determinare daritmeticamente, quindi il codice cerca tutte le possibilità per vedere se qualcuno di loro funziona.

Hai salvato 5 byte copiando il trucco di Dennis di fornire un output falso quando braggiunge x-1prendendo il modulo di output x-1. Un altro byte salvato da Dennis mi ricorda che l'espiazione ha inspiegabilmente una precedenza maggiore ~.

Una soluzione di uguale lunghezza con inanziché 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

Rubino, 50 byte

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

Vorrei davvero rimuovere quello spazio fastidioso ma come nuovo arrivato al rubino, non ho ancora familiarità con le sue stranezze sintattiche.

Emojicode , 214 byte

(77 caratteri):

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

Stampa i risultati nella base 9.

Ho intenzione di fare un golf con il codice emojicode da un paio di settimane ormai, ma la lingua è diventata solo di recente abbastanza stabile da funzionare effettivamente con 😉. Come bonus, questa domanda si avvale dell'unico pezzo di funzionalità in cui l'emojicode è davvero bravo: rappresentare numeri interi in altre basi.

Ungolfed (👴 è un commento di linea in 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 byte

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

Provalo su Ideone .

Idea

Qualsiasi modifica x della base b> 1 e la cifra d <b soddisfano quanto segue.

Poiché d <b , la mappa (b, d) ↦ cb + d è iniettiva.

Inoltre, poiché b, x> 1 , abbiamo c <x , quindi cb + d <cb + b = (c + 1) b ≤ xb .

Ciò significa che, per trovare valori adeguati per c e d per una data base b , possiamo scorrere tutti i in [0,…, bx) e verificare se (b - 1) x == (i% b) (b ^{i / b} - 1) .

Codice

Il nome lambda f verifica se (b - 1) x è nell'insieme {(i% b) (b ^{i / b} - 1) | 0 ≤ i <bx} , a partire dal valore b = 2 .

• Se il test ha esito positivo, si restituisce b .

• Altrimenti, chiamiamo F nuovamente, con lo stesso x e b incrementato di 1 .

Poiché alla fine b può raggiungere x - 1 , prendiamo il risultato finale modulo x - 1 per restituire 0 in questo caso. Si noti che ciò non accadrà se b = 2 soddisfa la condizione, poiché viene restituito senza ricorrere. Tuttavia, la domanda garantisce che b = 2 <x - 1 in questo caso.

Perl 6, 45 43 42 byte

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

Spiegato (sorta di)

Per riferimento, una variabile $^xin { ... }è la stessa di fare-> $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 *)fornisce un elenco invertito di cifre / "cifre" per $nin base$b

Polymod (per davvero): il metodo polymod è quasi come una versione più potente della divmodfunzione di Python . $n.polymod(*@args)divide $ n per ogni valore in * @ args, aggiungendo il resto ( $n mod $x) all'elenco che restituisce e usando il quoziente per la divisione successiva. Sento di averlo spiegato male, quindi ecco alcuni esempi (scritti in perl 6, ma abbastanza puliti da essere compresi dalla maggior parte spero):

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 byte

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

{... ⍵... }funzione anonima da applicare a x(rappresentati da ⍵)
b←1+⍳⍵-3numeri interi da 2 - ⍵-2 memorizzati come b
⍵{... }¨per ogni elemento in b ( ⍵), applica la funzione {... }con x come argomento sinistro ⍺
⍵⊥⍣¯1⊢⍺converti x in quella base
1=≢∪è 1 uguale al conteggio di cifra unica?
b/⍨elementi di b dove vero (che esiste solo una cifra univoca).

Casi di esempio

Se non esiste alcuna base, l'output è vuoto (che è falso), come può essere dimostrato da questo programma:

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

Questo stampa 'Falso'

Pyth, 26 19 byte

hMfql{eT1m,djQdr2tQ

Provalo qui!

Aggiungerò una spiegazione dopo che ho giocato a golf. Guarda questa risposta per un'implementazione e una spiegazione più brevi.

MATL , 15 14 byte

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

Funziona con la versione corrente (14.0.0) del linguaggio / compilatore.

Se non esiste alcuna base, l'output è vuoto (che è falso).

Provalo 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 byte

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

Funzione anonima, non troppo complicata. Filtra semplicemente le basi in base alla rigidità.

Python 2, 75 byte

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

Una porta della mia risposta rubino. Stampa tutte le basi valide se ne esistono.

Julia, 45 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce un array di numeri interi. Per chiamarlo, assegnarlo a una variabile. Restituirà tutte le basi applicabili o un array vuoto. Non ci sono problemi con basi di grandi dimensioni.

Innanzitutto generiamo l'intervallo inclusivo [2, n - 2], dove n è l'input. Abbiamo quindi filterl'elenco di soli numeri interi b per i quali n nella base b ha meno di 2 cifre univoche. Per fare ciò, per ogni intero b nell'intervallo, otteniamo le cifre di n nella base b come un array usando digits, otteniamo elementi unici usando ∪e otteniamo l'indice dell'ultimo elemento (cioè la lunghezza) usando endof.

Brachylog , 12 byte

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

Provalo online! (come generatore!)

Prende input attraverso la variabile input e genera una base attraverso la variabile output nel caso ciò sia possibile, altrimenti fallendo. Allo stesso tempo, funziona anche come generatore che genera un elenco di tutte le basi, in cui tale elenco può essere vuoto.

Idealmente potrebbe sembrare qualcosa del genere ḃ↙.=&>>, probabilmente sacrificando la funzionalità del generatore in quella forma o in una simile (dal momento che alla fine colpirà unaria), ma a partire da ora 12 byte è il più breve che io sappia ottenere.

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

Rubino , 46 43 byte

Utilizza la funzione Numeri # interi introdotta in Ruby 2.4 per evitare di dover dividere manualmente.

-3 byte grazie a @Jordan.

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

Provalo online!

05AB1E , 7 byte

ÍL¦ʒвÙg

Emette tutti i valori possibili o un elenco vuoto come valore di falso (anche se gli output tecnicamente validi sono anche falsi, poiché solo 105AB1E è vero e tutto il resto è falso).

Provalo online o verifica tutti i casi di test .

Spiegazione:

Í        # 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 byte

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

Provalo online!

Emette tutte le risposte possibili o nulla se non esiste una soluzione.