Si un entier contient un chiffre / une séquence de chiffres qui se répète en continu (vous comprendrez pourquoi j'ai dit "en continu") 5 fois ou plus, nous l'appelons "ennuyeux".

Par exemple, 11111est ennuyeux, alors qu'il 12345ne l'est pas.

Instructions

Prendre un entier comme entrée

Sortez une valeur véridique si l'entier est ennuyeux et une valeur de falsey si l'entier n'est pas ennuyeux.

Exemple

11111=> trueou 1(1 se répète 5 fois)

12345=> falseou0

1112111=> falseou0

4242424242=> trueou 1(42 répétitions 5 fois)

-11111=> trueou1

3452514263534543543543543543876514264527473275=> trueou 1(543 répétitions 5 fois)

Si vous utilisez d'autres types de «vérité» et «faux», spécifiez-le.

Règles

Les règles de base du code-golf s'appliquent.

Bonne chance!

05AB1E , 8 octets

Code:

Œv¹y5×åO

Explication:

Π        # 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 vérité est non nulle et la fausseté est nulle. Utilise l' encodage CP-1252 .

Essayez-le en ligne!

Rétine , 9 octets

(.+)\1{4}

Vérifiez tous les tests! (légèrement modifié pour exécuter tous les tests en même temps.)

Java 8, 52 octets

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

Outgolfed cette réponse Java 8 avec un direct String#matches.

Explication:

Essayez-le ici.

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

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

Hourra pour les lambdas Java 8! Renvoie truesi une correspondance est trouvée et falsesinon.

Essayez-le en ligne! (Ideone)

Lua, 35 octets

Eh bien, je ne vois pas comment faire mieux avec les modèles de Lua! Prend un argument de ligne de commande comme entrée et sortie nilpour les cas de falsification, et le nombre répété lorsqu'il est véridique.

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

JavaScript, 16 octets

Dans node.js (60 octets)

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

Gaspiller une tonne d'octets en entrée / sortie.

JavaScript ES6 (33 octets)

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

Encore une fois gaspillage d'octets sur les entrées / sorties.

De préférence, en tant que fonction anonyme (22 octets)

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

Ou encore plus court ( 16 octets )

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

Merci @BusinessCat d'avoir signalé mes erreurs.

Python 3.5, 49 43 octets:

( -6 octets grâce aux conseils de Martin Ender ! )

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

Utilise une expression régulière pour faire correspondre toutes les séquences de caractères répétitives tant qu'elles se répètent en continu 5 fois ou plus. Renvoie un reobjet de correspondance (tel que <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) si une correspondance est trouvée comme valeur véridique, et rien ou Nonecomme valeur de falsey.

Essayez-le en ligne! (Ideone)

Perl, 17 15 octets

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

+ le pdrapeau.

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

Merci à Dom Hasting pour le (.+)lieu de(\d+) .

Explications si nécessaire: (.+)correspondra à n'importe quelle partie du nombre et \1{4}$recherche s'il est répété 4 fois de suite.

C # - 93 38 octets

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

Prend une chaîne, retourne un entier.

Merci à aloisdg pour avoir économisé beaucoup d'octets!

Pyth , 9 8 octets

1 octet grâce à Maltysen.

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

La valeur vraie est un tableau non vide.

La valeur de Falsey est [](tableau vide).

Suite de tests.

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 octets

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

Une fonction. Prend une chaîne en entrée et en sortie Trueou False. Teste les chaînes par rapport à l'expression a__~~a__~~a__~~a__~~a__, qui représente la même séquence de caractères répétée 5 fois. Pour référence, la solution la plus courte utilisant une expression régulière fait 45 octets de long:

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

^{vous maudit RegularExpression!}

PHP, 37 33 octets

grâce à NoOneIsHere, j'ai oublié <?=

programme pour PHP <5.4, imprime 1pour les nombres ennuyeux, 0sinon

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

usage:

• mettre register_globals=1en php.iniphp-cgi
  puis appelerphp-cgi <filename> n=<number>;echo""
• pour PHP> = 5.4, remplacez $npar$_GET[n]

solution non regexp, 152 147 140 octets

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

• renvoie le code de sortie 1 pour les nombres ennuyeux, 0 sinon
  remplacez die(1)par die(print 1)et ajoutezecho 0; pour imprimer à la place
• même utilisation que ci-dessus, mais également défini short_open_tags=1 si désactivé
• La boucle externe a une valeur de départ déraisonnable dans le golf, remplacez-la $n+1par ceil(strlen($n)/5)+1ou au moins par strlen($n)pour les tests ou elle peut boucler comme pour toujours.

Haskell, 80 (63?)

Ce serait 63 s'il n'y avait pas de déclaration d'importation.

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

Usage

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

Soit dit en passant, consécutif a plus de sens pour moi que continuellement.

(Désolé, je ne peux pas encore commenter.)

MATLAB, 26 ou 13 octets

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

cela prend une variable entière «i». Une chaîne n'est que la dernière partie:

all(s==s(1))

J'ai compté la nouvelle ligne comme un personnage.

TSQL, 151 octets

Golfé:

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

Non 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

Violon

PowerShell, 26 octets

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

Je ne suis en aucun cas un maître des regex, alors merci aux autres réponses pour cela.

Clojure, 24 octets

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

Utilise les valeurs falsey de clojure de nil/ falseet les valeurs véridiques pour tout le reste. Plus précisément, nillorsqu'aucune correspondance n'est trouvée pour false, et un tableau []pour true lorsqu'une correspondance est trouvée comme pour 11111 ["11111" "1"]est alors vraie.

JS sans 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}

non minifié:

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