Desafio

Um repdigit é um número inteiro não negativo cujos dígitos são todos iguais.

Crie uma função ou programa completo que utilize um único número inteiro como entrada e emita um valor verdadeiro se o número de entrada for um re-dígito na base 10 e, caso contrário, o valor falso.

A entrada é garantida como um número inteiro positivo .

Você pode pegar e usar a entrada como uma representação de string na base 10 com impunidade.

Casos de teste

Todos esses são redigits abaixo de 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

Uma lista maior pode ser encontrada no OEIS .

Ganhando

O código mais curto em bytes vence. Isso não quer dizer que respostas inteligentes em idiomas detalhados não sejam bem-vindas.

Braquilog , 1 byte

=

Experimente online!

Isso atua em números inteiros.

De 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 bytes

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

Experimente online!

COBOL , 139 BYTES

Eu sinto que o COBOL não gosta de golfe de código (provavelmente porque não há como ele vencer), mas aqui vai:

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 é definido como um PIC 9 (4).

05AB1E , 1 byte

Ë

Verifica se todos os dígitos são iguais

Experimente online!

Python 3, 25, 24 e 19 bytes.

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

Uma variante de código de erro stdin =>.

Retorna o código de erro 0 se for um repdigit - ou um erro na falha.

Agradeço ao Dennis por me ajudar nos comentários.

Mathematica, 27 bytes

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

Não bate Equal@@IntegerDigits@#&, mas supera a outra solução Mathematica baseada em aritmética.

Os repdígitos têm a forma n = d (10 ^m -1) / 9, em que m é o número de dígitos ed é o dígito repetido. Podemos recuperar d de n usando o módulo 10 (porque se for um dígito repetitivo, será o último dígito d ). Portanto, podemos apenas reorganizar isso como m = log ₁₀ (9 n / (n% 10) + 1) e verificar se m é um número inteiro.

Haskell , 15 bytes

all=<<(==).head

Experimente online!Pega a entrada da string.

Equivalente a \s->all(==head s)s. Estreitamente supera alternativas:

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 bytes

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

Esta é uma função que recebe a entrada como uma string e retorna 1se for um repdigit e0 não.

Faz isso fazendo uso do strspn função, que pega duas cadeias e retorna o comprimento do prefixo mais longo da primeira cadeia, consistindo apenas em caracteres da segunda cadeia. Aqui, a primeira string é a entrada e a segunda string é o último dígito da entrada, obtido ao passar um ponteiro para o último caractere da string de entrada.

Se a entrada for um re-dígito, o resultado da chamada para strspnserá strlen(s). Em seguida, a indexação sretornará um byte nulo, se este for o caso ( str[strlen(str)]é sempre \0) ou o primeiro dígito que não corresponder ao último dígito. Negar isso com !resultados se srepresenta um repdigit.

Experimente online!

Agradeço ao @Dennis por me lembrar indiretamente do truque de atribuir em vez de retornar por meio de sua resposta incrivelmente impressionante , economizando 4 bytes!

PHP, 25 28 25

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

remova todos os caracteres da direita que sejam iguais ao primeiro e imprima 1se todos os caracteres foram removidos.

R, 31 bytes

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

Essas funções funcionam com entradas de sequência e usam uma expressão regular para determinar se a entrada é um repdigit.

Exemplo

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

/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

Experimente online!

A linguagem /// não tem nenhum conceito de verdade e falsey, portanto, gera "T" se a entrada é um re-dígito e não gera nenhum caractere se a entrada não é um re-dígito.

Gelatina , 2 1 byte

E

Experimente online!

Oitava , 11 bytes

@(s)s==s(1)

Experimente online!

Toma a entrada como uma sequência.

Ele verifica a igualdade de todos os caracteres com os primeiros caracteres. Se todos forem iguais, o resultado será um vetor com apenas 1(verdadeiro no Octave), caso contrário, haverá pelo menos um 0(falso no Octave). Aqui está uma prova .

grep, 17 bytes

grep -xP '(.)\1*'

Corresponde a qualquer sequência que seja uma repetição de seu primeiro caractere.

C #, 42 33 28 bytes

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

i tem que ser uma string.

Muito raspada graças a @LethalCoder

Braingolf , 6 bytes

iul1-n

Experimente online!

Infelizmente, a entrada implícita de Braingolf a partir dos argumentos da linha de comando não pode aceitar uma entrada com todos os dígitos como uma string; ela sempre a converterá em um número; portanto, a solução é transmiti-la via STDIN, que adiciona 1 byte para ler STDIN (i )

Explicação:

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

Depois u, o comprimento da pilha é igual ao número de caracteres únicos na entrada, subtraindo 1 significa que será 0se, e somente se houver exatamente 1 caractere exclusivo na entrada, 0for o único número falsey no Python, nsubstituindo 0por 1, e tudo mais com 0.

Japonês , 4 bytes

¥çUg

Experimente online!

JavaScript (ES6), 23 21 bytes

Economizou 2 bytes graças a Neil

Recebe a entrada como um número inteiro ou uma sequência. Retorna um booleano.

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

Demo

let f =

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

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

Ohm , 4 bytes

Ul2<

Experimente online!

Explicação

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

APL, 5 bytes

2 bytes salvos graças a @KritixiLithos

⍕≡1⌽⍕

Experimente online!

Java, 21 bytes:

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

lé uma MutableList<Character>das coleções do eclipse.

Kotlin , 28 19 bytes

{it.toSet().size<2}

Experimente online!

Toma entrada como um Stringporque

Você pode pegar e usar a entrada como uma representação de string na base 10 com impunidade.

Explicação

{
    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
}

Se você não gostar do fato de ser um String, pode ter um que sejaInt por 24 bytes .

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

Regex (ECMAScript), 31 bytes

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

Experimente online!

Recebe entrada unária, como de costume para expressões regulares matemáticas (observe que o problema é trivial com entrada decimal: apenas ^(.)\1*$ ).

Explicação:

^(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 bytes

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

Neim , 1 byte

𝐐

Simplesmente verifica se todos os elementos são iguais.

Sem embutido, 2 bytes:

𝐮𝐥

Explicação:

𝐮     Calculate unique digits
 𝐥    Get the length

Isso funciona porque apenas 1 é considerado verdadeiro em Neim, e todo o resto é falso.

Como alternativa, para 4 bytes:

𝐮𝐣μ𝕃

Explicação:

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

Tente!

C, 38 bytes

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

Recursivamente caminha uma corda. Se os dois primeiros caracteres diferirem ( *s^s[1]), teremos sucesso apenas se estivermos no final da string ( !s[1]), caso contrário, repetiremos o teste na próxima posição ( f(s+1)).

Programa de teste

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

Java, 38 33 23 bytes

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

né um String, naturalmente.

Observe que não há necessidade ^...$no regex, pois ele é usado automaticamente para a correspondência exata (como o matchmétodo), em comparação com a localização na string.

Tente!

Salva

• -5 bytes: usado String desde "Você pode receber e usar a entrada como uma string com impunidade".
• -10 bytes: o regex parece ser um bom ajuste.

R, 25 bytes

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

Experimente online

A melhor solução não-regex que eu consegui encontrar foi 36 bytes:

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

Cubix , 15 bytes

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

Experimente online!

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

Assista

Saídas 1 para verdade e nada para falsey

Simplesmente leia leituras na entrada, um caractere de cada vez. Afasta o caractere atual do anterior. Se um resultado diferente de zero, ele será interrompido imediatamente. Caso contrário, ele continua inserindo e comparando até o EOI. No EOI (-1), negue e saia

QBasic 4.5, 55 bytes

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

Eu calculei isso! O loop FOR verifica o número de dígitos na entrada e criac , que é uma série de 1's de comprimento igual à entrada. Um número é re-digitado se modular a string == 0.

Experimente online! Observe que o intérprete on-line é um pouco peculiar e eu tive que escrever algumas declarações de que o QBasic IDE baseado em DOS se expandia automaticamente.