Sfida

Un repdigit è un numero intero non negativo le cui cifre sono tutte uguali.

Creare una funzione o un programma completo che accetta un singolo intero come input e genera un valore di verità se il numero di input è una modifica nella base 10 e falsa il valore in caso contrario.

L'input è garantito per essere un numero intero positivo .

Puoi prendere e usare l'input come rappresentazione di stringa nella base 10 con impunità.

Casi test

Queste sono tutte riprogrammazioni inferiori a 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

Un elenco più ampio è disponibile su OEIS .

vincente

Vince il codice più breve in byte. Questo non vuol dire che risposte intelligenti in lingue verbose non saranno le benvenute.

Brachylog , 1 byte

=

Provalo online!

Questo agisce sugli interi.

Da 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 byte

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

Provalo online!

COBOL , 139 BYTES

Sento che COBOL non ha alcun amore nel golf di codice (probabilmente perché non c'è modo di vincere), ma ecco qui:

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 è definito come un PIC 9 (4).

05AB1E , 1 byte

Ë

Verifica se tutte le cifre sono uguali

Provalo online!

Python 3, 25, 24 19 byte.

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

Una variante del codice di errore stdin =>.

Restituisce il codice di errore 0 se si tratta di una modifica o di un errore in caso di errore.

Grazie a Dennis per avermi aiutato nei commenti.

Mathematica, 27 byte

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

Non batte Equal@@IntegerDigits@#&, ma batte l'altra soluzione Mathematica basata sull'aritmetica.

Le modifiche sono nella forma n = d (10 ^m -1) / 9 dove m è il numero di cifre e d è la cifra ripetuta. Possiamo recuperare d da n prendendolo modulo 10 (perché se è una cifra rep, l'ultima cifra sarà d ). Quindi possiamo semplicemente riorganizzarlo come m = log ₁₀ (9 n / (n% 10) + 1) e verificare se m è un numero intero.

Haskell , 15 byte

all=<<(==).head

Provalo online! Accetta l'input di stringa.

Equivalente a \s->all(==head s)s. Supera leggermente le alternative:

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 byte

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

Questa è una funzione che accetta input come stringa e restituisce 1se si tratta di una modifica e in 0altro modo.

A tale scopo, utilizza la strspnfunzione, che accetta due stringhe e restituisce la lunghezza del prefisso più lungo della prima stringa costituita da soli caratteri della seconda stringa. Qui, la prima stringa è l'input e la seconda stringa è l'ultima cifra dell'input, ottenuta passando un puntatore all'ultimo carattere della stringa di input.

Se l'input è una modifica, il risultato della chiamata strspnsarà strlen(s). Quindi, l'indicizzazione in srestituirà un byte nullo se questo è il caso ( str[strlen(str)]è sempre \0) o la prima cifra che non corrisponde all'ultima cifra altrimenti. La negazione con questo !comporta se srappresenta una modifica.

Provalo online!

Grazie a @Dennis per avermi indirettamente ricordato il trucco di assegnazione invece di ritorno tramite la sua risposta follemente impressionante , risparmiando 4 byte!

PHP, 25 28 25

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

rimuovi tutti i caratteri da destra uguali al primo e stampa 1se tutti i caratteri sono stati rimossi.

R, 31 byte

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

Questa funzione funziona con input di stringa e utilizza un'espressione regolare per determinare se l'input è un riporto.

Esempio

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

/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

Provalo online!

Il linguaggio /// non ha alcun concetto di verità e falsità, quindi questo genera "T" se l'input è una modifica, e non genera alcun carattere se l'input non è una modifica.

Gelatina , 2 1 byte

E

Provalo online!

Ottava , 11 byte

@(s)s==s(1)

Provalo online!

Prende l'input come stringa.

Controlla la parità di tutti i personaggi con i primi caratteri. Se tutti sono uguali, il risultato sarà un vettore con solo 1(vero in Ottava), altrimenti ce ne sarà almeno uno 0(falso in Ottava). Ecco una prova .

grep, 17 byte

grep -xP '(.)\1*'

Corrisponde a qualsiasi stringa che è una ripetizione del suo primo carattere.

C #, 42 33 28 byte

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

i deve essere una stringa.

Rasato molto grazie a @LethalCoder

Braingolf , 6 byte

iul1-n

Provalo online!

Sfortunatamente, l'input implicito di Braingolf da args a riga di comando non può accettare un input di tutte le cifre come una stringa, lo lancerà sempre su un numero, quindi la soluzione è passarlo tramite STDIN, che aggiunge 1 byte per la lettura di STDIN ( i)

Spiegazione:

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

Dopodiché u, la lunghezza dello stack è uguale al numero di caratteri univoci nell'input, sottraendo 1 significa che sarà 0se e solo se c'è esattamente 1 carattere univoco nell'input, 0è l'unico numero di falsi in Python, quindi nsostituirà 0con 1, e tutto il resto con 0.

Japt , 4 byte

¥çUg

Provalo online!

JavaScript (ES6), 23 21 byte

Salvato 2 byte grazie a Neil

Accetta l'input come numero intero o stringa. Restituisce un valore booleano.

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

dimostrazione

let f =

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

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

Ohm , 4 byte

Ul2<

Provalo online!

Spiegazione

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

APL, 5 byte

2 byte salvati grazie a @KritixiLithos

⍕≡1⌽⍕

Provalo online!

Java, 21 byte:

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

lè una MutableList<Character>raccolta di eclissi.

Kotlin , 28 19 byte

{it.toSet().size<2}

Provalo online!

Prende input come Stringperché

Puoi prendere e usare l'input come rappresentazione di stringa nella base 10 con impunità.

Spiegazione

{
    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 non ti piace il fatto che ci vuole un String, puoi averne uno che richiede un Intper 24 byte .

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

Regex (ECMAScript), 31 byte

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

Provalo online!

Prende input in unario, come al solito per le regex matematiche (si noti che il problema è banale con input decimale: solo ^(.)\1*$).

Spiegazione:

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

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

Neim , 1 byte

𝐐

Controlla semplicemente che tutti gli elementi siano uguali.

Senza built-in, 2 byte:

𝐮𝐥

Spiegazione:

𝐮     Calculate unique digits
 𝐥    Get the length

Questo funziona perché solo 1Neim è considerato vero e tutto il resto è falso.

In alternativa, per 4 byte:

𝐮𝐣μ𝕃

Spiegazione:

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

Provalo!

C, 38 byte

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

Cammina ricorsivamente una stringa. Se i primi due caratteri differiscono ( *s^s[1]), allora riusciamo solo se siamo alla fine della stringa ( !s[1]), altrimenti ripetiamo il test nella posizione successiva ( f(s+1)).

Programma di 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 byte

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

nè un String, naturalmente.

Si noti che non è necessario ^...$nel regex poiché viene utilizzato automaticamente per la corrispondenza esatta (come il matchmetodo), rispetto alla ricerca nella stringa.

Provalo!

Salva

• -5 byte: usato Stringda "Puoi prendere e usare l'input come una stringa con impunità."
• -10 byte: regex è apparentemente una buona scelta.

R, 25 byte

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

Provalo online

La migliore soluzione non regex che ho potuto trovare era di 36 byte:

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

Cubix , 15 byte

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

Provalo online!

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

Guardalo correre

Output 1 per verità e niente per falsità

Molto semplicemente, legge nell'input un carattere alla volta. Allontana il personaggio attuale dal precedente. Se un risultato diverso da zero si arresta immediatamente. Altrimenti continua a inserire e confrontare fino all'EOI. Su EOI (-1), annulla ed esci

QBasic 4.5, 55 byte

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

L'ho fatto per matematica! Il ciclo FOR controlla il numero di cifre nell'input, quindi creac , che è una serie di 1 di lunghezza uguale all'input. Un numero viene quindi riconfigurato se modulo la stringa singola == 0.

Provalo online! Si noti che l'interprete online è un po 'eccentrico e ho dovuto scrivere un paio di affermazioni che l'IDE QBasic basato su DOS si espandesse automaticamente.