Si un número entero tiene un dígito / secuencia de dígitos que se repite continuamente (comprenderá por qué dije "continuamente") 5 o más veces, lo llamamos "aburrido".

Por ejemplo, 11111es aburrido, mientras 12345que no lo es.

Instrucciones

Tomar un entero como entrada

Genere un valor verdadero si el entero es aburrido, y un valor falso si el entero no es aburrido.

Ejemplo

11111=> trueo 1(1 se repite 5 veces)

12345=> falseo0

1112111=> falseo0

4242424242=> trueo 1(42 repeticiones 5 veces)

-11111=> trueo1

3452514263534543543543543543876514264527473275=> trueo 1(543 se repite 5 veces)

Si utiliza otros tipos de "verdad" y "falso", especifíquelo.

Reglas

Se aplican reglas básicas de código de golf .

¡Buena suerte!

05AB1E , 8 bytes

Código:

Œv¹y5×åO

Explicación:

Π        # 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 verdad no es cero y la falsedad es cero. Utiliza la codificación CP-1252 .

Pruébalo en línea!

Retina , 9 bytes

(.+)\1{4}

¡Verifique todos los casos de prueba! (ligeramente modificado para ejecutar todos los casos de prueba a la vez).

Java 8, 52 bytes

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

Superó esta respuesta de Java 8 con un directo String#matches.

Explicación:

Pruébalo aquí

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

¡Hurra por las lambdas de Java 8! Devuelve truesi se encuentra una coincidencia y de lo falsecontrario.

¡Pruébelo en línea! (Ideona)

Lua, 35 bytes

Bueno, ¡no veo cómo hacerlo mejor con los patrones de Lua! Toma un argumento de línea de comando como entrada y salida nilpara casos falsos, y el número se repite cuando es verdadero.

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

JavaScript, 16 bytes

En node.js (60 bytes)

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

Perder una tonelada de bytes en entrada / salida.

JavaScript ES6 (33 bytes)

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

Nuevamente desperdiciando bytes en entrada / salida.

Preferiblemente, como una función anónima (22 bytes)

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

O incluso más corto ( 16 bytes )

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

Gracias @BusinessCat por señalar mis errores.

Python 3.5, 49 43 bytes:

( -6 bytes gracias a los consejos de Martin Ender ! )

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

Utiliza una expresión regular para hacer coincidir todas las secuencias repetidas de caracteres siempre que se repitan continuamente 5 o más veces. Devuelve un reobjeto de coincidencia (como <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) si una coincidencia se encuentra como un valor verdadero y nada o Nonecomo un valor falso.

¡Pruébelo en línea! (Ideona)

Perl, 17 15 bytes

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

+ la pbandera

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

Gracias a Dom Hasting por el (.+)lugar de(\d+) .

Explicaciones si es necesario: (.+)coincidirá con cualquier parte del número y \1{4}$buscará si se repite 4 veces consecutivas.

C # - 93 38 bytes

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

Toma una cadena, devuelve un entero.

¡Gracias a aloisdg por guardar muchos bytes!

Pyth, 9 8 bytes

1 byte thanks to Maltysen.

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

Truthy value is a non-empty array.

Falsey value is [] (empty array).

Test suite.

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]

Function. Takes a string as input and outputs True or False. Tests strings against the expression a__~~a__~~a__~~a__~~a__, which represents the same character sequence repeated 5 times. For reference, the shortest solution using a regex is 45 bytes long:

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

^{curse you RegularExpression!}

PHP, 37 33 bytes

gracias a NoOneIsHere, me olvidé <?=

programa para PHP <5.4, impresiones 1para números aburridos, de lo 0contrario

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

uso:

• conjunto register_globals=1en php.iniphp-cgi
  luego llamarphp-cgi <filename> n=<number>;echo""
• para PHP> = 5.4, reemplace $ncon$_GET[n]

solución no 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));

• devuelve el código de salida 1 para números aburridos, 0 más
  reemplaza die(1)con die(print 1)y agrega echo 0;para imprimir en su lugar
• mismo uso que el anterior, pero también configurado short_open_tags=1si está deshabilitado
• El bucle externo tiene un valor de inicio irrazonable en el golf, reemplace $n+1con ceil(strlen($n)/5)+1o al menos con strlen($n)para probar o puede bucle como para siempre.

Haskell, 80 (¿63?)

Sería 63 si no hubiera una declaración de importación.

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"

Por cierto, consecutiva tiene más sentido para mí que continuamente.

(Lo siento, no puedo comentar todavía).

MATLAB, 26 o 13 bytes

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

esto toma una variable entera 'i'. Una cadena es solo la última parte:

all(s==s(1))

He contado la nueva línea como un personaje.

TSQL, 151 bytes

Golfizado:

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

Sin golf:

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

Violín

PowerShell, 26 bytes

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

De ninguna manera soy un maestro de expresiones regulares, así que acrediten a las otras respuestas por eso.

Clojure, 24 bytes

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

Utiliza los valores falsos de clojure de nil/ falsey los valores de verdad para todo lo demás. Específicamente, nilcuando no se encuentra una coincidencia para falso, y una matriz []para verdadero cuando se encuentra una coincidencia como para 11111, entonces ["11111" "1"]es verdadero.

JS sin expresiones regulares, 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}

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