甲纯位数是可以单独通过重复相同的位被写入的自然数。例如，777是repdigit，因为它仅由7重复3次的数字组成。

这不仅限于十进制（以10为底）数字，但是：

• 每个梅森数（格式为M _n当用二进制（基数2）编写时， = 2 ⁿ -1）都是一个位数。
• 以一进制（基数1）写入时，每个数字都是一个小数位数。
• 每个数字n也可以用11基数表示为小数位n-1（例如，17以十六进制（基数16）写为11，而3以二进制数（基数2）写也）。11）。

这里的挑战是找到 输入数字可能是重复数字的其他基础。

输入项

正整数 x > 3任何方便格式的。

输出量

一个正整数b，(x-1) > b > 1其中xin 的表示形式为brepdigit。

• 如果不b存在，则输出0或出现错误值。
• 如果b存在多个，则可以输出其中任何一个或全部。

规则

• 该(x-1) > b > 1限制是为了防止琐碎转换到一元或“减一”基。的输出数可以写在一元或任何方便的基础，但碱本身必须不平凡的转换中的一个。
• 输入/输出可以通过任何合适的方法。
• 适用标准漏洞限制。

例子

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)

果冻，11 9个字节

bRI¬P€TḊṖ

返回一个碱基列表，如果没有，则为空（虚假）。 在线尝试！

怎么运行的

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

显然，Pyth的一元q检查列表是否包含大约10天前的所有唯一值。显然，研究Pyth虫会提高高尔夫球得分。

[2..input-1)如果该基数中输入的唯一数字位数为长度1，则过滤列表。

测试套件

说明：

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字节

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

我必须手动实现基本转换，因为Ruby的内建函数最多只能达到36。

返回nil找不到。

->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字节

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

无需递归，只需尝试所有基础并输出一组有效的基础。

这是很有诱惑力的编码b，并d在一个单一的数字，但它需要太多的括号表达式提取它们。77个字节：

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个字节：

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

输出第一个b有效的，或0如果没有则。

甲REP-单元x的d数字c在碱b具有价值x==c*(b**d-1)/(b-1)。等效地，x*(b-1)==c*(b**d-1)。

该值c必须是x%b，最后一位。我看不到有一种d算术确定的方法，因此代码尝试了所有可能性，以查看它们是否可行。

通过复制Dennis通过取模为输出b到达时提供假输出的技巧，节省了5个字节。丹尼斯保留的另一个字节提醒我，幂运算莫名其妙地具有更高的优先级。x-1x-1~

等长的解决方案，其中包含in而不是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个字节

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

我真的很想删除那个烦人的空间，但是作为红宝石的新手，我仍然不十分熟悉其语法怪癖。

表情符号，214字节

（77个字符）：

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

以9为基数打印结果。

我本来打算用emojicode进行代码高尔夫已经有几个星期了，但是直到最近，这种语言才变得足够稳定，可以实际使用😉。另外，这个问题还充分利用了emojicode的一项功能：它实际上很擅长：用其他基数表示整数。

Ungolfed（👴是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字节

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

在Ideone上尝试一下。

理念

底数b的任何代表数字x > 1和数字 d <b的满足以下条件。

以来 d <b，因此映射（b，d）↦cb + d是内射的。

另外，由于b，x> 1，我们有 c <x，所以cb + d <cb + b =（c + 1）b≤xb。

这意味着，以找到合适的值Ç和d为给定的基极b，我们可以通过所有迭代我在[0，...，BX）和检查是否（B - 1）X ==（ⅰ％B）（B ^{i / b} -1）。

码

命名的lambda f检验（b-1）x是否在{{i％b）（b ^{i / b} -1）| 0≤i <bx}，从值b = 2开始。

• 如果测试成功，则返回b。

• 否则，我们再次调用f，相同的x和b增加1。

由于b最终可能达到x-1，因此在这种情况下，我们以x-1为模的最终结果返回0。请注意，如果b = 2满足条件，则不会发生这种情况，因为返回时无需递归。但是，该问题保证在这种情况下b = 2 <x-1。

Perl 6，45 43 42字节

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

解释（某种）

作为参考，$^xin { ... }中的变量与-> $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 *)为您提供$n以基为单位的数字/“数字”的反向列表$b

Polymod（实际）：polymod方法几乎类似于python divmod函数的更强大版本。$n.polymod(*@args)将$ n除以* @ args中的每个值，将余数（$n mod $x）添加到它返回的列表中，并使用商进行下一个除法。我觉得我解释得很不好，所以这里有一些例子（用perl 6编写，但足够干净，我希望大多数人都能理解）：

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个字节

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

{... ⍵... }匿名函数被应用到x（由表示⍵）
b←1+⍳⍵-3的整数，从2 -存储为⍵-2 b
⍵{... }¨在B（每个元素⍵），应用功能{... }其中x为左参数⍺
⍵⊥⍣¯1⊢⍺x转换到基
1=≢∪是1等于帐簿唯一数字？
b/⍨b的元素为true（只有一个唯一数字）。

案例案例

如果不存在任何基数，则输出为空（为false），如以下程序所示：

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

打印“假”

Pyth，26个 19字节

hMfql{eT1m,djQdr2tQ

在这里尝试！

打完高尔夫球后再加一个解释。查看此答案以获得更短的实现和解释。

MATL，15 14字节

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

这适用于当前版本（14.0.0）该语言/编译器的。

如果不存在任何基数，则输出为空（为false）。

在线尝试！

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个字节

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

匿名函数，不太复杂。只是根据重复性过滤掉碱基。

Python 2，75个字节

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

我的红宝石答案的端口。打印所有有效的基数（如果存在）。

朱莉娅，45个字节

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

这是一个接受整数并返回整数数组的匿名函数。要调用它，请将其分配给变量。它将返回所有适用的基数或空数组。大型基地没有问题。

首先，我们生成包含范围[2，n -2]，其中n是输入。然后filter，我们仅列出整数b，其基数b中的n少于2个唯一数字。为此，对于范围中的每个整数b，我们使用来获取基b中n的数字作为数组，使用来获取唯一项，并使用来获取最后一个元素的索引（即长度）。digits∪endof

Brachylog，12个字节

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

在线尝试！ （作为发电机！）

在可能的情况下，通过输入变量获取输入，并通过输出变量输出基数，否则将失败。同时，它还用作生成器，它输出所有碱基的列表，该列表可以为空。

理想情况下，它看起来像ḃ↙.=&>>，可能会牺牲这种形式或类似形式的生成器功能（因为它最终会变成一元），但是到目前为止，我知道如何获得它是最短的12个字节。

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

红宝石，46 43字节

使用Ruby 2.4中引入的Integer＃digits函数来避免手动除法。

-3个字节，感谢@Jordan。

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

在线尝试！

05AB1E，7 个字节

ÍL¦ʒвÙg

输出所有可能的值，或将一个空列表输出为falsey值（尽管技术上有效的输出也为falsey，因为仅 1在05AB1E中真是假，其他所有都是假）。

在线尝试或验证所有测试用例。

说明：

Í        # 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 5，63个字节

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

在线尝试！

输出所有可能的答案，如果不存在解决方案，则不输出任何内容。