Wenn eine Ganzzahl eine Ziffer / Ziffernfolge enthält, die sich 5 oder mehr Mal wiederholt (Sie werden verstehen, warum ich "kontinuierlich" gesagt habe), nennen wir sie "langweilig".

Zum Beispiel 11111ist langweilig, während 12345es nicht ist.

Anleitung

Nehmen Sie eine Ganzzahl als Eingabe

Geben Sie einen Wahrheitswert aus, wenn die Ganzzahl langweilig ist, und einen Falsey-Wert, wenn die Ganzzahl nicht langweilig ist.

Beispiel

11111=> trueoder 1(1 5-mal wiederholt)

12345=> falseoder0

1112111=> falseoder0

4242424242=> trueoder 1(42 Wiederholungen 5 Mal)

-11111=> trueoder1

3452514263534543543543543543876514264527473275=> trueoder 1(543 Wiederholungen 5 Mal)

Wenn Sie andere Arten von "truth" und "false" verwenden, geben Sie diese an.

Regeln

Grundlegende Code-Golf- Regeln gelten.

Viel Glück!

05AB1E , 8 Bytes

Code:

Œv¹y5×åO

Erläuterung:

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

Die Wahrheit ist nicht Null und falsch ist Null. Verwendet die CP-1252- Codierung.

Probieren Sie es online!

Netzhaut , 9 Bytes

(.+)\1{4}

Überprüfen Sie alle Testfälle! (Leicht modifiziert, um alle Testfälle gleichzeitig auszuführen.)

Java 8, 52 Bytes

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

Überrumpelte diese Java 8 Antwort mit einem direkten String#matches.

Erläuterung:

Probieren Sie es hier aus.

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 für Java 8 Lambdas! Gibt zurück, trueob eine Übereinstimmung gefunden wurde oder falsenicht.

Probieren Sie es online! (Ideone)

Lua, 35 Bytes

Nun, ich kann nicht besser mit Luas Mustern umgehen! Übernimmt ein Befehlszeilenargument als Eingabe und Ausgabe nilfür falsche Fälle, und die Zahl wird wiederholt, wenn sie wahr ist.

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

JavaScript, 16 Bytes

In node.js (60 Bytes)

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

Eine Tonne Bytes bei der Eingabe / Ausgabe verschwenden .

JavaScript ES6 (33 Byte)

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

Verschwendung von Bytes bei der Eingabe / Ausgabe.

Vorzugsweise als anonyme Funktion (22 Bytes)

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

Oder noch kürzer ( 16 Bytes )

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

Vielen Dank an @BusinessCat für den Hinweis auf meine Fehler.

Python 3.5, 49 43 Bytes:

( -6 Bytes dank Tipps von Martin Ender ! )

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

Verwendet einen regulären Ausdruck, um alle sich wiederholenden Zeichenfolgen abzugleichen, solange sie sich mindestens fünf Mal hintereinander wiederholen. Gibt ein reÜbereinstimmungsobjekt (z. B. <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) zurück, wenn eine Übereinstimmung als wahrer Wert und nichts oder Noneals falscher Wert gefunden wird.

Probieren Sie es online! (Ideone)

Perl, 17-15 Bytes

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

+ die pFlagge.

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

Danke an Dom Hasting für den (.+)Ersatz (\d+).

Erläuterungen, falls erforderlich: (.+)Stimmt mit einem beliebigen Teil der Nummer überein und \1{4}$sucht, ob diese viermal hintereinander wiederholt wird.

C # - 93 38 Bytes

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

Nimmt einen String und gibt eine Ganzzahl zurück.

Vielen Dank an aloisdg für das Speichern vieler Bytes!

Pyth , 9 8 Bytes

1 Byte danke an Maltysen.

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

Der Wahrheitswert ist ein nicht leeres Array.

Falscher Wert ist [](leeres Array).

Testsuite.

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]

Funktion. Nimmt einen String als Ein- und Ausgang Trueoder False. Testet Strings gegen den Ausdrucka__~~a__~~a__~~a__~~a__ , der dieselbe Zeichenfolge darstellt, die fünfmal wiederholt wird. Als Referenz ist die kürzeste Lösung mit einem regulären Ausdruck 45 Byte lang:

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

^{verfluche dich RegularExpression!}

PHP, 37 33 Bytes

dank NoOneIsHere habe ich vergessen <?=

Programm für PHP <5.4, druckt 1für langweilige Zahlen, 0sonst

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

Verwendung:

• set register_globals=1in php.iniPHP-cgi
  dann rufenphp-cgi <filename> n=<number>;echo""
• für PHP> = 5,4, ersetzen $nmit$_GET[n]

Nicht-Regexp-Lösung, 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));

• Gibt den Exit-Code 1 für langweilige Nummern zurück. Anderenfalls
  ersetzen Sie diese die(1)durch die(print 1)und hängen Sie sie anecho 0; stattdessen den Ausdruck hinzu
• gleiche Verwendung wie oben, aber auch eingestellt short_open_tags=1 wenn deaktiviert
• Die äußere Schleife hat einen unangemessenen Startwert beim Golfen bekommen, ersetzen $n+1mit ceil(strlen($n)/5)+1oder zumindest mit strlen($n)zum Testen oder sie kann wie für immer schleifen.

Haskell, 80 (63?)

Es wäre 63, wenn es keine Importanweisung gäbe.

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

Verwendung

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

Aufeinanderfolgend macht für mich übrigens mehr Sinn als ununterbrochen.

(Leider kann ich noch keinen Kommentar abgeben.)

MATLAB, 26 oder 13 Bytes

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

Dies erfordert eine ganzzahlige Variable 'i'. Eine Zeichenfolge ist nur der letzte Teil:

all(s==s(1))

Ich habe die Newline als Zeichen gezählt.

TSQL, 151 Bytes

Golf gespielt:

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

Geige

PowerShell, 26 Byte

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

Ich bin auf keinen Fall ein Regex-Meister, also loben Sie die anderen Antworten dafür.

Clojure, 24 Bytes

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

Verwendet die falschen Werte von nil/ falseund die wahren Werte von clojure für alles andere. Insbesondere nilwenn keine Übereinstimmung für false gefunden wird und ein Array []für true, wenn eine Übereinstimmung wie für 11111 gefunden wird, dann ["11111" "1"]ist true.

JS ohne reguläre Ausdrücke, 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}

nicht minimiert:

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