Если целое число содержит цифру / последовательность цифр, которая повторяется непрерывно (вы поймете, почему я сказал «непрерывно») 5 или более раз, мы называем это «скучно».

Например, 11111скучно, а 12345нет.

инструкции

Возьмите целое число в качестве входных данных

Выведите истинное значение, если целое число скучно, и значение false, если целое число не скучно.

пример

11111=> trueили 1(1 повторяется 5 раз)

12345=> falseили0

1112111=> falseили0

4242424242=> trueили 1(42 повторяется 5 раз)

-11111=> trueили1

3452514263534543543543543543876514264527473275=> trueили 1(543 повторяется 5 раз)

Если вы используете другие типы «истина» и «ложь», укажите это.

правила

Применяются основные правила игры в гольф .

Удачи!

05AB1E , 8 байтов

Код:

Œv¹y5×å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.

Истина отлична от нуля, а ложь равна нулю. Использует кодировку CP-1252 .

Попробуйте онлайн!

Сетчатка , 9 байт

(.+)\1{4}

Проверьте все тестовые случаи! (немного изменен, чтобы запускать все тестовые сценарии одновременно.)

Java 8, 52 байта

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

Обошел этот Java 8 ответ с прямым String#matches.

Объяснение:

Попробуй это здесь.

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 байт:

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

Ура для Java 8 лямбд! Возвращает, trueесли совпадение найдено и falseиначе.

Попробуйте онлайн! (Ideone)

Луа, 35 байт

Ну, я не вижу, как сделать лучше с образцами Луа! Принимает аргумент командной строки в качестве входных и выходных данных nilдля ложных случаев, а число повторяется, когда истина.

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

JavaScript, 16 байт

В node.js (60 байт)

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

Потеря тонны байтов на вводе / выводе.

JavaScript ES6 (33 байта)

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

Снова тратить байты на ввод / вывод.

Желательно, как анонимная функция (22 байта)

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

Или даже короче ( 16 байт )

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

Спасибо @BusinessCat за указание на мои ошибки.

Python 3.5, 49 43 байта:

( -6 байт благодаря советам Мартина Эндера ! )

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

Использует регулярное выражение для сопоставления всех повторяющихся последовательностей символов, если они повторяются непрерывно 5 или более раз. Возвращает reобъект совпадения (например, <_sre.SRE_Match object; span=(0, 10), match='4242424242'>), если совпадение найдено как истинное значение, а ничего или Noneкак ложное значение.

Попробуйте онлайн! (Ideone)

Perl, 17 15 байт

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

+ pфлаг.

(беги с perl -pe '$_=/(.+)\1{4}/')

Спасибо Дому Хастингу за (.+)вместо (\d+).

Пояснения, если необходимо: (.+)будет соответствовать любой части числа, и \1{4}$ищет, если это будет повторяться 4 раза подряд.

C # - 93 38 байт

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

Принимает строку, возвращает целое число.

Спасибо aloisdg за сохранение большого количества байтов!

Pyth , 9 8 байт

1 байт благодаря Maltysen.

см} * 5dQ .:
е} * 5TQ .:

Истинное значение - непустой массив.

Значение Falsey [](пустой массив).

Тестирование.

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 байт

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

Функция. Принимает строку в качестве ввода и вывода Trueили False. Проверяет строки на выражение a__~~a__~~a__~~a__~~a__, которое представляет одну и ту же последовательность символов, повторенную 5 раз. Для справки, самое короткое решение с использованием регулярных выражений имеет длину 45 байт:

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

^{проклинаю тебя, регулярное выражение!}

PHP, 37 33 байта

спасибо NoOneIsHere, я забыл о <?=

программа для PHP <5.4, печать 1для скучных чисел, 0другое

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

использование:

• набор register_globals=1в php.iniдля PHP-CGI
  затем вызватьphp-cgi <filename> n=<number>;echo""
• для PHP> = 5.4, заменить $nна$_GET[n]

решение без регулярных выражений, 152 147 140 байт

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

• возвращает код выхода 1 для скучных чисел, 0 в противном случае
  заменить die(1)на die(print 1)и добавить echo 0;вместо печати
• То же использование, что и выше, но также установлено, short_open_tags=1если отключено
• Внешний контур получил необоснованное начальное значение в гольфе, заменить $n+1с ceil(strlen($n)/5)+1или , по крайней мере, strlen($n)для тестирования или он может цикл, навсегда.

Хаскелл, 80 (63?)

Было бы 63, если бы не было оператора импорта.

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

использование

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

Кстати, последовательное имеет больше смысла для меня, чем непрерывно.

(Извините, я пока не могу комментировать.)

MATLAB, 26 или 13 байтов

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

это принимает целочисленную переменную 'i'. Строка это только последняя часть:

all(s==s(1))

Я посчитал символ новой строки.

TSQL, 151 байт

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

скрипка

PowerShell, 26 байт

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

Я ни в коем случае не мастер регулярных выражений, так что поверьте другим ответам за это.

Clojure, 24 байта

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

Использует ложные значения clojure nil/ falseи истинные значения для всего остального. В частности, nilкогда совпадение не найдено для false, а массив []для true, когда совпадение найдено, например, для 11111, тогда ["11111" "1"]true.

JS без регулярных выражений, 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}

не минимизированный:

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