Un chiffre est un nombre naturel qui peut être écrit uniquement en répétant le même chiffre. Par exemple, 777est un chiffre, car il est uniquement composé du chiffre 7répété trois fois.

Cependant, cela ne se limite pas aux nombres simplement décimaux (base 10):

• Chaque nombre de Mersenne (de la forme M _n = 2 ⁿ -1 ) est un chiffre lorsqu'il est écrit en binaire (base 2).
• Chaque nombre est trivialement un chiffre lorsqu'il est écrit en unaire (base 1).
• Chaque nombre npeut également être trivialement écrit comme le chiffre 11de base dans la base n-1(par exemple, 17lorsqu'il est écrit en hexadécimal (base 16) 11, et 3lorsqu'il est écrit en binaire (base 2) l'est également 11).

Le défi ici est de trouver d' autres bases où le numéro d'entrée peut être un chiffre.

Contribution

Un entier positif x > 3, dans n'importe quel format pratique.

Production

Un entier positif bavec (x-1) > b > 1où la représentation de xdans la base best un chiffre.

• S'il n'en bexiste pas, sortie 0ou valeur Falsey .
• S'il en bexiste plusieurs, vous pouvez en sortir une partie ou la totalité.

Règles

• La (x-1) > b > 1restriction est d'empêcher les conversions triviales en unaire ou la base "soustraire une". Le numéro de sortie peut être écrit en unaire ou dans n'importe quelle base pratique, mais la base elle-même ne doit pas être l'une des conversions triviales.
• L'entrée / sortie peut se faire via n'importe quelle méthode appropriée .
• Des restrictions standard contre les échappatoires s'appliquent.

Exemples

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ée, 11 9 octets

bRI¬P€TḊṖ

Renvoie une liste de bases, qui est vide (fausse) s'il n'y en a pas. Essayez-le en ligne!

Comment ça marche

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 dix

fqjQT)r2tQ

Apparemment, Pyth recherche unaire qune liste qui a toutes les valeurs uniques d'il y a environ 10 jours. Apparemment, enquêter sur les bugs Pyth améliore les scores de golf.

Filtre la liste [2..input-1)si l'ensemble unique de chiffres de l'entrée dans cette base est de longueur 1.

Suite de tests

Explication:

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

Rubis, 87 69 63 octets

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

J'ai dû implémenter la conversion de base à la main, car les buildins de Ruby ne montent qu'à la base 36 ...

Renvoie nilpour introuvable.

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

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

Pas de récursivité, essaie simplement toutes les bases et sort un ensemble de celles qui fonctionnent.

Il est tentant de coder bet den un seul numéro, mais il faut trop d'expressions entre parenthèses pour les extraire. 77 octets:

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

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

Sort le premier bqui fonctionne, ou 0si aucun ne fonctionne.

Une unité xde répétition de dchiffres de cen base ba une valeur x==c*(b**d-1)/(b-1). De manière équivalente, x*(b-1)==c*(b**d-1).

La valeur cdoit être x%ble dernier chiffre. Je ne vois cependant aucun moyen de déterminer darithmétiquement, donc le code essaie toutes les possibilités pour voir si l'une d'entre elles fonctionne.

Enregistré 5 octets en copiant l'astuce de Dennis de donner une sortie falsey quand batteint x-1en prenant le modulo de sortie x-1. Un autre octet sauvé de Dennis me rappelant que l'exponentiation est inexplicablement plus prioritaire ~.

Une solution de longueur égale avec inau lieu 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

Rubis, 50 octets

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

Je voudrais vraiment supprimer cet espace ennuyeux, mais en tant que nouveau venu dans ruby, je ne connais pas encore bien ses bizarreries syntaxiques.

Emojicode , 214 octets

(77 caractères):

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

Imprime les résultats en base 9.

J'avais l'intention de faire un golf de code avec emojicode depuis quelques semaines maintenant, mais le langage n'est devenu que suffisamment stable pour fonctionner avec 😉. En prime, cette question utilise le seul élément de fonctionnalité qu'emojicode est en fait vraiment bon: représenter des entiers dans d'autres bases.

Ungolfed (👴 est un commentaire de ligne en 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 octets

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

Essayez-le sur Ideone .

Idée

Tout chiffre x de la base b> 1 et du chiffre d <b satisfait aux conditions suivantes.

Puisque d <b , la carte (b, d) ↦ cb + d est injective.

De plus, puisque b, x> 1 , nous avons c <x , donc cb + d <cb + b = (c + 1) b ≤ xb .

Cela signifie que, pour trouver des valeurs appropriées pour c et d pour une base b donnée , nous pouvons parcourir tous les i dans [0,…, bx) et vérifier si (b - 1) x == (i% b) (b ^{i / b} - 1) .

Code

Le lambda f nommé teste si (b - 1) x est dans l'ensemble {(i% b) (b ^{i / b} - 1) | 0 ≤ i <bx} , en commençant par la valeur b = 2 .

• Si le test a réussi, nous revenons b .

• Sinon, nous appelons à nouveau f , avec les mêmes x et b incrémentés de 1 .

Puisque b peut finalement atteindre x - 1 , nous prenons le résultat final modulo x - 1 pour retourner 0 dans ce cas. Notez que cela ne se produira pas si b = 2 remplit la condition, car elle est renvoyée sans récurrence. Cependant, la question garantit que b = 2 <x - 1 dans ce cas.

Perl 6, 45 43 42 octets

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

Expliqué (en quelque sorte)

Pour référence, une variable $^xdans { ... }est identique à faire-> $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 *)vous donne une liste inversée de chiffres / 'chiffres' pour $ndans la base$b

Polymod (pour de vrai): La méthode polymod est presque comme une version plus puissante de la divmodfonction de python .$n.polymod(*@args)divise $ n par chaque valeur dans * @ args, en ajoutant le reste ( $n mod $x) à la liste qu'il renvoie et en utilisant le quotient pour la division suivante. Je sens que je l'ai mal expliqué alors voici quelques exemples (écrits en perl 6, mais assez propres pour être compris par la plupart j'espère):

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 octets

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

{... ⍵... }fonction anonyme à appliquer x(représenté par ⍵) des
b←1+⍳⍵-3nombres entiers de 2 - ⍵-2 stockées en tant que b
⍵{... }¨pour chaque élément b ( ⍵), appliquer la fonction {... }avec x comme argument de gauche ⍺
⍵⊥⍣¯1⊢⍺converti x à ladite base
1=≢∪est égal à 1 égal au décompte de chiffre unique?
b/⍨éléments de b où vrai (qu'il n'y a qu'un seul chiffre unique).

Exemples de cas

Si aucune base n'existe, la sortie est vide (ce qui est falsey), comme le démontre ce programme:

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

Cela imprime «Faux»

Pyth, 26 19 octets

hMfql{eT1m,djQdr2tQ

Essayez-le ici!

Ajoutera une explication après avoir joué au golf. Regardez cette réponse pour une implémentation et une explication plus courtes.

MATL , 15 14 octets

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

Cela fonctionne avec la version actuelle (14.0.0) du langage / compilateur.

Si aucune base n'existe, la sortie est vide (ce qui est falsey).

Essayez-le en ligne!

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 octets

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

Fonction anonyme, pas trop compliquée. Filtre simplement les bases basées sur la répétition.

Python 2, 75 octets

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

Un port de ma réponse rubis. Imprime toutes les bases valides s'il en existe.

Julia, 45 octets

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

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie un tableau d'entiers. Pour l'appeler, affectez-le à une variable. Il renverra toutes les bases applicables ou un tableau vide. Il n'y a aucun problème avec les grandes bases.

D'abord, nous générons la plage inclusive [2, n - 2], où n est l'entrée. Nous listons ensuite filteruniquement les entiers b pour lesquels n dans la base b a moins de 2 chiffres uniques. Pour ce faire, pour chaque entier b de la plage, nous obtenons les chiffres de n dans la base b sous forme de tableau en utilisant digits, obtenons des éléments uniques en utilisant ∪et obtenons l'index du dernier élément (c'est-à-dire la longueur) en utilisant endof.

Brachylog , 12 octets

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

Essayez-le en ligne! (comme générateur!)

Prend l'entrée via la variable d'entrée et sort une base via la variable de sortie dans le cas où cela est possible, sinon. Dans le même temps, il fonctionne également comme un générateur qui génère une liste de toutes les bases, où cette liste peut être vide.

Idéalement, cela pourrait ressembler à quelque chose ḃ↙.=&>>, sacrifiant peut-être la fonctionnalité du générateur sous cette forme ou une autre similaire (car cela finirait par frapper unaire), mais à partir de maintenant 12 octets est le plus court que je sais comment l'obtenir.

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

Rubis , 46 43 octets

Utilise le nombre entier # introduite dans Ruby 2.4 pour éviter d'avoir à diviser manuellement.

-3 octets grâce à @Jordan.

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

Essayez-le en ligne!

05AB1E , 7 octets

ÍL¦ʒвÙg

Sort toutes les valeurs possibles, ou une liste vide comme valeur de falsey (bien que les sorties techniquement valables soient aussi falsey, car seule 1est vraie en 05AB1E, et tout le reste est falsey).

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Génère toutes les réponses possibles ou rien si aucune solution n'existe.