Вызов

Репдигиты является неотрицательным целым числом , чьи цифры все равны.

Создайте функцию или завершенную программу, которая принимает одно целое число в качестве входных данных и выводит истинное значение, если входное число является повторной цифрой в базе 10 и ложным значением в противном случае.

На входе гарантировано положительное целое число.

Вы можете безнаказанно принимать и использовать ввод как строковое представление в базе 10.

Контрольные примеры

Это все repdigits ниже 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 .

выигрыш

Самый короткий код в байтах побеждает. Нельзя сказать, что умные ответы на многословных языках не будут приветствоваться.

Брахилог , 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);}

Попробуйте онлайн!

КОБОЛ , 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 байт

Ë

Проверяет, все ли цифры равны

Попробуйте онлайн!

Питон 3, 25, 24 19 байт.

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

A stdin => вариант кода ошибки.

Возвращает код ошибки 0, если это повторная цифра - или ошибка при ошибке.

Спасибо Деннису за помощь в комментариях.

Mathematica, 27 байт

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

Он не побеждает Equal@@IntegerDigits@#&, но побеждает другое арифметическое решение Mathematica.

Повторные цифры имеют вид n = d (10 ^м -1) / 9, где m - количество цифр, а d - повторяющаяся цифра. Мы можем восстановить d из n , взяв его по модулю 10 (потому что, если это цифра повторения, ее последняя цифра будет d ). Таким образом, мы можем просто изменить это как m = log ₁₀ (9 n / (n% 10) + 1) и проверить, является ли m целым числом.

Haskell , 15 байт

all=<<(==).head

Попробуйте онлайн! Принимает строку ввода.

Эквивалент \s->all(==head s)s. Узко выбивает альтернативы:

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если она является повторной, и в 0противном случае.

Это делается путем использования strspnфункции, которая принимает две строки и возвращает длину самого длинного префикса первой строки, состоящего только из символов из второй строки. Здесь первая строка является вводом, а вторая строка является последней цифрой ввода, полученной путем передачи указателя на последний символ входной строки.

Если входной сигнал является повторным, то результатом вызова strspnбудет strlen(s). Затем индексирование в sвозвращает нулевой байт, если это так ( str[strlen(str)]всегда \0) или первая цифра, которая в противном случае не соответствует последней цифре. Отрицание этого !приводит к тому, sпредставляет ли репдигит.

Попробуйте онлайн!

Спасибо @Dennis за то, что он косвенно напомнил мне о трюке с присваиванием вместо возврата через его безумно впечатляющий ответ , сэкономив 4 байта!

PHP, 25 28 25

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

удалите все символы справа, которые равны первому, и напечатайте, 1если все символы были удалены.

R, 31 байт

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

Эта функция работает со строковыми входами и использует регулярное выражение, чтобы определить, является ли ввод повторной цифрой.

пример

> 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 в Октаве), в противном случае будет хотя бы один 0(false в Octave). Вот доказательство .

grep, 17 байт

grep -xP '(.)\1*'

Соответствует любой строке, которая является повторением первого символа.

C #, 42 33 28 байт

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

i должен быть строкой.

Много сбрил благодаря @LethalCoder

Braingolf , 6 байтов

iul1-n

Попробуйте онлайн!

К сожалению, неявный ввод Braingolf из аргументов командной строки не может принять ввод всех цифр в виде строки, он всегда будет приводить его к числу, поэтому вместо этого решение состоит в том, чтобы передать его через 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если и только если существует ровно один уникальный характер на входе, 0является единственной falsey числа в Python, так nбудет заменить 0с 1, а все остальное с 0.

Japt , 4 байта

¥çUg

Попробуйте онлайн!

JavaScript (ES6), 23 21 байт

Сохранено 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 байт

2 байта сохранены благодаря @KritixiLithos

⍕≡1⌽⍕

Попробуйте онлайн!

Java, 21 байт:

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

lэто MutableList<Character>из коллекции затмения.

Котлин , 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)*$

Попробуйте онлайн!

Принимает ввод в унарном виде, как обычно для математических регулярных выражений (обратите внимание, что проблема с тривиальным вводом тривиальна: просто ^(.)\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;

Нейм , 1 байт

𝐐

Просто проверяет, что все элементы равны.

Без встроенного, 2 байта:

𝐮𝐥

Объяснение:

𝐮     Calculate unique digits
 𝐥    Get the length

Это работает, потому что только 1в Нейме считается правдой, а все остальное ложно.

Альтернативно, для 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");
}

Ява, 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 для правды и ничего для фальси

Очень просто читать читает на входе по одному символу за раз. Уносит текущего персонажа от предыдущего. Если результат не равен нулю, он немедленно останавливается. В противном случае он продолжает вводить и сравнивать до ВЗ. На ВЗ (-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.

Попробуйте онлайн! Обратите внимание, что онлайн-интерпретатор немного странный, и мне пришлось написать пару утверждений, что основанная на DOS среда IDE QBasic будет расширяться автоматически.