Jeśli liczba całkowita zawiera cyfrę / sekwencję cyfr, która powtarza się w sposób ciągły (zrozumiesz, dlaczego powiedziałem „nieprzerwanie”) 5 lub więcej razy, nazywamy to „Nudnym”.

Na przykład 11111jest nudny, a 12345nie jest.

Instrukcje

Weź jako liczbę całkowitą

Podaj prawdziwą wartość, jeśli liczba całkowita jest nudna, i wartość falsey, jeśli liczba całkowita nie jest nudna.

Przykład

11111=> truelub 1(1 powtórzony 5 razy)

12345=> falselub0

1112111=> falselub0

4242424242=> truelub 1(42 powtórzenia 5 razy)

-11111=> truelub1

3452514263534543543543543543876514264527473275=> truelub 1(543 powtarza się 5 razy)

Jeśli używasz innych rodzajów „prawdy” i „fałszu”, podaj je.

Zasady

Obowiązują podstawowe zasady gry w golfa .

Powodzenia!

05AB1E , 8 bajtów

Kod:

Œv¹y5×åO

Wyjaśnienie:

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

Prawda jest niezerowa, a fałsz zero. Wykorzystuje kodowanie CP-1252 .

Wypróbuj online!

Siatkówka , 9 bajtów

(.+)\1{4}

Zweryfikuj wszystkie przypadki testowe! (nieznacznie zmodyfikowany, aby uruchomić wszystkie przypadki testowe jednocześnie).

Java 8, 52 bajty

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

Obezwładnił tę odpowiedź Java 8 bezpośrednio String#matches.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów:

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

Brawo dla Java 8 lambdas! Zwraca, truejeśli znaleziono dopasowanie i falseinaczej.

Wypróbuj online! (Ideone)

Lua, 35 bajtów

Cóż, nie widzę, jak lepiej sobie radzić z wzorami Lui! Pobiera argument wiersza polecenia jako dane wejściowe i wyjściowe nildla przypadków fałszowania, a liczba jest powtarzana, gdy jest prawdziwa.

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

JavaScript, 16 bajtów

W node.js (60 bajtów)

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

Marnowanie ton bajtów na wejściu / wyjściu.

JavaScript ES6 (33 bajty)

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

Ponownie marnowanie bajtów na wejściu / wyjściu.

Najlepiej jako funkcja anonimowa (22 bajty)

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

Lub nawet krótszy ( 16 bajtów )

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

Dzięki @BusinessCat za wskazanie moich błędów.

Python 3.5, 49 43 bajtów:

( -6 bajtów dzięki wskazówkom Martina Endera ! )

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

Używa wyrażenia regularnego do dopasowania wszystkich powtarzających się sekwencji znaków, o ile powtarzają się one nieprzerwanie 5 lub więcej razy. Zwraca reobiekt dopasowania (np. <_sre.SRE_Match object; span=(0, 10), match='4242424242'>), Jeśli dopasowanie zostanie znalezione jako wartość zgodna z prawdą i jako nic lub Nonejako wartość falsey.

Wypróbuj online! (Ideone)

Perl, 17 15 bajtów

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

+ pflaga.

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

Dzięki Dom Hasting za (.+)zamiast(\d+) .

Wyjaśnienia w razie potrzeby: (.+)dopasują dowolną część liczby i \1{4}$sprawdzą, czy jest powtarzana 4 razy pod rząd.

C # - 93 38 bajtów

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

Bierze ciąg, zwraca liczbę całkowitą.

Dzięki aloisdg za oszczędność wielu bajtów!

Pyth , 9 8 bajtów

1 bajt dzięki Maltysen.

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

Prawda jest niepustą tablicą.

Wartość Falsey to [](pusta tablica).

Zestaw testowy.

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 bajtów

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

Funkcjonować. Bierze ciąg jako dane wejściowe i wyjściowe Truelub False. Testuje ciągi znaków względem wyrażenia a__~~a__~~a__~~a__~~a__, które reprezentuje tę samą sekwencję znaków powtórzoną 5 razy. Dla porównania, najkrótsze rozwiązanie z wyrażeniem regularnym ma długość 45 bajtów:

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

^{przeklinam cię RegularExpression!}

PHP, 37 33 bajtów

dzięki NoOneIsHere zapomniałem o tym <?=

Program dla PHP <5,4, druki 1dla nudny numery, 0inny

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

stosowanie:

• zestaw register_globals=1w php.iniPHP CGI
  następnie zadzwonićphp-cgi <filename> n=<number>;echo""
• PHP> = 5,4, wymienić $nz$_GET[n]

rozwiązanie nieregexp, 152 147 140 bajtów

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

• kod wyjścia zwraca 1 dla liczb nudny, 0 jeszcze
  wymienić die(1)z die(print 1)i dołączyć echo 0;do drukowania zamiast
• takie samo użycie jak powyżej, ale również ustawione, short_open_tags=1jeśli wyłączone
• Zewnętrzna pętla uzyskała nieuzasadnioną wartość początkową podczas gry w golfa, zamień $n+1ją na ceil(strlen($n)/5)+1lub przynajmniej strlen($n)na testowanie, lub może zapętlić się jak zawsze.

Haskell, 80 (63?)

Byłoby 63, gdyby nie było wyciągu z importu.

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

Stosowanie

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

Nawiasem mówiąc, kolejne mają dla mnie większy sens niż ciągłe.

(Przepraszam, nie mogę jeszcze komentować.)

MATLAB, 26 lub 13 bajtów

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

bierze to zmienną całkowitą „i”. Łańcuch to tylko ostatnia część:

all(s==s(1))

Policzyłem nowy wiersz jako znak.

TSQL, 151 bajtów

Gra w golfa:

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

Nie golfowany:

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

Skrzypce

PowerShell, 26 bajtów

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

W żadnym wypadku nie jestem mistrzem wyrażeń regularnych, więc dziękuję innym za to.

Clojure, 24 bajty

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

Używa falsey wartości clojure i nil/ falsei prawdziwych wartości dla wszystkiego innego. W szczególności, nilgdy nie zostanie znalezione dopasowanie dla fałszu, a tablica []dla wartości true, gdy zostanie znalezione dopasowanie, jak dla 11111, wówczas ["11111" "1"]jest prawdziwa.

JS bez wyrażeń regularnych, 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}

nie zminimalizowane:

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