挑战

甲纯位数是一个非负整数，其位数都相等。

创建一个函数或完整程序，该函数或完整程序将单个整数作为输入，并且如果输入的数字是以10为底的repdigit，则输出真实值，否则输出false。

输入保证为正整数。

您可以不受限制地接受并使用输入作为10进制的字符串表示形式。

测试用例

这些都是1000以下的位数。

1
2
3
4
5
6
7
8
9
11
22
33
44
55
66
77
88
99
111
222
333
444
555
666
777
888
999

可以在OEIS上找到更大的列表。

获奖

以字节为单位的最短代码获胜。这并不是说不欢迎用冗长的语言回答。

Brachylog，1个字节

=

在线尝试！

这作用于整数。

来自src/predicates.pl#L1151：

brachylog_equal('integer':0, 'integer':0, 'integer':0).
brachylog_equal('integer':0, 'integer':I, 'integer':I) :-
    H #\= 0,
    integer_value('integer':_:[H|T], I),
    brachylog_equal('integer':0, [H|T], [H|T]).

C（gcc），33 30 29字节

f(n){n=n%100%11?9/n:f(n/10);}

在线尝试！

COBOL，139字节

我觉得COBOL在代码高尔夫方面没有得到任何热爱（可能是因为它不可能赢），但是这里有：

IF A = ALL '1' OR ALL '2' OR ALL '3' OR ALL '4' OR ALL '5' OR
ALL '6' OR ALL '7' OR ALL '8' OR ALL '9' DISPLAY "TRUE" ELSE   
DISPLAY "FALSE".

A被定义为PIC 9（4）。

05AB1E，1个字节

Ë

检查所有数字是否相等

在线尝试！

Python 3中，25，24 19个字节。

len({*input()})>1>t

标准输入=>错误代码变体。

如果是重复数字，则返回错误代码0-或失败时返回错误。

感谢Dennis在评论中帮助我。

Mathematica，27个字节

AtomQ@Log10[9#/#~Mod~10+1]&

它没有击败Equal@@IntegerDigits@#&，但超过了其他基于算术的Mathematica解决方案。

代表位数的形式为n = d（10 ^m -1）/ 9，其中m是位数，而d是重复位数。我们可以恢复d从ň通过服用模10（因为如果它是一个代表数字，它的最后一位数字将是d）。因此我们可以将其重新排列为m = log ₁₀（9 n /（n％10）+1），然后检查m是否为整数。

Haskell，15个字节

all=<<(==).head

在线尝试！接受字符串输入。

等同于\s->all(==head s)s。狭beat地击败替代品：

f s=all(==s!!0)s
f s=s==(s!!0<$s)
f(h:t)=all(==h)t
f(h:t)=(h<$t)==t
f s=(s<*s)==(s*>s)
f(h:t)=h:t==t++[h]

C（gcc），41个字节

f(char*s){s=!s[strspn(s,s+strlen(s)-1)];}

此函数将输入作为字符串，1如果是repdigit 0则返回，否则返回。

它通过使用该strspn函数来实现此目的，该函数接受两个字符串，并返回第一个字符串的最长前缀的长度，该长度仅由第二个字符串中的字符组成。在这里，第一个字符串是输入，第二个字符串是输入的最后一位，这是通过将指针传递到输入字符串的最后一个字符而获得的。

如果输入是repdigit，则对的调用结果strspn将为strlen(s)。然后，s如果是这种情况（str[strlen(str)]始终为\0），则索引入将返回一个空字节，否则将返回与最后一位不匹配的第一个数字。否定该!结果是否s代表repdigit。

在线尝试！

感谢@Dennis通过他令人印象深刻的答案间接地使我想起了分配而不是返回的技巧，节省了4个字节！

PHP，25 28 25

<?=!chop($argn,$argn[0]);

从右侧删除与第一个相同的1所有字符，如果所有字符都被删除，则打印。

R，31个字节

function(x)grepl("^(.)\\1*$",x)

此函数适用于字符串输入，并使用正则表达式确定输入是否为repdigit。

例

> f <- function(x)grepl("^(.)\\1*$",x)
> x <- c("1", "2", "11", "12", "100", "121", "333")
> f(x)
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE

///，110字节

/11/1//22/2//33/3//44/4//55/5//66/6//77/7//88/8//99/9//1/.//2/.//3/.//4/.//5/.//6/.//7/.//8/.//9/.//T..///.//T

在线尝试！

///语言没有任何关于真假的概念，因此如果输入是数字位数，则输出“ T”，如果输入不是数字位数，则不会输出任何字符。

果冻，2 1字节

E

在线尝试！

八度，11字节

@(s)s==s(1)

在线尝试！

将输入作为字符串。

它检查所有字符是否与第一个字符相等。如果全部相等，则结果将是一个仅包含矢量1（八度为true），否则将至少有一个矢量（八度为0false）。这是一个证明。

grep，17个字节

grep -xP '(.)\1*'

匹配任何重复第一个字符的字符串。

C＃，42 33 28字节

i=>i.Replace(i[0]+"","")==""

i 必须是一个字符串。

@LethalCoder大大减少了

Braingolf，6个字节

iul1-n

在线尝试！

不幸的是，Braingolf从命令行args的隐式输入不能接受全数字输入作为字符串，它将始终将其强制转换为数字，因此解决方案是通过STDIN传递它，该方法会添加1个字节以读取STDIN（i）

说明：

iul1-n
i       Read from STDIN as string, push each codepoint to stack
 u      Remove duplicates from stack
  l     Push length of stack
   1-   Subtract 1
     n  Boolean negate, replace each item on stack with 1 if it is a python falsey value
        replace each item on stack with 0 if it is a python truthy value
        Implicit output of last item on stack

在之后u，堆栈的长度等于输入中唯一字符的数量，减去1表示0当且仅当输入中恰好有1个唯一字符时，0它才是Python中唯一的假数字，因此n将替换0为1，还有其他一切0。

Japt，4个字节

¥çUg

在线尝试！

JavaScript（ES6），23 21字节

感谢Neil，节省了2个字节

将输入作为整数或字符串。返回一个布尔值。

n=>/^(.)\1*$/.test(n)

演示版

let f =

n=>/^(.)\1*$/.test(n)

console.log(f(444))
console.log(f(12))

欧姆，4个字节

Ul2<

在线尝试！

说明

 Ul2<
 U    # Push uniquified input
  l   # Length
   2< # Is it smaller than 2?

APL，5个字节

@KritixiLithos节省了2个字节

⍕≡1⌽⍕

在线尝试！

Java，21个字节：

l->l.toSet().size()<2

l是MutableList<Character>来自eclipse的集合。

科特林，28 19字节

{it.toSet().size<2}

在线尝试！

将输入作为String原因

您可以不受限制地接受并使用输入作为10进制的字符串表示形式。

说明

{
    it.toSet()     // create a Set (collection with only unique entries)
                   // out of the characters of this string
        .size < 2  // not a repdigit if the set only has one entry
}

如果你不喜欢它需要一个这样的事实String，你可以有一个接受一个Int为24个字节。

{(""+it).toSet().size<2}

正则表达式（ECMAScript），31个字节

^(x{0,9})((x+)\3{8}(?=\3$)\1)*$

在线尝试！

与通常的数学正则表达式一样，以一元形式输入（请注意，使用十进制输入时，这个问题很简单：just ^(.)\1*$）。

说明：

^(x{0,9})           # \1 = candidate digit, N -= \1
(                   # Loop the following:
  (x+)\3{8}(?=\3$)  # N /= 10 (fails and backtracks if N isn’t a multiple of 10)
  \1                # N -= \1
)* $                # End loop, assert N = 0

PHP，30个字节

<?=($a=$argn).$a[0]==$a[0].$a;

Neim，1个字节

𝐐

只需检查所有元素是否相等。

没有内置，2个字节：

𝐮𝐥

说明：

𝐮     Calculate unique digits
 𝐥    Get the length

这行得通，因为仅 1是在Neim中认为是真实的，而其他所有东西都是虚假的。

另外，对于4个字节：

𝐮𝐣μ𝕃

说明：

𝐮      Calculate unique digits
 𝐣      Join list into an integer
   𝕃   Check that is is less than
  μ    Ten.

试试吧！

C，38个字节

f(char*s){return*s^s[1]?!s[1]:f(s+1);}

递归地走一个字符串。如果前两个字符不同（*s^s[1]），那么只有在字符串（!s[1]）的末尾，我们才能成功，否则在下一个位置（f(s+1)）重复测试。

测试程序

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s: %s\n", *argv, f(*argv)?"yes":"no");
}

Java，38 33 23字节

n->n.matches("(.)\\1*")

n是String自然的。

请注意，与在字符串中查找相比，^...$正则表达式中无需使用正则表达式，因为它会自动用于精确匹配（例如match方法）。

试试吧！

节省

• -5字节：String自“您可以接受并使用输入作为不受惩罚的字符串”以来使用。
• -10个字节：正则表达式显然很合适。

R，25个字节

grepl("^(.)\\1*$",scan())

在线尝试

我能想到的最佳非正则表达式解决方案是36个字节：

is.na(unique(el(strsplit(x,"")))[2])

Cubix，15个字节

uOn@ii?-?;.$@<_

在线尝试！

    u O
    n @
i i ? - ? ; . $
@ < _ . . . . .
    . .
    . .

观看运行

输出1为真，否为假

非常简单的读取一次读取输入中的一个字符。它使当前字符脱离前一个字符。如果结果非零，则立即停止。否则，它将继续输入和比较直到EOI。在EOI（-1）上，取反并退出

QBasic 4.5，55字节

INPUT a
FOR x=1TO LEN(STR$(a))
c=c*10+1
NEXT
?a MOD c=0

我算了！FOR循环检查输入中的位数，然后创建c，它是一系列等于输入的1。如果数字对单字符串== 0取模，则该数字就是repdigit。

在线尝试！请注意，在线解释器有点古怪，我不得不写出几条基于DOS的QBasic IDE会自动扩展的语句。