48

# バックグラウンド

オランダ王立気象研究所は、熱波の定義のシリーズとして*を少なくとも 5 個の連続 ≥25℃の天気（「夏の天気」）は、そのようなことの日の少なくとも当時の3がある≥30°C（「熱帯天気」 ）。

*（まあ、オランダの基準による。）

# チャレンジ

バイト単位の最短回答が優先されます。

# テストケース

``````[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]
``````

``````[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]
``````

2

FryAmTheEggman

3
@FryAmTheEggmanそうですね、オランダでは、はい:)、しかしあなたの答えがこの事実を悪用したくないので、いいえ。
リン

1
@HatWizardはい、大丈夫です。たとえば、「クラッシュ/クラッシュしない」も問題ありません。
リン

2
ちょっと@Lynnこれは大きな挑戦であり、今でもそうです:
ローランドシュミッツ

1
@RolandSchmitzありがとう！チャレンジの生涯の後半に出てきた創造的な答えに私は喜んで驚いています。🎉
リン・

19

# ゼリー、15 バイト

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

`1`熱波が他で検出されたなら戻る数のリストを受け入れるモナドリンク`0`

オンラインでお試しください！またはテストスイートを参照してください。

### どうやって？

5で割ると、基準は5以上の4つを超える値の実行の存在になり、そのうち2つ以上が6以上でなければなりません。

これらの値から5を引くと、基準はゼロ以上の4つ以上の値の実行の存在となり、そのうち2つ以上は1以上でなければなりません。

これらの値の符号を取得すると（-1、0、または1を取得）、基準は-1に等しくない4つを超える値の実行の存在となり、そのうち2つ以上は1に等しくなければなりません。

これらの値に1を追加すると（0、1、または2を取得）、基準はゼロではない4つ以上の値の実行の存在になり、2つ以上は2に等しくなければなりません。

ゼロを含むリストの積はゼロであり、2を超える2（および残りは1）を含むリストの積は4を超えます。これは、この調整済みリストの基準が、製品の最小値と長さが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
P        -   product
L      -   length
«       -   minimum
>4  - greater than four? (vectorises) -- 1 if so, else 0
Ṁ - maximum -- 1 if any are 1, else 0
``````

9

# C（clang）、64バイト

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

マジックナンバー864と、アイデアを提供してくれたUdo BorkowskiとMathisに感謝します。

どのように機能しますか？数値の各シーケンスは、reduce値1から始まるreduce操作で繰り返されます。25以上の数値が見られる場合、reduceは2倍されます。30以上の数値が見られる場合、reduceは2倍され、3 = 6. 25未満の数値が見られる場合、リデュースは1から再開します。リデュースが864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3で割り切れる場合、熱波が見つかり、その結果がモジュロ演算は0で、reduce値が0になり、戻り値がtrueになります。

オンラインでお試しください！

PPCGへようこそ。
ムハンマドサルマン

PPCGへようこそ！テストケーススイートで完了した非常に素晴らしい最初の答え！私たちが魔法を理解できるように説明を追加していただけますか？
JayCe

それは本当にエレガントなソリューションで、よくやった:)
リン

7

# APL（Dyalog Classic）、21 20バイト

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

オンラインでお試しください！

`25 30⍸x` x <25の場合は0、25≤x <30の場合は1、それ以外の場合は2

すべての可能な場所から開始する（または同等に終了する）これらの累積積を計算し、最初の4つの製品を破棄し、8以上（2 3）の製品の存在を検出します

6

# Japt、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
3§      // has at least three items
Zè¨30 // with a value of at least 30.``````

コメントですべての議論が正しく行われたと思います。Shaggyの
おかげで1バイト削られました

オンラインでお試しください！

シャギー

@Shaggy私もそう思いましたが、短いバージョンも見つかりませんでした。ポインターに感謝します！
NIT

1

シャギー

sudo

1
@sudoこれらのシンボルはすべてシングルバイトです。たとえば、`漢`3バイトですが`¨`、1バイトです。上記で使用されている記号は、すべて1バイトであるという理由で、ゴルフ言語用に選択されています。
Nit

5

# PowerShell、121バイト

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

PowerShellは相当持っていない`.some``.every`など、またはので、これを手で巻かれています。

ループの外に出たら、パイプラインの結果をで配列連結し、`\$b`それらを`Where-Object`節に入れ`|?{...}`ます これにより、要素の長さが`-ge5`（空白での分割に基づいて）あり、tempの数がを超える文字列が取り出さ`30``-ge3`ます。これらの文字列はパイプラインに残っているため、真偽値は空ではありません（真偽の区別については、「すべてのテストケースの検証」リンクを参照してください）。

mazzy

-2バイト`...{\$a=-split\$_;\$a.count-ge5-and(\$a|?{\$_-ge30}).count-ge3}`
mazzy

mazzy

103バイト`\$b=@();\$args|%{if(\$_-ge25){\$b+=\$_}else{,\$b;\$b=@()}}-E{,\$b}|?{\$_.count-ge5-and(\$_|?{\$_-ge30}).count-ge3}`
mazzy

5

# ゼリー、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).
``````

4

# 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
``````

4

## バッチ、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%
``````

4

# Python、67バイト

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

オンラインでお試しください！

4

# APL（Dyalog Unicode）、29バイト

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

オンラインでお試しください！

`∨/`何かありますかな要素

`(5≤≢¨a)`5 < `≢`各シリーズの日数の集計（`a`すべての可能な日数のシリーズがあります）

`∧` そして

`3≤+/30≤` 3≤合計 `+/`3≤30インチ以上の要素

`↑a←` によって形成された行列

`e⊆⍨25≤e←⎕` 25以上の連続した要素のシリーズ

-ngn

@ngnそれを発見してくれてありがとう、修正
Kritixi Lithos

4

# Kotlin、57バイト

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

（-1バイトは、明示的なパラメーターv->を暗黙的なパラメーターitに置き換え

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

GBによるRubyソリューションで見られるように、any {}操作を使用して-16バイト）

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

（Lynnに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}
``````

このラムダ式はリストを受け取り、熱波の場合はtrueを返し、そうでない場合はfalseを返します。

マジックナンバー864と、アイデアを提供してくれたUdo BorkowskiとMathisに感謝します。

どうすれば動作しますか？数値の各シーケンスは、reduce値1から始まるany {}演算で繰り返されます。reduce は2倍され、30以上の場合は3倍されます（2 * 3 = 6）。リデュースが再び1から始まることがわかります。リデュースが864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3で割り切れる場合、熱波が見つかり、モジュロ演算の結果は0になります。any {}から呼び出される内部ラムダの真の戻り値操作反復を停止し、真の値を返します。

オンラインでお試しください！

いい説明:)
JayCe

バイトカウントは、関数の本体だけでなく、関数宣言全体を反映する必要があると思います。今のところ、スニペットのように思えます。
ジョナサンフレッチ

@ jonathan-frech、関数本体を、Javaのようにオプションではない中括弧を含む、わずかに長いラムダ式に変更しました。これは公平ですか？
ローランドシュミッツ

@RolandSchmitz他のKotlinのサブミッションとJavaラムダ関数のサブミッションを見ると、関数宣言のバイトカウントは含まれていません。つまり、元の送信が有効である可能性が最も高いことを意味します。私のコメントで申し訳ありませんが、型宣言のない有効な言語構成体ではないため、非常にスニペット-eskに見えるため、奇妙に思えました。
ジョナサンフレッチ

3

# ワンダー、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を超え、30を超える2アイテムを超えるかどうかを確認します。

mbomb007

3

# スタックス、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
``````

これは、熱波としてカウントできるすべてのサブアレイを出力します。サブアレイは、存在しない場合にのみ偽造されます。

3

# ルビー、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?}``

オンラインでお試しください！

2番目の真実のケースでは、+ 30日がすべて5日以内ではないため、失敗すると考えています。
スティーヴィーグリフィン

benj2240

3

# 殻、19バイト

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

オンラインでお試しください！

フィルター（`f`）を使用すると、論理および（`&`を使用してチェックするよりも1バイト短くなります。また、`±` - 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
``````

3

# R、111 93 71 67 66バイト

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

オンラインでお試しください！

ローランド シュミッツの 恥知らずなポート回答。ローランドのおかげで4バイト、ジュゼッペのおかげで-1バイト。

TIOは機能バージョンにリンクしています。

`rle`ジュゼッペのおかげで、以前のバージョンは25日以上連続して抽出され、なんと18バイトを節約しました！

`F`代わりにを使用すると`T`、6バイトのバイトを節約するために実行`F=F|"if"(cond,(expr),0)`してから戻ることができ`F`ます。また、周りの括弧の不要なペアを持っている`(1-z[i]):0`が、私はそれはちょうどかもしれないと思う`1-z[i]:1`...別のカップルのバイトを保存するために、とにかく
ジュゼッペ

^別のアイデアが思い浮かんだとき、私は上記のコメントを提出しようとしていたが、なんとか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}`が、中に時々 unprintablesクリープ...ので、TIOにPPCGから貼り付けるように注意してください
ジュゼッペ・

これは素晴らしいです！おそらくジョナサンアランの数学を活用するさらに短い方法があります...
JayCe

ニース、（i * 2 *（1+（2 *（j> 29））））から（i *（2 + 4 *（j> 29））の内部を単純化すると、さらにバイトを節約できます））
ローランドシュミッツ

@RolandSchmitz非常に本当です！
JayCe

3

# Swift 4、50バイト

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

オンラインでお試しください！

クロージャー式は、熱波の場合は0を返し、その他の場合は> 0を返します。

ローランド・シュミッツおよびマティスと共同で作成。

どのように機能しますか？数値の各シーケンスは、reduce値1から始まるreduce操作で繰り返されます。25以上の数値が見られる場合、reduceは2倍されます。30以上の数値が見られる場合、reduceは2倍され、3 = 6. 25未満の数値が表示された場合、リデュースは1から再開します。リデュースが864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3で割り切れる場合、熱波が見つかり、その結果がモジュロ演算は0であり、結果として0のリデュース値になります。熱波が見つかった場合のみ、リデュースは0になります。

3

# パイソン2、66の 63バイト

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

オンラインでお試しください！

Lynnのおかげで-3バイト

どのように機能しますか？数値の各シーケンスは、reduce値1から始まるreduce操作で繰り返されます。25以上の数値が見られる場合、reduceは2倍されます。30以上の数値が見られる場合、reduceは2倍され、3 = 6. 25未満の数値が表示された場合、リデュースは1から再開します。リデュースが864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3で割り切れる場合、熱波が見つかり、その結果がモジュロ演算は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)``

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

Lynnは条件を短くすることを提案しました`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)``

インポートステートメントも含める必要があります:)
ムハンマドサルマン

1

リン

1
`b*25>b*c`3バイトかどうかを確認して保存できます。これは、異なる言語で、このアプローチを取るソリューションの多くに適用される場合があります:)
リン・

@Lynnどうもありがとう。それに応じてソリューションを更新しました。
ウドボルコフスキ

2

# Pyth、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.
``````