Bir tamsayı içinde sürekli olarak yinelenen bir rakam / rakam dizisi varsa (neden "sürekli" dediğimi anlayacaksınız) 5 veya daha fazla kez, "Sıkıcı" olarak adlandırırız.

Örneğin 11111, sıkıcı, oysa 12345değildir.

Talimatlar

Girdi olarak bir Tamsayı al

Tamsayı sıkıcı ise bir truthy değeri ve tamsayı sıkıcı değilse bir falsey değeri verin.

Örnek

11111=> trueveya 1(1, 5 kez tekrar eder)

12345=> falseveya0

1112111=> falseveya0

4242424242=> trueveya 1(42 5 kez tekrar eder)

-11111=> trueveya1

3452514263534543543543543543876514264527473275=> trueveya 1(543 5 kez tekrarlar)

Başka "doğruluk" ve "yanlış" türlerini kullanıyorsanız, belirtin.

kurallar

Temel kod-golf kuralları geçerlidir.

İyi şanslar!

05AB1E , 8 bayt

Kod:

Œv¹y5×åO

Açıklama:

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

Hakikat sıfır değildir ve sahte sıfırdır. CP-1252 kodlamasını kullanır .

Çevrimiçi deneyin!

Retina , 9 bayt

(.+)\1{4}

Tüm test durumlarını doğrulayın! (tüm test pencerelerini bir kerede çalıştırmak için hafifçe değiştirildi.)

Java 8, 52 bayt

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

Outgolfed bu Java 8 cevabı doğrudan sahip String#matches.

Açıklama:

Burada dene.

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

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

Java 8 lambdaları için yaşasın! Eşleşme truebulunursa ve falseaksi takdirde döner.

Çevrimiçi Deneyin! (Ideone)

Lua, 35 Bayt

Şey, Lua'nın kalıplarıyla nasıl daha iyi yapabileceğimi anlamıyorum! nilSahte durumlarda giriş ve çıkış olarak komut satırının argümanını ve gerçek olduğunda tekrarlanan sayıyı alır.

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

JavaScript, 16 bayt

Node.js içinde (60 bayt)

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

Giriş / çıkışta bir ton bayt harcamak .

JavaScript ES6 (33 bayt)

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

Yine giriş / çıkışta bayt israfı.

Tercihen, isimsiz bir işlev olarak (22 bayt)

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

Veya daha kısa ( 16 bayt )

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

@BusinessCat, hatalarımı işaret ettiği için teşekkür ederiz.

Python 3.5, 49 43 bayt:

( Martin Ender'den gelen ipuçları sayesinde -6 bayt ! )

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

Sürekli olarak 5 veya daha fazla kez tekrarladıkları sürece tüm yinelenen karakter dizileriyle eşleşmesi için Normal İfade kullanır. Bir reeşleşme <_sre.SRE_Match object; span=(0, 10), match='4242424242'>truthy değeri ve hiçbir şey veya falsey değeri olarak bulunursa, eşleşme nesnesini (örneğin ) döndürür None.

Çevrimiçi Deneyin! (Ideone)

Perl, 17 15 bayt

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

+ pbayrak.

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

(.+)Bunun yerine Dom Hasting'e teşekkürler (\d+).

Gerekirse açıklama: (.+)sayının herhangi bir kısmıyla eşleşir ve \1{4}$4 kez tekrar edilip edilmediğini arar.

C # - 93 38 bayt

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

Bir dize alır, bir tamsayı döndürür.

Bir sürü baytı kurtardığınız için aloisdg'a teşekkürler !

Pyth , 9 8 bayt

Maltysen sayesinde 1 bayt.

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

Truthy değeri boş olmayan bir dizidir.

Falsey değeri [](boş dizi).

Test odası.

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 bayt

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

İşlev. Bir dize girdi olarak alır ve çıktılar Trueveya False. a__~~a__~~a__~~a__~~a__5 kez tekrarlanan aynı karakter sırasını temsil eden ifadeye karşı dizeleri test eder. Başvuru için, bir regex kullanan en kısa çözüm 45 bayttır:

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

^{Lanet olsun seni RegularExpression!}

PHP, 37 33 bayt

NoOneIsHere sayesinde, unuttum <?=

PHP <5.4 programı, 1sondaj numaralarını yazdırır , 0başka

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

kullanımı:

• set register_globals=1içinde php.iniphp-cgi için
  daha sonra çağrıphp-cgi <filename> n=<number>;echo""
• PHP> = 5.4 için, değiştirmek $nile$_GET[n]

regexp olmayan çözüm, 152 147 140 bayt

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

• sıkıcı sayılar için 1 çıkış kodunu döndürür, 0 ile
  değiştirin ve bunun yerine yazdırmayı ekleyindie(1)die(print 1)echo 0;
• yukarıdakiyle aynı kullanım, ancak short_open_tags=1devre dışı bırakılırsa da ayarlanır
• Dış döngü, golf oynamada makul olmayan bir başlangıç ​​değeri aldı; test için veya ile en azından bununla değiştirin $n+1; aksi takdirde sonsuza kadar değişebilir.ceil(strlen($n)/5)+1strlen($n)

Haskell, 80 (63?)

Alma ifadesi olmasaydı 63 olur.

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

kullanım

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

Bu arada, ardışık olarak bana sürekli daha anlamlı geliyor .

(Üzgünüm, henüz yorum yapamam.)

MATLAB, 26 veya 13 bayt

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

bu 'i' tamsayı değişkeni alır. Bir dize sadece son kısmıdır:

all(s==s(1))

Newline'ı karakter olarak saydım.

TSQL, 151 bayt

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

Keman

PowerShell, 26 bayt

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

Hiçbir şekilde bir regex ustası değilim, bu yüzden bunun için diğer cevaplara kredi verin.

Clojure, 24 bayt

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

Kullanımları Clojure en Falsey değerlerini nil/ falseher şey için ve truthy değerleri. Özellikle, nilfalse []için eşleşme bulunmadığında ve 11111 için olduğu gibi bir eşleşme bulunduğunda true için bir dizi daha sonra ["11111" "1"]doğrudur.

Regexs olmadan 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}

küçültülmüş değil:

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