Rileva ondate di calore

48

sfondo

Il Royal Netherlands Meteorological Institute definisce un'ondata di calore * come una serie di almeno 5 giorni consecutivi di tempo ≥25 ° C ("tempo estivo"), in modo che almeno 3 di quei giorni siano ≥30 ° C ("tempo tropicale" ).

Il clima tropicale non deve essere misurato consecutivamente: ad esempio: 30, 25, 30, 26, 27, 28, 32, 30è un'ondata di calore di 8 giorni con 4 giorni di clima tropicale.

* (Beh, per gli standard olandesi.)

Sfida

Dato un elenco non vuoto di numeri interi positivi che rappresentano le misurazioni della temperatura in gradi Celsius di giorni successivi, decidere se tale elenco contiene un'ondata di calore (secondo la definizione sopra).

Vince la risposta più breve in byte.

Casi test

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]
code-golf  math  array-manipulation  decision-problem 
— Lynn
fonte
2
La temperatura è garantita essere inferiore a 100 gradi Celsius?
— FryAmTheEggman,
3
@FryAmTheEggman Beh, nei Paesi Bassi, sì :), ma non voglio che la tua risposta offenda questo fatto, quindi no.
— Lynn,
1
@HatWizard Sì, va bene. Anche "Crash / Don't crash" va bene, per esempio.
— Lynn,
2
Hey @Lynn questa è stata una grande sfida ed è ancora :-)
— Roland Schmitz,
1
@RolandSchmitz Grazie! Sono felicemente sorpreso dalle risposte creative che ne sono uscite così tardi nella vita della sfida. 🎉
— Lynn,

Risposte:

19

Gelatina , 15 byte

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

Un collegamento monadico che accetta un elenco di numeri che ritorna 1se viene rilevata un'ondata di calore in altro modo 0.

Provalo online! o vedi la suite di test .

Come?

Il criterio è l'esistenza di una serie di più di quattro valori maggiori o uguali a 25, di cui più di due devono essere maggiori o uguali a 30.

Se dividiamo per cinque, i criteri diventano l'esistenza di una serie di più di quattro valori maggiori o uguali a cinque, di cui più di due devono essere maggiori o uguali a sei.

Se sottraggiamo cinque da questi valori, i criteri diventano l'esistenza di una serie di più di quattro valori maggiori o uguali a zero, di cui più di due devono essere maggiori o uguali a uno.

Se prendiamo il segno di questi valori (ottenendo -1, 0 o 1) i criteri diventano l'esistenza di una serie di più di quattro valori non uguali a -1, di cui più di due devono essere uguali a uno.

Se ne aggiungiamo uno a questi valori (ottenendo 0, 1 o 2) i criteri diventano l'esistenza di una serie di più di quattro valori non uguali a zero, di cui più di due devono essere uguali a due.

Il prodotto di un elenco contenente uno zero è zero e il prodotto di un elenco contenente più di due (e il resto sono quelli) è più di quattro. Ciò significa che i criteri in questo elenco adattato diventano che il minimo del prodotto e la lunghezza è maggiore di 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
— Jonathan Allan
fonte
9

Haskell , 73 72 71 69 67 66 byte

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

Grazie a @flawr e @Laikoni per due byte ciascuno e @xnor per un byte!

Provalo online!

Uguale lunghezza:

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

Provalo online!

— Angs
fonte
9

C (clang) , 64 byte

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

La funzione o () restituisce 1 per un'onda di calore o 0 altro.

Grazie al numero magico 864 ea Udo Borkowski e Mathis per le loro idee.

Come funziona se funziona? Ogni sequenza di numeri viene ripetuta con un'operazione di riduzione a partire dal valore di riduzione 1. Se viene visualizzato un numero> = 25, la riduzione viene moltiplicata per 2. Se viene visualizzato un numero> = 30, la riduzione viene moltiplicata per 2 e per 3 = 6. Se viene visualizzato un numero <25, la riduzione ricomincia da 1. Se la riduzione è divisibile per 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, viene rilevata un'ondata di calore e il risultato del operazione modulo è 0 che risulta in un valore ridotto di 0 e in un valore restituito di vero.

Provalo online!

— Roland Schmitz
fonte
Benvenuti in PPCG.
— Muhammad Salman,
Benvenuti in PPCG! Molto bella la prima risposta completa della suite di test case! Potresti aggiungere una spiegazione in modo da capire la magia?
— JayCe,
È una soluzione davvero elegante, ben fatta :)
— Lynn,
7

APL (Dyalog Classic) , 21 20 byte

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

Provalo online!

usi ⎕io←1

25 30⍸x è 0 se x <25, 1 se 25≤x <30 o 2 altrimenti

calcoliamo i prodotti cumulativi di questi a partire da (o equivalentemente: terminando a) tutte le posizioni possibili, scartiamo i primi 4 prodotti e rileviamo la presenza di prodotti ≥8 (che è 2 3 )

— NGN
fonte
6

Japt , 19 18 byte

ô<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.

Spero di aver ricevuto correttamente tutte le discussioni nei commenti.
Rasato di un byte grazie a Shaggy .

Provalo online!

— lendine
fonte
Pensavo che questo avrebbe funzionato in modo più breve durante la lettura ma riuscivo a gestire solo 18 byte .
— Shaggy,
@Shaggy L'ho pensato anch'io, ma non sono riuscito a trovare nemmeno una versione più breve. Grazie mille per il puntatore!
— Nit
1
Sembra che al momento stiamo vincendo questo :)
— Shaggy,
I caratteri non ASCII non contano come byte multipli?
— sudo,
1
@sudo Quei simboli sono tutti a byte singolo. Ad esempio, 漢sarebbe 3 byte, ma ¨è un byte. I simboli usati sopra sono stati scelti per la lingua del golf proprio perché sono tutti un singolo byte.
— Nit
5

PowerShell , 121 byte

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

Provalo online! oppure Verifica tutti i casi di test

PowerShell non ha l'equivalente di .someao .everyo simili, quindi questo viene lanciato a mano.

Prendiamo l'input $acome una matrice di numeri interi. Imposta la variabile helper $bsulla stringa vuota. Quindi, scorrere tutti i numeri interi in $a. All'interno del ciclo, se l'intero è più -gadatto ea 25, aggiungilo alla nostra potenziale stringa $b, altrimenti mettilo $bsulla pipeline e impostalo sulla stringa vuota.

Una volta fuori dal ciclo, concatenare i risultati della pipeline con array $be inserirli in una Where-Objectclausola |?{...}. Questo estrae quelle stringhe che hanno una lunghezza dell'elemento di -ge5(basata sulla divisione in spazi bianchi) e un conteggio delle temp maggiori 30dell'essere -ge3. Quelle stringhe vengono lasciate sulla pipeline, quindi un valore di verità non è vuoto (vedere il collegamento "verifica tutti i casi di prova" per la distinzione di verità / falsità).

— AdmBorkBork
fonte
prova a usare $args invece param($a)e$a
— mazzy
-2 byte...{$a=-split$_;$a.count-ge5-and($a|?{$_-ge30}).count-ge3}
— mazzy
109 byte con array. salva $args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}-B{,($b=@())}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}come get-heatWave.ps1. Test script regex101.com/r/lXdvIs/2
— mazzy
103 byte$b=@();$args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}
— mazzy
Cosa fa -E? Non ne ho familiarità.
— AdmBorkBork,
5

Gelatina , 17 16 byte

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

Provalo online!

Come funziona

: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).
— Dennis
fonte
4

JavaScript (ES6), 63 51 byte

Restituisce un valore booleano.

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

Provalo online!

— Arnauld
fonte
4

05AB1E , 20 byte

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

Provalo online!

Spiegazione

Π                    # 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
— Emigna
fonte
4

Lotto, 119 byte

@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%

Accetta input come argomenti della riga di comando e output 1 per un'onda di calore, altrimenti 0.

— Neil
fonte
4

Python , 67 byte

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

Provalo online!

Timeout sui casi di test più lunghi a causa della crescita esponenziale. Trova le liste secondarie contigue tagliando ripetutamente il primo o l'ultimo elemento. Che i 3 giorni siano ≥30 ° C viene verificato osservando il terzo valore più grande sorted(l)[~2]. I casi di base potrebbero forse essere più brevi sfruttando la verità / falsità o terminando con errori.

— XNOR
fonte
4

APL (Dyalog Unicode) , 29 byte

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

Provalo online!

∨/vi sono eventuali elementi tali che

(5≤≢¨a)5 <il conteggio ≢dei giorni in ogni serie ( aha tutte le possibili serie di giorni)

∧ e

3≤+/30≤3 ≤ il +/numero totale di elementi ≥ 30 pollici

↑a← la matrice formata da

e⊆⍨25≤e←⎕ la serie di elementi consecutivi che sono ≥ 25

— Kritixi Lithos
fonte
Il tuo primo test viene commentato inutilmente - funziona.
— ngn,
@ngn Grazie per averlo individuato, risolto
— Kritixi Lithos
4

Kotlin , 57 byte

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

(-1 byte sostituendo il parametro esplicito v-> con il parametro implicito esso )

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

(-16 byte usando qualsiasi operazione {} vista nella soluzione Ruby da GB )

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

(-1 byte grazie Lynn: sostituito r> 0 && v <25 con 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}

Questa espressione lambda prende un elenco e restituisce true per un'ondata di calore o false.

Grazie al numero magico 864 ea Udo Borkowski e Mathis per le loro idee.

Come funziona se funziona? Ogni sequenza di numeri viene ripetuta con qualsiasi operazione {} a partire dal valore di riduzione 1. La riduzione viene moltiplicata per 2 e moltiplicata per 3 (2 * 3 = 6) se il numero è maggiore o uguale a 30. Se un numero <25 si vede che la riduzione ricomincia da 1. Se la riduzione è divisibile per 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, viene rilevata un'ondata di calore e il risultato dell'operazione modulo è 0 che risulta in un valore di ritorno vero nella lambda interna chiamato dall'operazione any {} che quindi interrompe l'iterazione e restituisce il valore di vero.

Provalo online!

— Roland Schmitz
fonte
Bella spiegazione :)
— JayCe
Penso che il conteggio dei byte dovrebbe riflettere l'intera dichiarazione della funzione, non solo il corpo della funzione. Come è adesso, mi sembra uno snippet.
— Jonathan Frech,
@Jonathan-Frech, ho cambiato il corpo della funzione in un'espressione lambda leggermente più lunga, inclusi i controventi che non sono opzionali come in Java. È giusto?
— Roland Schmitz,
@RolandSchmitz Guardando altri invii di Kotlin e invii di funzioni lambda Java, credo che non sia stato accettato il conteggio dei byte della dichiarazione di funzione; ciò significa che il tuo invio originale è molto probabilmente valido. Ci scusiamo per il mio commento, mi è sembrato strano perché trovo che sia molto snippet-esk, dal momento che non è un costrutto di linguaggio valido senza la dichiarazione del tipo.
— Jonathan Frech,
3

Meraviglia , 34 byte

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

Esempio di utilizzo:

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

Spiegazione

Versione dettagliata:

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

Prendi sequenze sovrapposte di 5 elementi consecutivi, quindi controlla se una delle sequenze ha tutti gli elementi> 25 e più di 2 elementi> 30.

— Mama Fun Roll
fonte
Ehi, questo non è correlato, ma il link di Facebook sul tuo sito Web è morto.
— mbomb007,
3

Stax , 23 byte

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

Eseguilo e esegui il debug su staxlang.xyz! L'esecuzione richiede molto tempo, quindi ho disabilitato l'esecuzione automatica.

Spacchettato (28 byte) e spiegazione

: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

Questo stamperà tutti i subarrays che possono essere contati come ondate di calore, che saranno falsi se e solo se non ne esistono.

— Khuldraeseth na'Barya
fonte
3

Buccia , 19 byte

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

Provalo online!

L'uso di filter ( f) è più corto di un byte rispetto all'utilizzo del controllo con un logico e ( &) , inoltre sarebbe davvero bello sbarazzarsi di ±- costando 2 byte :(

Spiegazione

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
— ბიმო
fonte
3

R , 111 93 71 67 66 byte

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

Provalo online!

Porto spudorato delle risposte di Roland Schmitz . -4 byte grazie a Roland e -1 grazie a Giuseppe.

TIO si collega alla versione funzionale.

La versione precedente ha estratto giorni consecutivi> 25 usando rlee salvato ben 18 byte grazie a Giuseppe!

— Jayce
fonte
se lo usi Finvece di T, puoi farlo F=F|"if"(cond,(expr),0)e poi tornare Fper salvare 6 byte ish. Hai anche un paio di parentesi non necessarie (1-z[i]):0ma penso che potrebbe essere 1-z[i]:1comunque un modo per salvare un altro paio di byte ...
— Giuseppe,
^ Stavo per inviare il commento sopra quando mi è venuta in mente un'altra idea e sono riuscito a trovare una soluzione sotto i 100 byte! Non 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}devi fare altro che incollare da PPCG a TIO perché a volte si insinuano degli stampabili ...
— Giuseppe,
È fantastico! C'è probabilmente un modo ancora più breve di sfruttare la matematica di Jonathan Allan ...
— JayCe
Bene, potresti anche salvare qualche altro byte, se semplifichi la parte interna da (i * 2 * (1+ (2 * (j> 29)))) a (i * (2 + 4 * (j> 29) ))
— Roland Schmitz,
@RolandSchmitz molto vero!
— JayCe
3

Swift 4 , 50 byte

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

Provalo online!

L'espressione di chiusura restituisce 0 per un'ondata di calore o> 0 altro.

Creato in collaborazione con Roland Schmitz e Mathis.

Come funziona se funziona? Ogni sequenza di numeri viene ripetuta con un'operazione di riduzione a partire dal valore di riduzione 1. Se viene visualizzato un numero> = 25, la riduzione viene moltiplicata per 2. Se viene visualizzato un numero> = 30, la riduzione viene moltiplicata per 2 e per 3 = 6. Se viene visualizzato un numero <25, la riduzione ricomincia da 1. Se la riduzione è divisibile per 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, viene rilevata un'ondata di calore e il risultato del il funzionamento del modulo è 0, il che si traduce in un valore di riduzione di 0. Solo quando viene rilevata un'ondata di calore, la riduzione può diventare 0. Una volta che il valore di riduzione è 0, sarà 0 per tutte le riduzioni future, ovvero anche per il risultato finale.

— Udo Borkowski
fonte
3

Python 2 , 66 63 byte

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

Provalo online!

-3 byte grazie a Lynn

Come funziona se funziona? Ogni sequenza di numeri viene ripetuta con un'operazione di riduzione a partire dal valore di riduzione 1. Se viene visualizzato un numero> = 25, la riduzione viene moltiplicata per 2. Se viene visualizzato un numero> = 30, la riduzione viene moltiplicata per 2 e per 3 = 6. Se viene visualizzato un numero <25, la riduzione ricomincia da 1. Se la riduzione è divisibile per 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, viene rilevata un'ondata di calore e il risultato del il funzionamento del modulo è 0, il che si traduce in un valore di riduzione di 0. Solo quando viene rilevata un'ondata di calore, la riduzione può diventare 0. Una volta che il valore di riduzione è 0, sarà 0 per tutte le riduzioni future, ovvero anche per il risultato finale.

Una versione più leggibile, ma più lunga si presenta così:

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

Rimozione di spazi / parentesi extra e sostituzione x if cond else ydi (y,x)[cond]dà

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

Lynn ha suggerito di abbreviare la condizione 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

con il risultato di 

lambda a:reduce(lambda b,c:(b*(6,2)[c<30]%864,1)[b*25>b*c],a,1)
— Udo Borkowski
fonte
Devi includere anche la dichiarazione di importazione :)
— Muhammad Salman,
1
In realtà non è necessario importare da ridurre functools, è un built-in in Python 2 !
— Lynn,
1
È possibile verificare se b*25>b*ce salvare 3 byte; questo potrebbe applicarsi a molte delle soluzioni che adottano questo approccio in diverse lingue :)
— Lynn,
@Lynn Mille grazie. Ho aggiornato la soluzione di conseguenza.
— Udo Borkowski,
2

Pyth, 23 byte

f&glT5&>T]25gePPT30SM.:

Provalo qui

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.
— Mnemonico
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.