Se un numero intero contiene una cifra / sequenza di cifre che si ripete continuamente (capirai perché ho detto "continuamente") 5 o più volte, lo chiamiamo "noioso".

Ad esempio, 11111è noioso, mentre 12345non lo è.

Istruzioni

Prendi un intero come input

Emette un valore di verità se l'intero è noioso e un valore di falsa se l'intero non è noioso.

Esempio

11111=> trueo 1(1 ripetizione 5 volte)

12345=> falseo0

1112111=> falseo0

4242424242=> trueo 1(42 ripetizioni 5 volte)

-11111=> trueo1

3452514263534543543543543543876514264527473275=> trueo 1(543 ripetizioni 5 volte)

Se usi altri tipi di "verità" e "falso", specificalo.

Regole

Si applicano le regole di base del code-golf .

In bocca al lupo!

05AB1E , 8 byte

Codice:

Œv¹y5×åO

Spiegazione:

Π        # Compute all substrings from the input.
 v        # For each substring.
   y5×    # Repeat the substring 5 times (42 × 5 = 4242424242).
  ¹   å   # Check if it's in the input string.
       O  # Sum up the result. Non-boring numbers should give 0.

La verità è diversa da zero e la falsità è zero. Utilizza la codifica CP-1252 .

Provalo online!

Retina , 9 byte

(.+)\1{4}

Verifica tutti i test! (leggermente modificato per eseguire contemporaneamente tutti i test.)

Java 8, 52 byte

s->s.matches(".*(.+)\\1{4}.*")

Superato questa risposta Java 8 con una diretta String#matches.

Spiegazione:

Provalo qui.

s->              // Method with String parameter and boolean return-type
  s.matches(     //  Return whether the entire String matches the following regex:
    ".*          //   0 or more leading characters
     (.+)\\1{4}  //   group of 1 or more characters, repeated 5 times
     .*")        //   0 or more trailing characters

Java 8, 73 66 byte:

L->java.util.regex.Pattern.compile("(.+)\\1{4}").matcher(L).find();

Evviva per Java 8 lambdas! Restituisce truese viene trovata una corrispondenza e in caso falsecontrario.

Provalo online! (Ideone)

Lua, 35 byte

Bene, non vedo come fare meglio con gli schemi di Lua! Accetta un argomento da riga di comando come input e output nilper casi falsi e il numero ripetuto quando è vero.

print((...):match("(%d+)%1%1%1%1"))

JavaScript, 16 byte

In node.js (60 byte)

process.stdin.on('data',t=>console.log(/(.+)\1{4}/.test(t)))

Sprecare una tonnellata di byte in input / output.

JavaScript ES6 (33 byte)

alert(/(.+)\1{4}/.test(prompt()))

Ancora una volta sprecando byte in input / output.

Preferibilmente, come funzione anonima (22 byte)

n=>/(.+)\1{4}/.test(n)

O anche più breve ( 16 byte )

/(.+)\1{4}/.test

Grazie @BusinessCat per aver segnalato i miei errori.

Python 3.5, 49 43 byte:

( -6 byte grazie ai suggerimenti di Martin Ender ! )

import re;lambda u:re.search(r'(.+)\1{4}',u)

Utilizza un'espressione regolare per abbinare tutte le sequenze ripetute di caratteri purché si ripetano continuamente 5 o più volte. Restituisce un reoggetto di corrispondenza (come <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) se viene trovata una corrispondenza come valore di verità e niente oNone come valore di falsa.

Provalo online! (Ideone)

Perl, 17 15 byte

$_=/(.+)\1{4}/

+ il p bandiera.

(Corri con perl -pe '$_=/(.+)\1{4}/' )

Grazie a Dom Hasting per (.+)invece di(\d+) .

Spiegazioni se necessario: (.+)corrisponderà a qualsiasi parte del numero e \1{4}$cercherà se viene ripetuto 4 volte consecutive.

C # - 93 38 byte

s=>new Regex(@"(.+)\1{4}").IsMatch(s);

Prende una stringa, restituisce un numero intero.

Grazie ad aloisdg per aver salvato molti byte!

Pyth , 9 8 byte

1 byte grazie a Maltysen.

sm} * 5DQ .:
f} * 5TQ .:

Il valore di verità è un array non vuoto.

Il valore Falsey è [](array vuoto).

Suite di test.

f}*5TQ.:   input as a string stored in Q
f}*5TQ.:Q  implicit arguments
        Q  input
      .:   all substrings of.
f   T      filter for this condition, keep those returning true:
  *5           repeat five times
 }   Q         in Q? (True/False)

Mathematica, 46 40 36 byte

b=a__;StringContainsQ[b~~b~~b~~b~~b]

Funzione. Accetta una stringa come input e output Trueo False. Verifica le stringhe rispetto all'espressione a__~~a__~~a__~~a__~~a__, che rappresenta la stessa sequenza di caratteri ripetuta 5 volte. Per riferimento, la soluzione più breve che utilizza un regex è lunga 45 byte:

StringContainsQ@RegularExpression@"(.+)\1{4}"

^{maledire RegularExpression!}

PHP, 37 33 byte

grazie a NoOneIsHere, me ne sono dimenticato <?=

programma per PHP <5.4, stampe 1per numeri noiosi, 0altro

<?=preg_match('/(.+)\1{4}/U',$n);

utilizzo:

• set register_globals=1in php.iniper php-cgi
  quindi chiamarephp-cgi <filename> n=<number>;echo""
• per PHP> = 5.4, sostituire $ncon$_GET[n]

soluzione non regexp, 152 147 140 byte

<?for($e=$n+1;--$e;)for($f=$e;$f--;)for($a=str_split(substr($n,$f),$e),$k=$c='';strlen($v=array_pop($a));)$c-$v?$k=0&$c=$v:($k++<3?:die(1));

• restituisce il codice di uscita 1 per numeri noiosi, altrimenti
  sostituisce 0 die(1)con die(print 1)e accoda echo 0;per stampare
• stesso utilizzo di cui sopra, ma anche impostato short_open_tags=1 se disabilitato
• L'anello esterno ha un valore iniziale irragionevole nel golf, lo sostituisce $n+1con ceil(strlen($n)/5)+1o almeno con strlen($n)per il test o può essere ripetuto come per sempre.

Haskell, 80 (63?)

Sarebbe 63 se non ci fossero dichiarazioni di importazione.

import Data.List
f x=or$tail[isInfixOf(concat$replicate 5 b)x|b<-subsequences x]

uso

f "11111211"
f "11111"
f "12345" 
f "1112111"
f "4242424242"
f "-11111"
f "3452514263534543543543543543876514264527473275"

A proposito, consecutivo ha più senso per me che continuamente.

(Mi dispiace, non posso ancora commentare.)

MATLAB, 26 o 13 byte

s=int2str(i);all(s==s(1))

questo richiede una variabile intera 'i'. Una stringa è solo l'ultima parte:

all(s==s(1))

Ho contato la newline come personaggio.

TSQL, 151 byte

golfed:

DECLARE @t varchar(99)='11111'

,@z bit=0,@a INT=1,@ INT=1WHILE @a<LEN(@t)SELECT @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),@=IIF(@=20,1,@+1),@a+=IIF(@=1,1,0)PRINT @z

Ungolfed:

DECLARE @t varchar(99)='11111'

,@z bit=0,
@a INT=1,
@ INT=1
WHILE @a<LEN(@t)
  SELECT
    @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),
    @=IIF(@=20,1,@+1),
    @a+=IIF(@=1,1,0)

PRINT @z

Violino

PowerShell, 26 byte

$args[0]-match"(.+)\1{4}"

Non sono affatto un regex master, quindi merito alle altre risposte per questo.

Clojure, 24 byte

#(re-find #"(.+)\1{4}"%)

Usa i valori falsi di clojure di nil/ falsee valori di verità per tutto il resto. In particolare, nilquando non viene trovata alcuna corrispondenza per false e una matrice []per true quando viene trovata una corrispondenza come per 11111, allora ["11111" "1"]è vero.

JS senza regex, 166

b=s=>{for(let i=0;i<s.length-4;i++){for(let n=1;n<=Math.floor((s.length-i)/5);n++){if([1,2,3,4].every(k=>s.slice(i,i+n)==s.slice(i+n*k,i+n*(k+1))))return 1}}return 0}

non minimizzato:

// test any start pos, and length
var b = s => {
    for (let i = 0; i <= s.length - 5; i++) {
        for (let n = 1; n <= Math.floor((s.length - i) / 5); n++) {
            // test if s is boring at position i, with length n
            if ([1, 2, 3, 4].every(k => s.slice(i, i + n) === s.slice(i + n * k, i + n * (k + 1)))) {
                return 1;
            }
        }
    }
    return 0;
};

console.log(b('11111'));
console.log(b('12345'));
console.log(b('1112111'));
console.log(b('-11111'));
console.log(b('3452514263534543543543543543876514264527473275'));