Nếu một số nguyên có một chữ số / dãy số trong đó lặp lại liên tục (Bạn sẽ hiểu lý do tại sao tôi nói "liên tục") 5 lần trở lên, chúng tôi gọi đó là "Chán".

Ví dụ, 11111là nhàm chán, trong khi 12345không.

Hướng dẫn

Lấy một số nguyên làm đầu vào

Xuất ra một giá trị trung thực nếu số nguyên là nhàm chán và giá trị falsey nếu số nguyên không nhàm chán.

Thí dụ

11111=> truehoặc 1(1 lần lặp lại 5 lần)

12345=> falsehoặc0

1112111=> falsehoặc0

4242424242=> truehoặc 1(42 lần lặp lại 5 lần)

-11111=> truehoặc1

3452514263534543543543543543876514264527473275=> truehoặc 1(543 lặp lại 5 lần)

Nếu bạn sử dụng các loại "sự thật" và "sai" khác, hãy chỉ định nó.

Quy tắc

Quy tắc golf-golf cơ bản được áp dụng.

Chúc may mắn!

05AB1E , 8 byte

Mã số:

Œv¹y5×åO

Giải trình:

Π        # 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 không phải là zero và falsy là zero. Sử dụng mã hóa CP-1252 .

Hãy thử trực tuyến!

Võng mạc , 9 byte

(.+)\1{4}

Xác nhận tất cả các thử nghiệm! (sửa đổi một chút để chạy tất cả các testcase cùng một lúc.)

Java 8, 52 byte

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

Vượt qua câu trả lời Java 8 này bằng một câu trực tiếp String#matches.

Giải trình:

Hãy thử nó ở đây.

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

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

Hoan hô cho Java 8 lambdas! Trả về truenếu trận đấu được tìm thấy và falsenếu không.

Dùng thử trực tuyến! (Ý)

Lua, 35 byte

Chà, tôi không thấy làm thế nào để làm tốt hơn với các mẫu của Lua! Lấy một đối số dòng lệnh làm đầu vào và đầu ra nilcho các trường hợp giả mạo và số được lặp lại khi trung thực.

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

JavaScript, 16 byte

Trong node.js (60 byte)

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

Lãng phí một tấn byte trên đầu vào / đầu ra.

JavaScript ES6 (33 byte)

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

Một lần nữa lãng phí byte trên đầu vào / đầu ra.

Tốt hơn là, như một hàm ẩn danh (22 byte)

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

Hoặc thậm chí ngắn hơn ( 16 byte )

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

Cảm ơn @BusinessCat đã chỉ ra những sai lầm của tôi.

Python 3.5, 49 43 byte:

( -6 byte nhờ các mẹo từ Martin Ender ! )

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

Sử dụng Biểu thức chính quy để khớp với tất cả các chuỗi ký tự lặp lại miễn là chúng lặp lại liên tục 5 lần trở lên. Trả về một ređối tượng khớp (chẳng hạn như <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) nếu một kết quả khớp được tìm thấy như một giá trị trung thực và không có gì hoặc Nonelà một giá trị falsey.

Dùng thử trực tuyến! (Ý)

Perl, 17 15 byte

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

+ pcờ.

(chạy với perl -pe '$_=/(.+)\1{4}/')

Cảm ơn Dom Hasting đã (.+)thay thế(\d+) .

Giải thích nếu cần: (.+)sẽ khớp với bất kỳ phần nào của số và \1{4}$tìm kiếm nếu nó được lặp lại 4 lần liên tiếp.

C # - 93 38 byte

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

Lấy một chuỗi, trả về một số nguyên.

Cảm ơn aloisdg vì đã tiết kiệm rất nhiều byte!

Bình thường , 9 8 byte

1 byte nhờ Maltysen.

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

Giá trị thật là một mảng không trống.

Giá trị Falsey là [] (mảng trống).

Bộ thử nghiệm.

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)

Toán học, 46 40 36 byte

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

Chức năng. Lấy một chuỗi làm đầu vào và đầu ra Truehoặc False. Kiểm tra các chuỗi chống lại biểu thức a__~~a__~~a__~~a__~~a__, đại diện cho chuỗi ký tự tương tự được lặp lại 5 lần. Để tham khảo, giải pháp ngắn nhất sử dụng regex dài 45 byte:

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

^{nguyền rủa bạn thường xuyên!}

PHP, 37 33 byte

cảm ơn NoOneIsHere, tôi đã quên mất <?=

chương trình cho PHP <5.4, in 1cho số nhàm chán, 0khác

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

sử dụng:

• bộ register_globals=1ở php.inicho php-cgi
  sau đó gọiphp-cgi <filename> n=<number>;echo""
• cho PHP> = 5.4, thay thế $nbằng$_GET[n]

giải pháp không regrec, 152 147 140 byte

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

• lợi nhuận thoát mã 1 cho số nhàm chán, 0 khác
  thay thế die(1)với die(print 1)và nối thêm echo 0;để in thay vì
• sử dụng tương tự như trên, nhưng cũng được đặt short_open_tags=1nếu bị tắt
• Vòng lặp bên ngoài có giá trị bắt đầu không hợp lý trong việc chơi gôn, thay thế $n+1bằng ceil(strlen($n)/5)+1hoặc ít nhất là strlen($n)để thử nghiệm hoặc nó có thể lặp lại như mãi mãi.

Haskell, 80 (63?)

Nó sẽ là 63 nếu không có báo cáo nhập khẩu.

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

Sử dụng

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

Nhân tiện, liên tiếp có ý nghĩa với tôi hơn là liên tục.

(Xin lỗi, tôi chưa thể bình luận.)

MATLAB, 26 hoặc 13 byte

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

cái này lấy một biến số nguyên 'i'. Một chuỗi chỉ là phần cuối cùng:

all(s==s(1))

Tôi đã tính dòng mới là một nhân vật.

TSQL, 151 byte

Chơi gôn

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

Ung dung:

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

Vĩ cầm

PowerShell, 26 byte

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

Tôi không có nghĩa là một bậc thầy regex, vì vậy hãy tin vào những câu trả lời khác cho điều đó.

Clojure, 24 byte

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

Sử dụng các giá trị falsey của clojure về nil/ falsevà các giá trị trung thực cho mọi thứ khác. Cụ thể, nilkhi không tìm thấy kết quả khớp cho sai và một mảng []là đúng khi tìm thấy kết quả khớp như đối với 11111 thì ["11111" "1"]đúng.

JS không có biểu thức chính quy, 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}

không rút gọn:

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