यदि किसी पूर्णांक में अंकों का एक क्रम / अनुक्रम होता है जो लगातार दोहराता है (आप समझेंगे कि मैंने "लगातार" क्यों कहा) 5 या अधिक बार, हम इसे "बोरिंग" कहते हैं।

उदाहरण के लिए, 11111बोरिंग है, जबकि 12345नहीं है।

अनुदेश

इनपुट के रूप में एक पूर्णांक ले लो

यदि पूर्णांक उबाऊ है, और पूर्णांक मूल्य उबाऊ नहीं है, तो एक सत्य मान का उत्पादन करें।

उदाहरण

11111=> trueया 1(5 बार दोहराता है)

12345=> falseया0

1112111=> falseया0

4242424242=> trueया 1(42 बार 5 बार दोहराता है)

-11111=> trueया1

3452514263534543543543543543876514264527473275=> trueया 1(543 बार दोहराता है)

यदि आप अन्य प्रकार के "सत्य" और "असत्य" का उपयोग करते हैं, तो इसे निर्दिष्ट करें।

नियम

बुनियादी कोड-गोल्फ नियम लागू होते हैं।

सौभाग्य!

code-golf number

— Rɪᴋᴇʀ
स्रोत

है 1112111उबाऊ?

— लीक नन

1

है 4242424242उबाऊ?

— घातक

4242424242 बोरिंग है ।1212111 नहीं है।

22

मुझे लगता है कि आज संख्या का दिन है जिसे कोई पसंद नहीं करता है। :)

— सिम्स

12

कड़ाई से बोलना, सभी संख्याएँ उबाऊ हैं, क्योंकि उन सभी को एक प्रमुख शून्य की मनमानी संख्या के साथ लिखा जा सकता है। :-)

— celtschk 14

13

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.

Truthy गैर-शून्य है और falsy शून्य है। CP-1252 एन्कोडिंग का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

1

के Œसाथ संयोजन का अच्छा उपयोग करें ×।

— एमीना जूल

1

@ अदनान अच्छा काम! c =

23

रेटिना , 9 बाइट्स

(.+)\1{4}

सभी टेस्टकेस को सत्यापित करें! (एक बार में सभी टेस्टकेस चलाने के लिए थोड़ा संशोधित।)

— लीक नन
स्रोत

4

रुको, लोग यह तेजी से कर रहे हैं?

मैं इसे पोस्ट करने के लिए बहुत धीमा था। जानता था कि रेटिना को यह चुनौती पसंद आएगी :)

— एमिग्ना

@ एमिग्ना सॉरी एक्सडी

— लीकी नून

1

@LuisMendo किसी भी 5+ से मेल नहीं खाता, भले ही वे समान हों या न हों? उदाहरण के लिए यह मैच होगा12345

— Emigna

4

@LuisMendo में (.+){5}फैलता है (.+)(.+)(.+)(.+)(.+)जबकि तक (.+)\1{4}फैलता है (.+)\1\1\1\1।

— लीक नून

7

जावा 8, 52 बाइट्स

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

एक प्रत्यक्ष के साथ इस जावा 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

— केविन क्रूज़सेन
स्रोत

6

जावा 8, 73 66 बाइट्स:

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

जावा 8 लंबोदर के लिए हुर्रे! रिटर्नtrueअगर मैच मिला और falseनहीं तो ।

यह ऑनलाइन की कोशिश करो! (Ideone)

— आर। कप
स्रोत

4

लुआ, 35 बाइट्स

खैर, मुझे नहीं लगता कि लूआ के पैटर्न के साथ बेहतर कैसे करना है! nilझूठे मामलों के लिए इनपुट और आउटपुट के रूप में एक कमांड-लाइन तर्क देता है, और सत्य होने पर दोहराई जाने वाली संख्या।

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

— Katenkyo
स्रोत

4

जावास्क्रिप्ट, 16 बाइट्स

नोड में (60 बाइट्स)

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

एक टन बर्बाद कर रहे हैंइनपुट / आउटपुट पर बाइट ।

जावास्क्रिप्ट ईएस 6 (33 बाइट्स)

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

फिर से इनपुट / आउटपुट पर बाइट्स बर्बाद करना।

अधिमानतः, एक अनाम फ़ंक्शन (22 बाइट्स) के रूप में

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

या उससे भी कम ( 16 बाइट्स )

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

मेरी गलतियों को इंगित करने के लिए @BusinessCat धन्यवाद।

— charredgrass
स्रोत

1

आप /(.+)\1{4}/.test(n)इसके बजाय उपयोग कर सकते हैं matchजो कुछ बाइट्स बचाता है। यह भी ऐसा नहीं लगता है कि यह वास्तव में कुछ भी उत्पादन करेगा।

— बिजनेस कैट

@BusinessCat आप बिल्कुल सही हैं, मुझे लगता है कि मैं इस सवाल में चूक गया। सलाह के लिये धन्यवाद।

— charredgrass

आपको मानक इनपुट लेने की आवश्यकता नहीं है, आप

— कैट

2

Uncaught TypeError: Method RegExp.prototype.test called on incompatible receiver undefined। मुझे यकीन नहीं है कि अगर तकनीकी रूप से एक सही उत्तर के रूप में गिना जाता है, तो क्या ऐसा कुछ होने की आवश्यकता नहीं होगी /./.test.bind(/(.+)\1{4}/)?

— पैट्रिक रॉबर्ट्स

प्रश्न में कहा गया है कि "किसी भी संख्या को 5 या अधिक बार दोहराया गया" बोरिंग है।

— टूथब्रश

3

पायथन 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)

— आर। कप
स्रोत

3

आह, सर्वशक्तिमान रेगेक्स।

2

{4,}द्वारा प्रतिस्थापित करें {4}?

— लीक नून

@LeakyNun Yeah, that also works.

— R. Kap

What's the \1 do after the regex group?

— speedplane

@speedplane Matches any subsequent occurrences of the match from the group.

— R. Kap

2

Perl, 17 15 bytes

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

+ the p flag.

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

Thanks to Dom Hasting for the (.+) instead of (\d+).

Explanations if needed : (.+) will match any part of the number, and \1{4}$ searches if it is repeated 4 times consecutives.

— Dada
स्रोत

Good one, but there are better golfers out there. Its still good though.

4

I'm not sure Perl can do better than that... And I still wanted to submit a Perl solution, so here it is.

— Dada

Can you add an explanation?

I think you might need $_=/(\d+)\1{4}/ instead as 111112 is boring but this won't catch it. You might even be able to use /./ as per the Retina answer.

— Dom Hastings

1

Yup you're right, I was tring to match a "very boring number" when only boring ones were enough

— दादा

1

C# - 93 38 bytes

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

Takes a string, returns an integer.

Thanks to aloisdg for saving a lot of bytes!

— Yytsi
स्रोत

You can take the argument as a string though, which should save you some bytes.

— Leaky Nun

1

Wouldn't @"(.+)\1{4}" work as the regex as well? Does in my C# environment at least.

— एमिग्ना जूल

You can use a lambda. It is allowed. s=>Syst...

— aloisdg says Reinstate Monica

@Emigna - it would definitely work regardless of the C# environment. Anything with >5 consecutive characters will also work for exactly 5 consecutive characters.

— charredgrass

1

Also, I think that we should be able to write s=>new Regex(@"(.+)\1{4}").IsMatch(s); Because we stay in .NET (which his our stdlib) and we never count for using System.Linq; or using System.Collections.Generic.

— aloisdg says Reinstate Monica

1

Pyth, 9 8 bytes

1 byte thanks to Maltysen.

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

Truthy value is a non-empty array.

Falsey value is [] (empty array).

Test suite.

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)

— Leaky Nun
स्रोत

get 8 bytes by replacing m with f and taking out the sum.

— Maltysen

1

मैथेमेटिका, 46 40 36 बाइट्स

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

समारोह। इनपुट और आउटपुट के रूप में एक स्ट्रिंग लेता है Trueया False। अभिव्यक्ति के खिलाफ टेस्ट स्ट्रिंग्स a__~~a__~~a__~~a__~~a__, जो 5 बार दोहराए गए एक ही चरित्र अनुक्रम का प्रतिनिधित्व करता है। संदर्भ के लिए, रेगेक्स का उपयोग करने वाला सबसे छोटा समाधान 45 बाइट्स लंबा है:

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

^{आप नियमित रूप से शाप!}

— LegionMammal978
स्रोत

पैटर्न मिलान का अच्छा उपयोग।

— मील

1

PHP, 37 33 बाइट्स

NoOneIsHere के लिए धन्यवाद, मैं भूल गया <?=

PHP <5.4 के लिए प्रोग्राम, 1उबाऊ संख्या के लिए प्रिंट , 0और

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

उपयोग:

सेट register_globals=1में php.iniphp-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)परीक्षण के लिए या इसे हमेशा के लिए की तरह पाश हो सकता है।

— टाइटस
स्रोत

1

<?=preg_match... कुछ

— चार्ट

1

हास्केल, 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"

वैसे, निरंतर की तुलना में मेरे लिए लगातार अधिक समझ में आता है ।

(क्षमा करें, मैं अभी तक टिप्पणी नहीं कर सकता।)

— Zylviij
स्रोत

1

मुझे उम्मीद है कि मेरे अपवोट ने खुद को टिप्पणी करने में सक्षम बनाने में मदद की।

0

MATLAB, 26 या 13 बाइट्स

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

यह पूर्णांक चर 'i' लेता है। एक स्ट्रिंग सिर्फ अंतिम भाग है:

all(s==s(1))

मैंने न्यूलाइन को एक चरित्र के रूप में गिना है।

— रिचर्ड
स्रोत

आपको इनपुट निर्दिष्ट करने की आवश्यकता है, उदाहरण के लिए। इसे साथ ले जाएं i=input('')या पूरी चीज़ को एक फंक्शन बनाएं (जैसे। @(i)...)। BTW, मुझे लगता है कि यह पहले से ही एक स्ट्रिंग के रूप में पूर्णांक लेने के लिए बहुत अधिक खिंचाव होगा। पीएस मुझे लगता है कि यह अंतिम परीक्षण के मामले में विफल रहता है और सरल भी 211111।

— पजाकोंक

जिसने भी प्रश्न संपादित किया है: वह मत करो। यदि ओपी ने कुछ समय बाद (जैसे कल) जवाब नहीं दिया है, तो आप संपादित करने का प्रयास कर सकते हैं। इसके अलावा, इसे हटाने की जरूरत है, गैर-प्रतिस्पर्धा के रूप में नहीं रखा गया है।

— 14

0

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

बेला

— t-clausen.dk
स्रोत

0

पॉवरशेल, 26 बाइट्स

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

मैं किसी भी तरह से एक रेगेक्स मास्टर नहीं हूं, इसलिए इसके लिए अन्य उत्तरों का श्रेय देता हूं।

— ThePoShWolf
स्रोत

0

क्लोजर, 24 बाइट्स

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

क्लोजर के nil/ falseऔर सब कुछ के लिए सत्य मूल्यों के झूठे मूल्यों का उपयोग करता है। विशेष रूप से, nilजब कोई मैच झूठे के लिए नहीं पाया जाता है, और []सच के लिए एक सरणी जब एक मैच 11111 के लिए की तरह पाया ["11111" "1"]जाता है तो सच है।

— क्रिस एफ
स्रोत

0

जेएस रेगेक्स के बिना, 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'));

— caub
स्रोत

1

नमस्ते, और PPCG में आपका स्वागत है! हालांकि, यह वास्तव में अधिक गोल्फ हो सकता है। ज्यादा छोटे कोड के लिए आप सिर्फ अतिरिक्त व्हाट्सएप को हटा सकते हैं। कृपया इसे या तो गोल्फ करें या हटाएं।

— Rɪᴋᴇʀ

मुझे रेगेक्स से बचने का विचार पसंद है। बदलें (['उबाऊ', 'जाने', 'गलत', 'सच'] ['बी', '', '0', '1']; कि 20 पात्रों में कटौती

— Coomie

गोल्फ बोरिंग नंबर खोजने के लिए