Golf to find Boring numbers

Question

If an integer has a digit/sequence of digits in it which repeats continuously (You will understand why I said "continuously") 5 or more times, we call It "Boring".

For example, 11111 is Boring, whereas 12345 is not.

Instructions

Take an Integer as Input

Output a truthy value if the integer is boring, and a falsey value if the integer is not boring.

Example

11111=>true or 1 (1 repeats 5 times)

12345=>false or 0

1112111=>false or 0

4242424242=>true or 1 (42 repeats 5 times)

-11111=>true or 1

3452514263534543543543543543876514264527473275=>true or 1 (543 repeats 5 times)

If you use other types of "truth" and "false", specify it.

Rules

Basic code-golf rules apply.

Good luck!

Answer 1

05AB1E, 8 bytes

Code:

Œv¹y5×åO

Explanation:

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

Truthy is non-zero and falsy is zero. Uses the CP-1252 encoding.

Try it online!

Answer 2

Retina, 9 bytes

(.+)\1{4}

Verify all testcases! (slightly modified to run all testcases at once.)

Answer 3

Java 8, 52 bytes

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

Outgolfed this Java 8 answer with a direct String#matches.

Explanation:

Try it here.

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

Answer 4

Java 8, 73 66 bytes:

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

Hooray for Java 8 lambdas! Returns true if match is found and false otherwise.

Try It Online! (Ideone)

Answer 5

Lua, 35 Bytes

Well, I don't see how to do better with Lua's patterns! Takes a command-line argument as input and output nil for falsy cases, and the number repeated when truthy.

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

Answer 6

JavaScript, 16 bytes

In node.js (60 bytes)

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

Wasting a ton of bytes on input/output.

JavaScript ES6 (33 bytes)

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

Again wasting bytes on input/output.

Preferably, as an anonymous function (22 bytes)

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

Or even shorter (16 bytes)

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

Thanks @BusinessCat for pointing out my mistakes.

Answer 7

Python 3.5, 49 43 bytes:

(-6 bytes thanks to tips from Martin Ender!)

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

Uses a Regular Expression to match all repeating sequences of characters as long as they repeat continuously 5 or more times. Returns an re match object (such as <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) if a match is found as a truthy value, and nothing or None as a falsey value.

Try It Online! (Ideone)

Answer 8

Perl, 17 15 bytes

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

+ the p flag.

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

Thanks to Dom Hasting for the (.+) instead of (\d+).

Explanations if needed : (.+) will match any part of the number, and \1{4}$ searches if it is repeated 4 times consecutives.

Answer 9

Husk, ¹³ 11 bytes

§ṁ€ȯm*5tQda

Try it online!

similar to 05AB1E.

-2 bytes from Dominic Van Essen and Jo King.

Answer 10

SABDT, 41 bytes

White Space-less:

if($.r("(.+)\1{4})"=""){pr"0";}el{pr"1";}

Prettified:

if( $.r( "(.+)\1{4}" ) = "" ){
    pr "0";
} el {
    pr "1";
}

Answer brought to you partly by the brilliant person who came up the regex "(.+)\1{4}"

Answer 11

C# - 93 38 bytes

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

Takes a string, returns an integer.

Thanks to aloisdg for saving a lot of bytes!

Answer 12

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)

Answer 13

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!}

Answer 14

PHP, 37 33 bytes

thanks to NoOneIsHere, I forgot about <?=

program for PHP<5.4, prints 1 for boring numbers, 0 else

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

usage:

• set register_globals=1 in php.ini for php-cgi
  then call php-cgi <filename> n=<number>;echo""
• for PHP>=5.4, replace $n with $_GET[n]

non-regexp solution, 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));

• returns exit code 1 for boring numbers, 0 else
  replace die(1) with die(print 1) and append echo 0; to print instead
• same usage as above, but also set short_open_tags=1 if disabled
• The outer loop got an unreasonable start value in the golfing, replace $n+1 with ceil(strlen($n)/5)+1 or at least with strlen($n) for testing or it may loop like forever.

Answer 15

Haskell, 80 (63?)

It would be 63 if there were no import statement.

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"

By the way, consecutive makes more sense to me than continuously.

(Sorry, I can't comment yet.)

Answer 16

CJam, 22 bytes

q:T,{)Tew{5*T\#)}/}%:+

Try it online!

Takes sum of 1-indexed positions of all possible repeated substrings in the input. Returns 0 if interesting, anything non-zero if boring.

Answer 17

Japt, 7 bytes

øUã mp5

Try it (includes all test cases)

øUã mp5     :Implicit input of string U
ø           :Does U contain any element of
 Uã         :  Substrings of U
    m       :  Map
     p5     :    Repeat 5 times

Answer 18

Python 3 without regex, 66 bytes

lambda s:any(s[j:i]*5in s for i in range(len(s))for j in range(i))

Try it online!

Answer 19

MATLAB, 26 or 13 bytes

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

this takes an integer variable 'i'. A string is just the last part:

all(s==s(1))

I have counted the newline as a character.

Answer 20

TSQL, 151 bytes

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

Fiddle

Answer 21

PowerShell, 26 bytes

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

I'm by no means a regex master, so credit to the other answers for that.

Answer 22

Clojure, 24 bytes

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

Uses clojure's falsey values of nil/false and truthy values for everything else. Specifically, nil when no match is found for false, and an array [] for true when a match is found like for 11111 then ["11111" "1"] is true.

Answer 23

JS without 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 minified:

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