Se um número inteiro possui um dígito / sequência de dígitos que se repete continuamente (você entenderá por que eu disse "continuamente") 5 ou mais vezes, chamamos de "chato".

Por exemplo, 11111é chato, enquanto 12345não é.

Instruções

Tome um número inteiro como entrada

Emita um valor verdadeiro se o número inteiro for chato e um valor falsey se o número inteiro não for chato.

Exemplo

11111=> trueou 1(1 repete 5 vezes)

12345=> falseou0

1112111=> falseou0

4242424242=> trueou 1(42 repetições 5 vezes)

-11111=> trueou1

3452514263534543543543543543876514264527473275=> trueou 1(543 repetições 5 vezes)

Se você usar outros tipos de "verdade" e "falso", especifique-o.

Regras

Aplicam-se regras básicas de golfe com código .

Boa sorte!

05AB1E , 8 bytes

Código:

Œv¹y5×åO

Explicação:

Π        # 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.

Verdade é diferente de zero e falso é zero. Usa a codificação CP-1252 .

Experimente online!

Retina , 9 bytes

(.+)\1{4}

Verifique todos os casos de teste! (ligeiramente modificado para executar todos os casos de teste de uma só vez.)

Java 8, 52 bytes

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

Superou essa resposta do Java 8 com uma direta String#matches.

Explicação:

Experimente aqui.

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

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

Viva o Java 8 lambdas! Retorna truese a correspondência for encontrada e falsecaso contrário.

Experimente Online! (Ideona)

Lua, 35 bytes

Bem, não vejo como fazer melhor com os padrões de Lua! Adota um argumento da linha de comando como entrada e saída nilpara casos de falsidade e o número repetido quando verdade.

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

JavaScript, 16 bytes

Em node.js (60 bytes)

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

Desperdiçando uma tonelada de bytes na entrada / saída.

JavaScript ES6 (33 bytes)

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

Desperdiçando novamente bytes na entrada / saída.

De preferência, como uma função anônima (22 bytes)

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

Ou ainda mais curto ( 16 bytes )

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

Obrigado @BusinessCat por apontar meus erros.

Python 3.5, 49 43 bytes:

( -6 bytes graças às dicas de Martin Ender ! )

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

Usa uma expressão regular para corresponder a todas as seqüências repetidas de caracteres, desde que sejam repetidas continuamente 5 ou mais vezes. Retorna um reobjeto de correspondência (como <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) se uma correspondência for encontrada como um valor de Noneverdade e nada ou como um valor de falsey.

Experimente Online! (Ideona)

Perl, 17 15 bytes

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

+ a pbandeira.

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

Obrigado a Dom Hasting pelo em (.+)vez de (\d+).

Explicações, se necessário: (.+)corresponderá a qualquer parte do número e \1{4}$pesquisará se ele for repetido 4 vezes consecutivas.

C # - 93 38 bytes

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

Pega uma string, retorna um número inteiro.

Obrigado ao aloisdg por economizar muitos bytes!

Pitão , 9 8 bytes

1 byte graças a Maltysen.

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

O valor de verdade é uma matriz não vazia.

O valor de Falsey é [](matriz vazia).

Suíte de teste.

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 bytes

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

Função. Toma uma string como entrada e saída Trueou False. Testa cadeias de caracteres contra a expressão a__~~a__~~a__~~a__~~a__, que representa a mesma sequência de caracteres repetida 5 vezes. Para referência, a solução mais curta usando uma regex tem 45 bytes:

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

^{amaldiçoá-lo RegularExpression!}

PHP, 37 33 bytes

graças a NoOneIsHere, eu esqueci <?=

programa para PHP <5.4, imprime 1para números chatos, 0senão

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

uso:

• conjunto register_globals=1no php.inipara php-cgi
  em seguida, chamarphp-cgi <filename> n=<number>;echo""
• para PHP> = 5.4, substitua $npor$_GET[n]

solução não-regexp, 152 147 140 bytes

<?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));

• retorna o código de saída 1 para números chatos, 0
  substitui die(1)por die(print 1)e anexa echo 0;para imprimir
• mesmo uso acima, mas também definido short_open_tags=1se desativado
• O loop externo tem um valor inicial irracional no golfe, substitua $n+1por, ceil(strlen($n)/5)+1ou pelo menos por, strlen($n)para teste ou ele pode repetir para sempre.

Haskell, 80 (63 anos)

Seria 63 se não houvesse declaração de importação.

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 propósito, consecutivo faz mais sentido para mim do que continuamente.

(Desculpe, não posso comentar ainda.)

MATLAB, 26 ou 13 bytes

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

isso leva uma variável inteira 'i'. Uma string é apenas a última parte:

all(s==s(1))

Eu contei a nova linha como personagem.

TSQL, 151 bytes

Golfe:

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 bytes

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

Eu não sou de modo algum um mestre de regex, portanto, agradeço as outras respostas por isso.

Clojure, 24 bytes

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

Usa os valores falsey de nil/ falsee os valores verdadeiros de clojure para todo o resto. Especificamente, nilquando nenhuma correspondência é encontrada para false e uma matriz []para true quando uma correspondência é encontrada como para 11111, então ["11111" "1"]é verdadeira.

JS sem regexes, 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}

não minificado:

// 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'));