Jika bilangan bulat memiliki angka / urutan digit di dalamnya yang berulang terus menerus (Anda akan mengerti mengapa saya mengatakan "terus menerus") 5 kali atau lebih, kami menyebutnya "Membosankan".

Misalnya, 11111Membosankan, sedangkan 12345tidak.

Instruksi

Ambil Integer sebagai Input

Keluarkan nilai yang benar jika bilangan bulat itu membosankan, dan nilai yang salah jika bilangan bulat itu tidak membosankan.

Contoh

11111=> trueatau 1(1 berulang 5 kali)

12345=> falseatau0

1112111=> falseatau0

4242424242=> trueatau 1(42 berulang 5 kali)

-11111=> trueatau1

3452514263534543543543543543876514264527473275=> trueatau 1(543 berulang 5 kali)

Jika Anda menggunakan jenis "kebenaran" dan "salah" lainnya, sebutkan.

Aturan

Aturan main kode-golf berlaku.

Semoga berhasil!

05AB1E , 8 byte

Kode:

Œv¹y5×åO

Penjelasan:

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

Kebenaran adalah bukan nol dan kepalsuan adalah nol. Menggunakan pengkodean CP-1252 .

Cobalah online!

Retina , 9 byte

(.+)\1{4}

Verifikasi semua testcases! (sedikit dimodifikasi untuk menjalankan semua testcass sekaligus.)

Java 8, 52 byte

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

Mengungguli jawaban Java 8 ini dengan langsungString#matches .

Penjelasan:

Coba di sini.

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

Hore untuk lambda Jawa 8! Kembali truejika kecocokan ditemukan dan falsesebaliknya.

Cobalah secara Online! (Ideone)

Lua, 35 Bytes

Yah, saya tidak melihat bagaimana melakukan lebih baik dengan pola Lua! Mengambil argumen command-line sebagai input dan output niluntuk kasus falsy, dan nomor diulang saat kebenaran.

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

JavaScript, 16 byte

Dalam node.js (60 byte)

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

Buang satu ton byte pada input / output.

JavaScript ES6 (33 byte)

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

Sekali lagi membuang-buang byte pada input / output.

Lebih disukai, sebagai fungsi anonim (22 byte)

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

Atau bahkan lebih pendek ( 16 byte )

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

Terima kasih @BusinessCat untuk menunjukkan kesalahan saya.

Python 3.5, 49 43 byte:

( -6 byte berkat tips dari Martin Ender ! )

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

Menggunakan Ekspresi Reguler untuk mencocokkan semua urutan karakter berulang selama mereka mengulangi terus menerus 5 kali atau lebih. Mengembalikan reobjek kecocokan (seperti <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) jika kecocokan ditemukan sebagai nilai yang benar, dan tidak ada atau Nonesebagai nilai falsey.

Cobalah secara Online! (Ideone)

Perl, 17 15 byte

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

+ pbendera.

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

Terima kasih kepada Dom Hasting untuk (.+)alih - alih (\d+).

Penjelasan jika diperlukan: (.+)akan cocok dengan bagian mana pun dari nomor tersebut, dan \1{4}$mencari apakah itu diulang 4 kali eksekutif.

C # - 93 38 byte

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

Mengambil string, mengembalikan bilangan bulat.

Terima kasih kepada aloisdg karena telah menghemat banyak byte!

Pyth , 9 8 byte

Terima kasih 1 byte untuk Maltysen.

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

Nilai sebenarnya adalah array yang tidak kosong.

Nilai Falsey adalah [](array kosong).

Suite uji.

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 byte

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

PHP, 37 33 bytes

terima kasih kepada NoOneIsHere, saya lupa <?=

program untuk PHP <5.4, mencetak 1untuk angka yang membosankan, yang 0lain

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

pemakaian:

• ditetapkan register_globals=1dalam php.iniuntuk php-cgi
  then call php-cgi <filename> n=<number>;echo""
• untuk PHP> = 5.4, ganti $ndengan$_GET[n]

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

• mengembalikan kode 1 untuk nomor yang membosankan, 0
  diganti die(1)dengan yang lain die(print 1)dan tambahkan echo 0;untuk mencetak
• penggunaan yang sama seperti di atas, tetapi juga diatur short_open_tags=1jika dinonaktifkan
• Loop luar mendapat nilai awal yang tidak masuk akal dalam golf, ganti $n+1dengan ceil(strlen($n)/5)+1atau setidaknya dengan strlen($n)untuk pengujian atau mungkin loop seperti selamanya.

Haskell, 80 (63?)

Ini akan menjadi 63 jika tidak ada pernyataan impor.

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

Pemakaian

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

By the way, berturut-turut lebih masuk akal bagi saya daripada terus menerus.

(Maaf, saya belum bisa berkomentar.)

MATLAB, 26 atau 13 byte

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

ini membutuhkan variabel integer 'i'. Sebuah string hanyalah bagian terakhir:

all(s==s(1))

Saya telah menghitung baris baru sebagai karakter.

TSQL, 151 byte

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

Tidak Disatukan:

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

Biola

PowerShell, 26 byte

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

Saya sama sekali tidak master regex, jadi kredit untuk jawaban lain untuk itu.

Clojure, 24 byte

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

Menggunakan nilai-nilai kepalsuan clojure tentang nil/ falsedan nilai-nilai kebenaran untuk semua hal lainnya. Khususnya, nilketika tidak ada kecocokan yang ditemukan untuk false, dan sebuah array []untuk true ketika kecocokan ditemukan seperti untuk 11111 maka ["11111" "1"]itu benar.

JS tanpa regex, 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}

tidak diperkecil:

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