हीट वेव्स का पता लगाएं

Question

पृष्ठभूमि

रॉयल नीदरलैंड मौसम विज्ञान संस्थान Netherlands25 ° C मौसम ("गर्मियों का मौसम") के कम से कम 5 लगातार दिनों की एक श्रृंखला के रूप में एक हीट वेव * को परिभाषित करता है , जैसे कि उन दिनों के कम से कम 3 ° °30 ° C ("उष्णकटिबंधीय मौसम") )।

उष्णकटिबंधीय मौसम को लगातार नहीं मापा जाना चाहिए: उदाहरण के लिए: 30, 25, 30, 26, 27, 28, 32, 30उष्णकटिबंधीय मौसम के 4 दिनों के साथ 8 दिनों की लंबी गर्मी की लहर है।

^{* (खैर, डच मानकों के अनुसार।)}

चुनौती

क्रमिक दिनों से सेल्सियस तापमान माप का प्रतिनिधित्व करने वाले सकारात्मक पूर्णांकों की एक गैर-खाली सूची को देखते हुए, तय करें कि उस सूची में गर्मी की लहर है (उपरोक्त परिभाषा के अनुसार)।

बाइट्स जीत में सबसे छोटा जवाब।

परीक्षण के मामलों

Falsey:

[30]
[29, 29, 29, 47, 30]
[31, 29, 29, 28, 24, 23, 29, 29, 26, 27, 33, 20, 26, 26, 20, 30]
[23, 31, 29, 26, 30, 24, 29, 29, 25, 27, 24, 28, 22, 20, 34, 22, 32, 24, 33]
[23, 24, 25, 20, 24, 34, 28, 32, 22, 20, 24]
[24, 28, 21, 34, 34, 25, 24, 33, 23, 20, 32, 26, 29, 29, 25, 20, 30, 24, 23, 21, 27]
[26, 34, 21, 32, 32, 30, 32, 21, 34, 21, 34, 31, 23, 27, 26, 32]
[29, 24, 22, 27, 22, 25, 29, 26, 24, 24, 20, 25, 20, 20, 24, 20]
[23, 33, 22, 32, 30]
[28, 21, 22, 33, 22, 26, 30, 28, 26, 23, 31, 22, 31, 25, 27, 27, 25, 28]
[27, 23, 42, 23, 22, 28]
[25, 20, 30, 29, 32, 25, 22, 21, 31, 22, 23, 25, 22, 31, 23, 25, 33, 23]

Truthy:

[30, 29, 30, 29, 41]
[1, 1, 25, 30, 25, 30, 25, 25, 25, 25, 25, 25, 25, 25, 40, 1, 1]
[31, 34, 34, 20, 34, 28, 28, 23, 27, 31, 33, 34, 29, 24, 33, 32, 21, 34, 30, 21, 29, 22, 31, 23, 26, 32, 29, 32, 24, 27]
[26, 29, 22, 22, 31, 31, 27, 28, 32, 23, 33, 25, 31, 33, 34, 30, 23, 26, 21, 28, 32, 22, 30, 34, 26, 33, 20, 27, 33]
[20, 31, 20, 29, 29, 33, 34, 33, 20]
[25, 26, 34, 34, 41, 28, 32, 30, 34, 23, 26, 33, 30, 22, 30, 33, 24, 20, 27, 23, 30, 23, 34, 20, 23, 20, 33, 20, 28]
[34, 23, 31, 34, 34, 30, 29, 31, 29, 21, 25, 31, 30, 29, 29, 28, 21, 29, 33, 25, 24, 30]
[22, 31, 23, 23, 26, 21, 22, 20, 20, 28, 24, 28, 25, 31, 31, 26, 33, 31, 27, 29, 30, 30]
[26, 29, 25, 30, 32, 28, 26, 26, 33, 20, 21, 32, 28, 28, 20, 34, 34]
[34, 33, 29, 26, 34, 32, 27, 26, 22]
[30, 31, 23, 21, 30, 27, 32, 30, 34, 29, 21, 31, 31, 31, 32, 27, 30, 26, 21, 34, 29, 33, 24, 24, 32, 27, 32]
[25, 33, 33, 25, 24, 27, 34, 31, 29, 31, 27, 23]

Comments

क्या तापमान 100 सेल्सियस से नीचे रहने की गारंटी है?

— FryAmTheEggman

@FryAmTheEggman वैसे, नीदरलैंड में, हाँ :), लेकिन मैं इस तथ्य का दुरुपयोग करने के लिए आपका जवाब नहीं चाहता, इसलिए नहीं।

— लिन

@ हैटवेयर हाँ, यह ठीक है। उदाहरण के लिए "क्रैश / क्रैश न करें" भी ठीक है।

— लिन

अरे @ लियन यह एक बड़ी चुनौती थी और अभी भी :-)

— रोलाण्ड शमित्ज़

@RolandSchmitz धन्यवाद! मुझे चुनौती के जीवनकाल में इतनी देर से आए रचनात्मक जवाबों से खुशी है। 🎉

— लिन

Answer 1

सी (जीसीसी) , 88 75 बाइट्स

h,e,a;t(int*_){for(h=e=a=0;*_;h+=e>4&a>2)e+=*_>24||(e=a=0),a+=*_++>29;e=h;}

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

Comments

h,e,a;t- अच्छा स्पर्श!

— user9549915

Answer 2

जेली , 15 बाइट्स

:5_5Ṡ‘ẆP«LƊ€>4Ṁ

एक मोनाडिक लिंक संख्याओं की एक सूची को स्वीकार करता है जो 1एक हीटवेव का पता लगाने पर वापस आती है 0।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

मानदंड 25 से अधिक या उसके बराबर चार से अधिक मानों के रन का अस्तित्व है, जिनमें से दो का 30 से अधिक या इसके बराबर होना चाहिए।

यदि हम पाँच से विभाजित करते हैं तो मानदंड पाँच से अधिक या उसके बराबर चार से अधिक मानों के रन का अस्तित्व बन जाता है, जिनमें से दो से अधिक छह से अधिक या इसके बराबर होना चाहिए।

यदि हम इन मानों में से पाँच घटाते हैं तो मानदंड शून्य से अधिक या उसके बराबर चार से अधिक मानों के रन का अस्तित्व बन जाता है, जिनमें से दो से अधिक या एक के बराबर होना चाहिए।

यदि हम इन मूल्यों (-1, 0, या 1 प्राप्त करना) का संकेत लेते हैं, तो मानदंड -1 के बराबर चार से अधिक मूल्यों के रन का अस्तित्व बन जाता है, जिनमें से दो से अधिक एक के बराबर होना चाहिए।

यदि हम इन मूल्यों में एक जोड़ते हैं (0, 1, या 2 प्राप्त करते हैं) मानदंड शून्य से अधिक नहीं के चार से अधिक मूल्यों के रन का अस्तित्व बन जाता है, जिनमें से दो से अधिक दो के बराबर होना चाहिए।

किसी भी शून्य वाली सूची का उत्पाद शून्य है और दो से अधिक जुड़वां (और बाकी होने वाले) वाली सूची का उत्पाद चार से अधिक है। इसका मतलब यह है कि इस समायोजित सूची के मानदंड बन जाते हैं कि उत्पाद की न्यूनतम और लंबाई 4 से अधिक है।

:5_5Ṡ‘ẆP«LƊ€>4Ṁ - Link: list of numbers
:5              - integer divide by five (vectorises)
  _5            - subtract five (vectorises)
    Ṡ           - sign {negatives:-1, zero:0, positives:1} (vectorises)
     ‘          - increment (vectorises)
      Ẇ         - all sublists
          Ɗ€    - last three links as a monad for €ach:
       P        -   product
         L      -   length
        «       -   minimum
            >4  - greater than four? (vectorises) -- 1 if so, else 0
              Ṁ - maximum -- 1 if any are 1, else 0

Answer 3

हास्केल , 73 72 71 69 67 66 बाइट्स

any(\a->sum[1|x<-a,x>29,take 4a<a]>2).scanl(\a t->[0|t>24]>>t:a)[]

दो बाइट्स के लिए @flawr और @Laoni के लिए धन्यवाद और एक बाइट के लिए @xnor!

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

समान लंबाई:

any(\a->take 4a<a&&sum a>2).scanl(\a t->[0|t>24]>>sum[1|t>29]:a)[]

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

Answer 4

सी (क्लैंग) , 64 बाइट्स

h;o(*t){for(h=1;*t;++t)h=h&&*t<25?1:h*(*t<30?2:6)%864;return!h;}

फ़ंक्शन ओ () हीटवेव या 0 के लिए 1 लौटाता है।

उनके विचारों के लिए जादू नंबर 864 और उडो बोरकोव्स्की और मैथिस के लिए धन्यवाद ।

कैसे काम करता है? संख्याओं के प्रत्येक अनुक्रम को कम मान पर शुरू किए गए एक कम ऑपरेशन के साथ पुनरावृत्त किया जाता है। यदि एक संख्या> = 25 को कम देखा जाता है तो 2. से गुणा किया जाता है। यदि संख्या> = 30 को देखा जाए तो कमी 2 से गुणा होकर 3 = होती है। 6. यदि कोई संख्या <25 देखी जाती है, तो कमी फिर से शुरू होती है। 1. यदि कमी 864 = 2 * 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3 से विभाज्य है, तो एक हीटवेव मिल जाता है, और परिणाम मोडुलो ऑपरेशन 0 होता है जिसके परिणामस्वरूप 0 का मान कम होता है और रिटर्न का सही मान होता है।

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

Comments

PPCG में आपका स्वागत है।

— मुहम्मद सलमान

PPCG में आपका स्वागत है! टेस्ट केस सूट के साथ बहुत अच्छा पहला जवाब पूरा! क्या आप एक स्पष्टीकरण जोड़ सकते हैं ताकि हम जादू को समझ सकें?

— JayCe

यह एक बहुत ही सुंदर समाधान है, अच्छी तरह से किया :)

— लिन

Answer 5

पायथन 3 , 79 बाइट्स

lambda T:any(len(s)>4<sum(s+s)for s in bytes(t>29or(t<25)*9for t in T).split())

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

Answer 6

APL (Dyalog Classic) , 21 20 बाइट्स

1∊8≤4↓⍉×\25 30⍸↑,⍨\⎕

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

का उपयोग करता है ⎕io←1

25 30⍸x 0 है अगर x <२५, १ अगर २५≤x <३०, या २ अन्यथा

हम सभी संभावित स्थानों से शुरू होने वाले (या समतुल्य: समाप्त होने वाले) उत्पादों की संचयी उत्पादों की गणना करते हैं, पहले 4 उत्पादों को छोड़ देते हैं, और उत्पादों की उपस्थिति का पता लगाते हैं (8 (जो 2 ^{3 है} )

Answer 7

जाप , 19 18 बाइट्स

ô<25 d_ʨ5©3§Zè¨30
ô                  // Partition the input at every item
 <25               // where the value is less than 25.
     d_            // Then, return whether any resulting subarray
       ʨ5         // is at least five items long
          ©        // and
           3§      // has at least three items
             Zè¨30 // with a value of at least 30.

मुझे उम्मीद है कि मुझे टिप्पणियों में सभी चर्चाएं सही ढंग से मिलेंगी। झबरा
धन्यवाद करने के लिए एक बाइट बंद मुंडा ।

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

Comments

सोचा कि जब मैं इसके माध्यम से पढ़ रहा था तो यह कम काम करेगा लेकिन केवल 18 बाइट्स का प्रबंधन कर सकता था ।

— झबरा

@ शैगी मुझे भी ऐसा लगा, लेकिन मुझे इससे छोटा वर्जन भी नहीं मिला। सूचक के लिए बहुत बहुत धन्यवाद!

— लीख

ऐसा लगता है कि हम इस समय इसे जीत रहे हैं :)

— झबरा

क्या गैर-ASCII वर्णों को एकाधिक बाइट्स के रूप में नहीं गिना जाता है?

— सूदो

@ सोडो वे सभी चिह्न एकल-बाइट हैं। उदाहरण के लिए, 漢3 बाइट्स होंगे, लेकिन ¨एक बाइट है। ऊपर इस्तेमाल किए गए प्रतीकों को गोल्फ भाषा के लिए बिल्कुल इस कारण से चुना गया है कि वे सभी एक ही बाइट हैं।

— लीख

Answer 8

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

param($a)$b="";($a|%{if($_-ge25){$b+="$_ "}else{$b;$b=""}})+$b|?{(-split$_).count-ge5-and(-split$_|?{$_-ge30}).count-ge3}

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

PowerShell के पास एक .someया एक .everyजैसे के बराबर नहीं है , इसलिए यह हाथ से लुढ़का हुआ है।

हम $aपूर्णांकों की एक सरणी के रूप में इनपुट लेते हैं। $bखाली स्ट्रिंग में सहायक चर सेट करें । फिर, प्रत्येक पूर्णांक के माध्यम से लूप करें $a। लूप के अंदर, यदि पूर्णांक -gअभिकर्मक eयोग्य है 25, तो इसे हमारे संभावित स्ट्रिंग में जोड़ें $b, अन्यथा $bपाइप लाइन पर रख दें और इसे खाली स्ट्रिंग पर सेट करें।

एक बार लूप से बाहर जाने के बाद, सरणी-पाइपलाइन पाइपलाइन के परिणामों को बदल देती है $b, और उन लोगों को एक Where-Objectखंड के माध्यम से डालती है |?{...}। यह उन तारों को बाहर निकालता है जिनकी एक तत्व लंबाई होती है -ge5(व्हॉट्सएप पर विभाजित होने के आधार पर) और 30होने से अधिक गति की गिनती होती है -ge3। उन तारों को पाइप लाइन पर छोड़ दिया जाता है, इसलिए एक सत्य मान गैर-रिक्त होता है (सत्य / असत्य भेद के लिए "सभी परीक्षण मामलों को सत्यापित करें" लिंक देखें)।

Comments

$args इसके बजाय का उपयोग करने की कोशिश करें param($a)और$a

— mazzy

-2 बाइट्स...{$a=-split$_;$a.count-ge5-and($a|?{$_-ge30}).count-ge3}

— माज़ी

सरणियों के साथ 109 बाइट्स। के $args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}-B{,($b=@())}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}रूप में सहेजें get-heatWave.ps1। टेस्ट स्क्रिप्ट regex101.com/r/lXdvIs/2

— mazzy

103 बाइट्स$b=@();$args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}

— माज़ी

क्या करता -Eहै? मैं उससे परिचित नहीं हूं।

— AdmBorkBork

Answer 9

जेली , 17 16 बाइट्स

:5_5Ṡṣ-ḤS«LƊ€Ṁ>4

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

यह काम किस प्रकार करता है

:5_5Ṡṣ-ḤS«LƊ€Ṁ>4  Main link. Argument: T (array of temperatures)

:5                Divide each item of T by 5 (integer division).
  _5              Subtract 5 from each quotient.
    Ṡ             Take the signs.
                  This maps (-oo,25) to -1, [25,30) to 0, and [30,+oo) to 1.
     ṣ-           Split at occurrences of -1.
       Ḥ          Double, replacing 1's with 2's.
           Ɗ€     Map the three links to the left over each chunk.
        S             Take the sum.
          L           Take the length.
         «            Take the minimum of the results.
             Ṁ    Take the maximum.
              >4  Test if it's larger than 4.
                  Note that the sum is larger than 4 if and only if there are more
                 than two 2's, which correspond to temperatures in [30,+oo).

Answer 10

पायथन 2 , 86 बाइट्स

lambda l:any(2<s.count('2')*(len(s)>14)for s in`[(t>24)+(t>29)for t in l]`.split('0'))

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

Answer 11

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

एक बूलियन देता है।

a=>a.some(n=>(n>24?y+=++x&&n>29:x=y=0)>2&x>4,x=y=0)

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

Answer 12

05AB1E , 20 बाइट्स

Œʒ24›DPsO4›*}29›O2›Z

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

व्याख्या

Π                    # push sublists of input
 ʒ          }         # filter, keep the lists where:
           *          # the product of:
     DP               # the product and
       sO4›           # the sum compared using greater-than to 4
  24›                 # for the elements greater than 24
                      # is true
                      # the result is:
                   Z  # the maximum from the remaining lists where
                O     # the sum of 
             29›      # the elements greater than 29
                 2›   # is greater than 2

Answer 13

बैच, 119 बाइट्स

@set h=0
@for %%t in (0 %*)do @if %%t lss 25 (set/as=5,t=3)else set/a"t+=!!t*(29-%%t)>>9,s-=!!s,h+=!(s+t+h)
@echo %h%

कमांड लाइन तर्क के रूप में इनपुट लेता है और एक हीटवेव के लिए आउटपुट 1 अन्यथा 0।

Answer 14

पायथन , 67 बाइट्स

f=lambda l:l>l[:4]and(min(l)>24<sorted(l)[~2]-5)|f(l[1:])|f(l[:-1])

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

घातीय वृद्धि के कारण लंबे समय तक परीक्षण के मामलों पर टाइम्स आउट करें। प्रथम या अंतिम तत्व को बार-बार काटकर सन्निहित उपविदों को ढूँढता है। उस 3 दिन 330 ° C हैं जो तीसरे सबसे बड़े मान को देखते हुए जांचा जाता है sorted(l)[~2]। आधार मामले शायद सत्य / गलत का फायदा उठाकर या त्रुटि के साथ समाप्त होने से कम हो सकते हैं।

Answer 15

जावास्क्रिप्ट (Node.js) , 48 बाइट्स

a=>a.some(x=>x>24?++A>4&(B+=x>29)>2:A=B=0,A=B=0)

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

काफी बुरा है

Answer 16

हास्केल , 64 बाइट्स

f l=or$drop 4l>>[sum[1|x<-l,x>29,all(>24)l]>2,f$tail l,f$init l]

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

Answer 17

एपीएल (डायलॉग यूनिकोड) , 29 बाइट्स

∨/(5≤≢¨a)∧3≤+/30≤↑a←e⊆⍨25≤e←⎕

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

∨/क्या कोई हैं तत्व हैं

(5≤≢¨a)5 < ≢प्रत्येक श्रृंखला में दिनों का मिलान ( aसभी दिनों की संभावित श्रृंखला है)

∧ तथा

3≤+/30≤3 +/elements तत्वों की कुल संख्या जो number 30 में हैं

↑a← द्वारा गठित मैट्रिक्स

e⊆⍨25≤e←⎕ लगातार तत्वों की श्रृंखला जो that 25 है

Comments

आपके पहले परीक्षण में अनावश्यक रूप से टिप्पणी की गई है - यह काम करता है।

— ngn

@ngn को स्पॉट करने के लिए धन्यवाद, निश्चित

— क्रिति लिथोस

Answer 18

Kotlin , 57 बाइट्स

{var r=1;it.any{r*=2;if(it>29)r*=3;if(it<25)r=1;r%864<1}}

(-1 स्पष्ट पैरामीटर की जगह बाइट > वी अंतर्निहित पैरामीटर के साथ यह )

{var r=1;it.any{v->r*=2;if(v>29)r*=3;if(v<25)r=1;r%864<1}}

(-16 बाइट्स किसी भी {} ऑपरेशन का उपयोग करते हुए जैसा कि GB द्वारा रूबी सॉल्यूशन में देखा गया है )

{it.stream().reduce(1){r,v->if(r*25>r*v)1 else(r*if(v<30)2 else 6)%864}<1}

(-1 बाइट धन्यवाद लिन: प्रतिस्थापित r> 0 && v <25 के साथ r * 25> r * v)

{it.stream().reduce(1){r,v->if(r>0&&v<25)1 else(r*if(v<30)2 else 6)%864}<1}

यह लंबोदर अभिव्यक्ति एक सूची लेता है और एक हीटवेव या झूठे अन्य के लिए सच होता है।

मैजिक नंबर 864 और उडो बोरकोव्स्की के लिए धन्यवादउनके विचारों के लिए और मैथिस के लिए ।

कैसे काम करता है? संख्याओं का प्रत्येक क्रम a के साथ पुनरावृत्त होता है कम मान पर शुरू किए गए किसी भी {} ऑपरेशन के 2 से गुणा की जाती है और संख्या 3 या (3 * 3 = 6) से गुणा की जाती है यदि संख्या अधिक या 30 के बराबर है। यदि संख्या <25 यह देखा जाता है कि कमी 1 से फिर से शुरू होती है। यदि घटा 864 = 2 * 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3 से विभाज्य है, तो एक हीटवेव पाया जाता है, और मोडुलो ऑपरेशन का परिणाम 0 होता है, जिसके परिणामस्वरूप होता है किसी भी {} ऑपरेशन से बुलाए गए आंतरिक लैम्ब्डा में एक सच्चा वापसी मूल्य जो तब पुनरावृत्ति को रोकता है और सच का मान लौटाता है।

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

Comments

अच्छी व्याख्या :)

— JayCe

मुझे लगता है कि आपकी बाइट की गिनती पूरे फ़ंक्शन की घोषणा को दर्शाती है, न कि केवल फ़ंक्शन की बॉडी को। जैसा कि अभी है, यह मुझे एक स्निपेट लगता है।

— जोनाथन फ्रीच

@ जोनाथन-फ्रीच, मैंने फ़ंक्शन बॉडी को थोड़ी लंबी लंबोदर अभिव्यक्ति में बदल दिया, जिसमें ब्रेसिज़ भी शामिल हैं जो कि वे जावा में वैकल्पिक नहीं हैं। क्या यह उचित है?

— रोलैंड शमित्ज़

@ रोलैंडस्चिट्ज़ अन्य कोटलिन सबमिशन और जावा लैम्डा फंक्शन सबमिशन को देखते हुए, मुझे लगता है कि फंक्शन डिक्लेरेशन बाइट काउंट को स्वीकार नहीं किया गया है; इसका अर्थ है कि आपका मूल सबमिशन सबसे अधिक मान्य है। मेरी टिप्पणी के लिए क्षमा करें, यह मुझे अजीब लगा, क्योंकि मुझे लगता है कि यह बहुत ही स्निपेट-एसके दिखता है, क्योंकि यह बिना किसी प्रकार की घोषणा के एक मान्य भाषा निर्माण नहीं है।

— जोनाथन फ्रीच

Answer 19

आश्चर्य है , 34 बाइट्स

(/>@(& <2!> '<29#0)*> '<24#0).cns5

उपयोग उदाहरण:

((/>@(& <2!> '<29#0)*> '<24#0).cns5) [25 33 33 25 24 27 34 31 29 31 27 23]

व्याख्या

वर्बोज़ संस्करण:

(some x\\(and <2 (fltr <29) x) (every <24) x) . (cns 5)

लगातार 5 आइटमों के ओवरलैपिंग दृश्यों को लें, फिर देखें कि किसी भी अनुक्रम में सभी आइटम> 25 और 2 से अधिक आइटम> 30 तो नहीं हैं।

Comments

अरे, यह असंबंधित है, लेकिन आपकी वेबसाइट पर फेसबुक लिंक मृत है।

— mbomb007

Answer 20

जेली , 21 बाइट्स

L5r⁸ṡẎ<25Ẹ$Ðḟ29<S€2<Ẹ

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

Answer 21

स्टैक्स , 23 बाइट्स

Æ7)║▄░Ä╟═╙hⁿ╧\ßY8÷K▌µ½x

भागो और इसे staxlang.xyz पर डीबग करें!इसे चलाने में लंबा समय लगता है, इसलिए मैंने ऑटो-रन को अक्षम कर दिया।

अनपैक्ड (28 बाइट्स) और स्पष्टीकरण

:efc%4>nc{24>f=a{29>f%2>|&|&
:e                              Set of all contiguous subarrays
  f                             Filter, using the rest of the program as a predicate:
   c                              Copy subarray on the stack
    %4>                           Five or more elements?
                        |&        AND
       nc                         Copy subarray twice to top
         {   f                    Filter:
          24>                       Greater than 24?
              =                   Equals the original subarray?
                          |&      AND
               a                  Move subarray to top
                {   f             Filter:
                 29>                Greater than 30?
                     %2>          Length greater than two?
                                  Implicit print if all three conditions are met

यह गर्मी के तरंगों के रूप में गिना जा सकने वाली सभी उपग्रहों को प्रिंट करेगा, जो कि केवल और केवल मौजूद नहीं होने पर मिथ्या होगी।

Answer 22

रूबी , 89 बाइट्स

->a{(0..a.size).map{|i|(b=a[i..-1].take_while{|t|t>24}).size>4&&b.count{|t|t>29}>2}.any?}

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

Comments

मेरा मानना ​​है कि यह विफल हो जाता है क्योंकि दूसरे सत्य मामले में, पांच दिनों के भीतर +30 दिन नहीं हैं।

— स्टीवी ग्रिफिन

बहुत अच्छा। आप एक each_consदृष्टिकोण के साथ कुछ बाइट्स दाढ़ी कर सकते हैं - इसे ऑनलाइन आज़माएं!

— बेंज़ 2240

Answer 23

हस्क , 19 बाइट्स

Vo≥3#≥30fo≥5Lġ(±≥25

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

फ़िल्टर का उपयोग करना ( f) तार्किक और ( &) के साथ जाँच के उपयोग से एक बाइट कम है , यह भी छुटकारा पाने के लिए वास्तव में अच्छा होगा± - लागत 2 बाइट्स :(

व्याख्या

V(≥3#≥30)f(≥5L)ġ(±≥25)  -- example input: [12,25,26,27,28,29,18,24,32]
               ġ(    )  -- group by
                ( ≥25)  -- | greater or equal to 25: [0,1,2,3,4,5,6,0,0,8]
                (±   )  -- | sign: [0,1,1,1,1,1,1,0,0,1]
                        -- : [[12],[25,26,27,28,29,30],[18,24],[32]]
         f(   )         -- filter by
          (  L)         -- | length: [1,6,2,1]
          (≥5 )         -- | greater or equal to 5: [0,2,0,0]
                        -- : [[25,26,27,28,29,30]]
V(      )               -- does any element satisfy
 (  #   )               -- | count occurences where
 (   ≥30)               -- | | elements greater or equal to 30
 (      )               -- | : [1]
 (≥3    )               -- | greater or equal to 3: [0]
                        -- : 0

Answer 24

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

G4`_+
/\b_{1,24}\b/%)C2`_{30}
1

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

Answer 25

आर , 111 93 71 67 66 बाइट्स

!Reduce(function(i,j)"if"(j<25,!!i,(i*(2+4*!j<30))%%864),scan(),1)

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

रोलांड शमित्ज़ के जवाब का बेशर्म बंदरगाह । -4 बाइट्स रोलैंड के लिए और -1 ग्यूसेप के लिए धन्यवाद।

कार्यात्मक संस्करण के लिए TIO लिंक।

पिछले संस्करण में लगातार दिन निकाले गए> 25 का उपयोग कर rleऔर Giuseppe की बदौलत 18 बाइट्स बचाए!

Comments

यदि आप Fइसके बजाय का उपयोग करते हैं T, तो आप कर सकते हैं F=F|"if"(cond,(expr),0)और फिर F6-ish बाइट्स को बचाने के लिए वापस जाएँ । आपके पास चारों ओर कोष्ठक की एक अनावश्यक जोड़ी है, (1-z[i]):0लेकिन मुझे लगता है कि 1-z[i]:1किसी अन्य युगल बाइट को बचाने के लिए बस वैसे भी हो सकता है ...

— Giuseppe

^ मैं उपरोक्त टिप्पणी प्रस्तुत करने वाला था जब मुझे एक और विचार आया, और मैं एक उप -100 बाइट समाधान खोजने में कामयाब रहा! function(x,z=rle(x>24)$l){for(i in 1:sum(z|1))F=F|z[i]>4&sum(x[sum(z[1:i])+1-z[i]:1]>29)>2;F}लेकिन यह पीपीसीजी से टीआईओ में चिपकाने से सावधान रहना चाहिए क्योंकि कभी-कभी इसमें अप्रतिबंधित रेंगना ...

— Giuseppe

यह शानदार है! जोनाथन एलन के गणित का लाभ उठाने का एक और भी छोटा तरीका है ...

— JayCe

अच्छा, आप कुछ और बाइट्स भी बचा सकते हैं, यदि आप (i * 2 * (1+ (2 * (j> 29))) से आंतरिक भाग को सरल बनाते हैं) (i * (2 + 4 * (j> 29) ))

— रोलैंड शमित्ज़

@RolandSchmitz बहुत सच!

— जेसी

Answer 26

स्विफ्ट 4 , 50 बाइट्स

{$0.reduce(1){$0>0&&$1<25 ?1:$0*($1<30 ?2:6)%864}}

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

क्लोजर एक्सप्रेशन 0 एक हीटवेव या> 0 के लिए लौटाता है।

रोलांड शमित्ज़ और मैथिस के सहयोग से बनाया गया ।

कैसे काम करता है? संख्याओं के प्रत्येक अनुक्रम को कम मान पर शुरू किए गए एक कम ऑपरेशन के साथ पुनरावृत्त किया जाता है। यदि एक संख्या> = 25 को कम देखा जाता है तो 2. से गुणा किया जाता है। यदि संख्या> = 30 को देखा जाए तो कमी 2 से गुणा होकर 3 = होती है। 6. यदि कोई संख्या <25 देखी जाती है, तो कमी फिर से शुरू होती है। 1. यदि कमी 864 = 2 * 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3 से विभाज्य है, तो एक हीटवेव मिल जाता है, और परिणाम modulo ऑपरेशन 0 है जिसका परिणाम 0. के घटते मूल्य में होता है। केवल एक हीट वेव पाए जाने पर कम हो सकता है 0. एक बार जब कम मूल्य 0 हो जाता है तो यह भविष्य के सभी कटौती के लिए 0 होगा, अर्थात अंतिम परिणाम के लिए भी।

Answer 27

पायथन 2 , 66 63 बाइट्स

lambda a:reduce(lambda b,c:(b*(6,2)[c<30]%864,1)[b*25>b*c],a,1)

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

-3 बाइट्स लिन का धन्यवाद

कैसे काम करता है? संख्याओं के प्रत्येक अनुक्रम को कम मान पर शुरू किए गए एक कम ऑपरेशन के साथ पुनरावृत्त किया जाता है। यदि एक संख्या> = 25 को कम देखा जाता है तो 2. से गुणा किया जाता है। यदि संख्या> = 30 को देखा जाए तो कमी 2 से गुणा होकर 3 = होती है। 6. यदि कोई संख्या <25 देखी जाती है, तो कमी फिर से शुरू होती है। 1. यदि कमी 864 = 2 * 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3 से विभाज्य है, तो एक हीटवेव मिल जाता है, और परिणाम modulo ऑपरेशन 0 है जिसका परिणाम 0. के घटते मूल्य में होता है। केवल एक हीट वेव पाए जाने पर कम हो सकता है 0. एक बार जब कम मूल्य 0 हो जाता है तो यह भविष्य के सभी कटौती के लिए 0 होगा, अर्थात अंतिम परिणाम के लिए भी।

अधिक पठनीय, लेकिन लंबा संस्करण इस तरह दिखता है:

lambda a:reduce((lambda b,c: 1 if b>0 and c<25 else b*(2 if c<30 else 6)%864), a, 1)

अतिरिक्त रिक्त स्थान / कोष्ठक को हटाने और x if cond else yद्वारा प्रतिस्थापित (y,x)[cond]करता है

lambda a:reduce(lambda b,c:(b*(6,2)[c<30]%864,1)[b>0and c<25],a,1)

लिन ने शर्त को छोटा करने का सुझाव दिया b>0and c<25:

b>0and c<25-> b*25>0 and b*c<b*25-> b*25>0 and b*25>b*c->b*25>b*c

जिसके परिणामस्वरूप

lambda a:reduce(lambda b,c:(b*(6,2)[c<30]%864,1)[b*25>b*c],a,1)

Comments

आपको आयात विवरण भी शामिल करना होगा :)

— मुहम्मद सलमान

आपको वास्तव में आयात को कम करने की आवश्यकता नहीं है functools, यह पायथन 2 में निर्मित है !

— लिन

आप देख सकते हैं कि क्या है b*25>b*cऔर 3 बाइट्स बचाएं; यह विभिन्न भाषाओं में इस दृष्टिकोण को लेने वाले कई समाधानों पर लागू हो सकता है :)

— लिन

@ बहुत धन्यवाद। मैंने तदनुसार समाधान अपडेट किया।

— उडो बोर्कोव्स्की

Answer 28

पायथ, 23 बाइट्स

f&glT5&>T]25gePPT30SM.:

इसे यहाँ आज़माएँ

f&glT5&>T]25gePPT30SM.:
f                  SM.:Q   Get the sorted subsequences of the (implicit) input...
 &qlT5                     ... with at least 5 elements...
      &>T]25               ... all at least 25...
            gePPT30        ... where the third to last is at least 30.

Answer 29

Befunge-98 , 61 बाइट्स

]&:46*`#;_$$$v\+1\;
 +1\_;#`+fe;#<\v
^_v#!`4:\_;#`2:<;\
>0>.@

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

Answer 30

पर्ल 6 , 54 52 बाइट्स

{$_>5&.grep(*>29)>2}o{any kv classify $+=25>*,0,|$_}

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

Comments

मुझे इस कोड का स्पष्टीकरण पढ़ना अच्छा लगेगा!

— लिन