Défi

Un repdigit est un entier non négatif dont les chiffres sont tous égaux.

Créez une fonction ou un programme complet qui prend un seul entier en entrée et génère une valeur de vérité si le nombre entré est un chiffre de référence en base 10 et une valeur falsy dans le cas contraire.

L'entrée est garantie d'être un entier positif .

Vous pouvez utiliser et utiliser l'entrée en tant que représentation sous forme de chaîne en base 10 en toute impunité.

Cas de test

Ce sont tous des repdigits inférieurs à 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

Une liste plus longue peut être trouvée sur OEIS .

Gagnant

Le code le plus court en octets gagne. Cela ne veut pas dire que des réponses intelligentes dans les langues verbeuses ne seront pas les bienvenues.

Brachylog , 1 octet

=

Essayez-le en ligne!

Cela agit sur les entiers.

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 octets

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

Essayez-le en ligne!

COBOL , 139 BYTES

J'ai l'impression que COBOL n'a pas d'amour en code golf (probablement parce qu'il n'y a aucun moyen de gagner), mais voici:

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 est défini comme un PIC 9 (4).

05AB1E , 1 octet

Ë

Vérifie si tous les chiffres sont égaux

Essayez-le en ligne!

Python 3, 25, 24 19 octets.

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

Un stdin => variante de code d'erreur.

Retourne le code d'erreur 0 s'il s'agit d'un repdigit - ou une erreur en cas d'échec.

Merci à Dennis de m'avoir aidé dans les commentaires.

Mathematica, 27 octets

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

Cela ne bat pas Equal@@IntegerDigits@#&, mais cela bat l’autre solution Mathematica basée sur l’arithmétique.

Les repdigits sont de la forme n = d (10 ^m -1) / 9 où m est le nombre de chiffres et d le chiffre répété. On peut récupérer d de n en prenant le modulo 10 (car s'il s'agit d'un chiffre de représentation, son dernier chiffre sera d ). Nous pouvons donc simplement réorganiser ceci en m = log ₁₀ (9 n / (n% 10) + 1) et vérifier si m est un entier.

Haskell , 15 octets

all=<<(==).head

Essayez-le en ligne! Prend une entrée de chaîne.

Équivalent à \s->all(==head s)s. De justesse bat les alternatives:

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 octets

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

C'est une fonction qui prend l'entrée en tant que chaîne et retourne 1s'il s'agit d'un repdigit et 0sinon.

Pour ce faire, il utilise la strspnfonction, qui prend deux chaînes et renvoie la longueur du préfixe le plus long de la première chaîne, composé uniquement de caractères de la deuxième chaîne. Ici, la première chaîne est l'entrée et la deuxième chaîne est le dernier chiffre de l'entrée, obtenu en passant un pointeur sur le dernier caractère de la chaîne d'entrée.

Si l'entrée est un repdigit, alors le résultat de l'appel à strspnsera strlen(s). Ensuite, l'indexation dans sretournera un octet nul si c'est le cas ( str[strlen(str)]c'est toujours \0) ou le premier chiffre qui ne correspond pas au dernier chiffre sinon. La négation de ceci avec des !résultats en si sreprésente un repdigit.

Essayez-le en ligne!

Merci à @Dennis de m'avoir rappelé de manière indirecte le truc assigner plutôt que de retourner via sa réponse incroyablement impressionnante , économisant 4 octets!

PHP, 25 28 25

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

supprime tous les caractères de la droite qui sont égaux au premier et affiche 1si tous les caractères ont été supprimés.

R, 31 octets

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

Cette fonction fonctionne avec les entrées de chaîne et utilise une expression régulière pour déterminer si l'entrée est un repdigit.

Exemple

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

/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

Essayez-le en ligne!

Le langage /// n'a pas de concept de vérité et de falsey, donc il génère "T" si l'entrée est un repdigit, et ne génère aucun caractère si l'entrée n'est pas un repdigit.

Gelée , 2 1 octet

E

Essayez-le en ligne!

Octave , 11 octets

@(s)s==s(1)

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne.

Il vérifie que tous les caractères sont égaux aux premiers. Si tous sont égaux, le résultat sera un vecteur avec seulement 1(vrai dans Octave), sinon il y en aura au moins un 0(faux dans Octave). Voici une preuve .

grep, 17 octets

grep -xP '(.)\1*'

Correspond à n'importe quelle chaîne qui répète son premier caractère.

C #, 42 33 28 octets

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

i doit être une chaîne.

Réduit beaucoup grâce à @LethalCoder

Braingolf , 6 octets

iul1-n

Essayez-le en ligne!

Malheureusement, l'entrée implicite de Braingolf à partir d'arguments en ligne de commande ne peut pas accepter une entrée composée uniquement de chiffres, elle le convertira toujours en nombre. La solution consiste donc à la transmettre via STDIN, ce qui ajoute 1 octet pour la lecture de STDIN (i ).

Explication:

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

Après u, la longueur de la pile est égale au nombre de caractères uniques dans l'entrée, soustraction de 1 signifie que ce sera 0si et seulement s'il y a exactement 1 caractère unique dans l'entrée, 0est le seul numéro de Falsey dans Python, nremplace donc 0par 1, et tout le reste avec 0.

Japt , 4 octets

¥çUg

Essayez-le en ligne!

JavaScript (ES6), 23 21 octets

2 octets sauvés grâce à Neil

Prend l'entrée sous forme de nombre entier ou de chaîne. Retourne un booléen.

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

Démo

let f =

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

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

Ohm , 4 octets

Ul2<

Essayez-le en ligne!

Explication

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

APL, 5 octets

2 octets enregistrés grâce à @KritixiLithos

⍕≡1⌽⍕

Essayez-le en ligne!

Java, 21 octets:

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

lest MutableList<Character>issu des collections eclipse.

Kotlin , 28 19 octets

{it.toSet().size<2}

Essayez-le en ligne!

Prend en entrée String cause

Vous pouvez utiliser et utiliser l'entrée en tant que représentation sous forme de chaîne en base 10 en toute impunité.

Explication

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

Si vous n'aimez pas le fait que cela prend un String, vous pouvez en avoir un qui prend un Intpour 24 octets .

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

Regex (ECMAScript), 31 octets

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

Essayez-le en ligne!

Prend les entrées de manière unaire, comme d'habitude pour les expressions rationnelles mathématiques (notez que le problème est trivial avec une entrée décimale: juste ^(.)\1*$).

Explication:

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

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

Neim , 1 octet

𝐐

Vérifie simplement que tous les éléments sont égaux.

Sans construit, 2 octets:

𝐮𝐥

Explication:

𝐮     Calculate unique digits
 𝐥    Get the length

Cela fonctionne parce que seule la 1vérité est considérée dans Neim, et tout le reste est faux.

Alternativement, pour 4 octets:

𝐮𝐣μ𝕃

Explication:

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

Essayez le!

C, 38 octets

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

Marche récursivement une chaîne. Si les deux premiers caractères diffèrent ( *s^s[1]), alors nous ne réussirons que si nous sommes à la fin de la chaîne ( !s[1]), sinon nous répétons le test à la position suivante (f(s+1) ).

Programme de test

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

Java, 38 33 23 octets

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

nest un String, naturellement.

Notez que ^...$l'expression régulière n'est pas nécessaire, car elle est automatiquement utilisée pour la correspondance exacte (telle que la matchméthode), par rapport à la recherche dans la chaîne.

Essayez le!

Enregistre

• -5 octets: utilisé Stringdepuis "Vous pouvez utiliser et utiliser les entrées comme une chaîne en toute impunité."
• -10 octets: regex est apparemment un bon choix.

R, 25 bytes

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

Try it online

Best non-regex solution I could come up with was 36 bytes:

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

Cubix, 15 bytes

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

Try it online!

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

Watch It Run

Outputs 1 for truthy and nothing for falsey

Very simply read reads in the input one character at a time. It takes the current character away from the previous. If a non zero result then it halts immediately. Otherwise it continues inputting and comparing until the EOI. On EOI (-1), negate and exit

QBasic 4.5, 55 bytes

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

I've mathed it! The FOR-loop checks the number of digits in the input, then creates c, which is a series of 1's of length equal to the input. A number then is repdigit if it modulo the one-string == 0.

Try it online! Note that the online interpreter is a bit quirky and I had to write out a couple of statements that the DOS-based QBasic IDE would expand automatically.