Detectar olas de calor

48

Antecedentes

El Instituto Meteorológico Real de los Países Bajos define una ola de calor * como una serie de al menos 5 días consecutivos de clima ≥25 ° C ("clima veraniego"), de modo que al menos 3 de esos días son ≥30 ° C ("clima tropical" )

El clima tropical no tiene que medirse consecutivamente: por ejemplo: 30, 25, 30, 26, 27, 28, 32, 30es una ola de calor de 8 días de duración con 4 días de clima tropical.

* (Bueno, para los estándares holandeses).

Desafío

Dada una lista no vacía de enteros positivos que representan mediciones de temperatura Celsius de días sucesivos, decida si esa lista contiene una ola de calor (según la definición anterior).

La respuesta más corta en bytes gana.

Casos de prueba

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]

Verdad:

[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
fuente
2
¿Se garantiza que la temperatura sea inferior a 100 grados Celsius?
— FryAmTheEggman
3
@FryAmTheEggman Bueno, en los Países Bajos, sí :), pero no quiero que tu respuesta abuse de este hecho, así que no.
— Lynn el
1
@ HatWizard Sí, está bien. "Crash / don't crash" también está bien, por ejemplo.
— Lynn
2
Hola @ Lynn, este fue un gran desafío y todavía lo es :-)
— Roland Schmitz
1
@RolandSchmitz ¡Gracias! Estoy felizmente sorprendido por las respuestas creativas que surgieron tan tarde en la vida del desafío. 🎉
— Lynn

Respuestas:

19

Jalea , 15 bytes

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

Un enlace monádico que acepta una lista de números que regresa 1si se detecta una ola de calor más 0.

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

El criterio es la existencia de una serie de más de cuatro valores mayores o iguales a 25, de los cuales más de dos deben ser mayores o iguales a 30.

Si dividimos entre cinco, el criterio se convierte en la existencia de una serie de más de cuatro valores mayores o iguales a cinco, de los cuales más de dos deben ser mayores o iguales a seis.

Si restamos cinco de estos valores, el criterio se convierte en la existencia de una serie de más de cuatro valores mayores o iguales a cero, de los cuales más de dos deben ser mayores o iguales a uno.

Si tomamos el signo de estos valores (obteniendo -1, 0 o 1) el criterio se convierte en la existencia de una serie de más de cuatro valores no iguales a -1, de los cuales más de dos deben ser iguales a uno.

Si agregamos uno a estos valores (obteniendo 0, 1 o 2), el criterio se convierte en la existencia de una serie de más de cuatro valores no iguales a cero, de los cuales más de dos deben ser iguales a dos.

El producto de una lista que contiene ceros es cero y el producto de una lista que contiene más de dos dos (y el resto son unos) es más de cuatro. Esto significa que el criterio en esta lista ajustada se convierte en que el mínimo del producto y la longitud es mayor que 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
fuente
9

Haskell , 73 72 71 69 67 66 bytes

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

¡Gracias a @flawr y @Laikoni por dos bytes cada uno y a @xnor por un byte!

Pruébalo en línea!

Misma longitud:

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

Pruébalo en línea!

— Angs
fuente
9

C (clang) , 64 bytes

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

La función o () devuelve 1 para una ola de calor o 0 más.

Gracias al número mágico 864 y a Udo Borkowski y Mathis por sus ideas.

¿Cómo funciona si funciona? Cada secuencia de números se repite con una operación de reducción que comienza en el valor de reducción 1. Si se ve un número> = 25, la reducción se multiplica por 2. Si se ve un número> = 30, la reducción se multiplica por 2 y por 3 = 6. Si se ve un número <25, la reducción comienza nuevamente en 1. Si la reducción es divisible por 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, se encuentra una ola de calor y el resultado de la reducción la operación del módulo es 0, lo que da como resultado un valor reducido de 0 y un valor de retorno de verdadero.

Pruébalo en línea!

— Roland Schmitz
fuente
Bienvenido a PPCG.
— Muhammad Salman
Bienvenido a PPCG! Muy buena primera respuesta completa con conjunto de casos de prueba! ¿Podría agregar una explicación para que comprendamos la magia?
— JayCe
Esa es una solución realmente elegante, bien hecho :)
— Lynn
7

APL (Dyalog Classic) , 21 20 bytes

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

Pruébalo en línea!

usos ⎕io←1

25 30⍸x es 0 si x <25, 1 si 25≤x <30, o 2 de lo contrario

calculamos los productos acumulativos de estos a partir de (o de manera equivalente: terminando en) todas las ubicaciones posibles, descartamos los primeros 4 productos y detectamos la presencia de productos ≥8 (que es 2 3 )

— ngn
fuente
6

Japt , 19 18 bytes

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

Espero haber entendido todas las discusiones en los comentarios correctamente.
Afeitado un byte gracias a Shaggy .

Pruébalo en línea!

— Liendre
fuente
Pensé que esto funcionaría más corto cuando lo estaba leyendo, pero solo podía administrar 18 bytes .
— Shaggy
@ Shaggy Yo también lo pensé, pero tampoco pude encontrar una versión más corta. Muchas gracias por el puntero!
— Nit
1
Parece que estamos ganando este en este momento :)
— Shaggy
¿Los caracteres no ASCII no cuentan como bytes múltiples?
— sudo
1
@sudo Esos símbolos son todos de un solo byte. Por ejemplo, 漢serían 3 bytes, pero ¨es un byte. Los símbolos utilizados anteriormente se han elegido para el idioma de golf exactamente por el hecho de que todos son de un solo byte.
— Nit
5

PowerShell , 121 bytes

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

Pruébalo en línea! o Verificar todos los casos de prueba

PowerShell no tiene el equivalente de .someao .everyo similar, por lo que se enrolla a mano.

Tomamos la entrada $acomo una matriz de enteros. Establezca la variable auxiliar $ben la cadena vacía. Luego, recorra cada número entero $a. Dentro del bucle, si el entero es -greaterthanor equal a 25, añadirlo a nuestra cadena de potencial $b, puesto de otro modo $ben la tubería y la puso en la cadena vacía.

Una vez fuera del ciclo, concatene la matriz con los resultados de la canalización $by colóquelos en una Where-Objectcláusula |?{...}. Esto extrae aquellas cadenas que tienen una longitud de elemento de -ge5(basada en la división en espacios en blanco) y un recuento de temperaturas mayores que 30ser -ge3. Esas cadenas se dejan en la tubería, por lo que un valor de verdad no está vacío (vea el enlace "verificar todos los casos de prueba" para la distinción de verdad / falsey).

— AdmBorkBork
fuente
intente usar $args en su lugar param($a)y$a
— mazzy
-2 bytes...{$a=-split$_;$a.count-ge5-and($a|?{$_-ge30}).count-ge3}
— mazzy
109 bytes con matrices. guardar $args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}-B{,($b=@())}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}como get-heatWave.ps1. Script de prueba regex101.com/r/lXdvIs/2
— mazzy
103 bytes$b=@();$args|%{if($_-ge25){$b+=$_}else{,$b;$b=@()}}-E{,$b}|?{$_.count-ge5-and($_|?{$_-ge30}).count-ge3}
— mazzy
¿Qué -Ehacer? No estoy familiarizado con eso.
— AdmBorkBork
5

Jalea , 17 16 bytes

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

Pruébalo en línea!

Cómo funciona

: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
fuente
4

05AB1E , 20 bytes

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

Pruébalo en línea!

Explicación

Π                    # 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
fuente
4

Lote, 119 bytes

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

Toma la entrada como argumentos de línea de comando y las salidas 1 para una ola de calor, de lo contrario 0.

— Neil
fuente
4

Python , 67 bytes

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

Pruébalo en línea!

Se agota el tiempo de espera en los casos de prueba más largos debido al crecimiento exponencial. Encuentra sublistas contiguas cortando repetidamente el primer o el último elemento. Los 3 días son ≥30 ° C se verifica mirando el tercer valor más grande sorted(l)[~2]. Los casos base tal vez podrían ser más cortos aprovechando la verdad / falsa o terminando con un error.

— xnor
fuente
4

APL (Dyalog Unicode) , 29 bytes

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

Pruébalo en línea!

∨/¿hay algún elemento tal que

(5≤≢¨a)5 <el recuento ≢de días en cada serie ( atiene todas las series posibles de días)

∧ y

3≤+/30≤3 ≤ el +/número total de elementos que son ≥ 30 en

↑a← la matriz formada por

e⊆⍨25≤e←⎕ la serie de elementos consecutivos que son ≥ 25

— Kritixi Lithos
fuente
Su primera prueba se comenta innecesariamente, funciona.
— ngn
@ngn Gracias por ver eso, arreglado
— Kritixi Lithos
4

Kotlin , 57 bytes

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

(-1 Byte reemplazando el parámetro explícito v-> con el parámetro implícito it )

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

(-16 bytes usando la operación any {} como se ve en la Solución Ruby de 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 gracias Lynn: reemplazó 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}

Esta expresión lambda toma una Lista y devuelve verdadero para una ola de calor o falso más.

Gracias al número mágico 864 y a Udo Borkowski y Mathis por sus ideas.

¿Cómo funciona si funciona? Cada secuencia de números se repite con cualquier operación {} que comience en el valor de reducción 1. La reducción se multiplica por 2 y se multiplica por 3 (2 * 3 = 6) si el número es mayor o igual a 30. Si un número <25 se ve que la reducción comienza nuevamente en 1. Si la reducción es divisible por 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, entonces se encuentra una ola de calor, y el resultado de la operación del módulo es 0, lo que resulta en un valor de retorno verdadero en el lambda interno llamado desde la operación any {} que luego deja de iterar y devuelve el valor verdadero

Pruébalo en línea!

— Roland Schmitz
fuente
Buena explicación :)
— JayCe
Creo que el recuento de bytes debe reflejar la declaración de función completa, no solo el cuerpo de la función. Como es ahora, me parece un fragmento.
— Jonathan Frech
@ jonathan-frech, cambié el cuerpo de la función a una expresión lambda un poco más larga que incluye los corchetes que no son opcionales como en Java. ¿Es justo?
— Roland Schmitz
@RolandSchmitz Mirando otras presentaciones de Kotlin y presentaciones de funciones lambda de Java, supongo que no se incluye el recuento de bytes de declaración de función; lo que significa que su envío original es probablemente válido. Perdón por mi comentario, me pareció extraño ya que me parece que es muy snippet-esk, ya que no es una construcción de lenguaje válida sin la declaración de tipo.
— Jonathan Frech
3

Maravilla , 34 bytes

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

Ejemplo de uso:

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

Explicación

Versión detallada:

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

Tome secuencias superpuestas de 5 elementos consecutivos, luego verifique si alguna de las secuencias tiene todos los elementos> 25 y más de 2 elementos> 30.

— Mama Fun Roll
fuente
Hola, esto no está relacionado, pero el enlace de Facebook en su sitio web está muerto.
— mbomb007
3

Stax , 23 bytes

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

¡Ejecútelo y depúrelo en staxlang.xyz! Esto tarda mucho tiempo en ejecutarse, por lo que desactivé la ejecución automática.

Desempaquetado (28 bytes) y explicación

: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

Esto imprimirá todas las submatrices que se pueden contar como ondas de calor, lo que será falso si solo existe.

— Khuldraeseth na'Barya
fuente
3

Casco , 19 bytes

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

Pruébalo en línea!

Usar filter ( f) es un byte más corto que usar check con un lógico y ( &) , también sería realmente bueno deshacerse de los ±2 bytes que cuestan :(

Explicación

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

R , 111 93 71 67 66 bytes

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

Pruébalo en línea!

El puerto descarado de las respuestas de Roland Schmitz . -4 bytes gracias a Roland y -1 gracias a Giuseppe.

TIO enlaces a la versión funcional.

¡La versión anterior extrajo días consecutivos> 25 usando rley guardó la friolera de 18 bytes gracias a Giuseppe!

— JayCe
fuente
si usa en Flugar de T, puede hacerlo F=F|"if"(cond,(expr),0)y luego regresar Fpara guardar 6 bytes ish. También tiene un par de paréntesis innecesarios, (1-z[i]):0pero creo que eso podría ser de 1-z[i]:1todos modos para guardar otro par de bytes ...
— Giuseppe
^ Estaba a punto de enviar el comentario anterior cuando se me ocurrió otra idea, ¡y logré encontrar una solución de menos de 100 bytes! Es 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}pero tenga cuidado de pegar desde PPCG en TIO debido a la fluencia a veces unprintables en ...
— Giuseppe
¡Esto es fantástico! Probablemente hay una forma aún más corta de aprovechar las matemáticas de Jonathan Allan ...
— JayCe
Agradable, incluso podría guardar algunos bytes más, si simplifica la parte interna de (i * 2 * (1+ (2 * (j> 29)))) a (i * (2 + 4 * (j> 29) ))
— Roland Schmitz
@RolandSchmitz muy cierto!
— JayCe
3

Swift 4 , 50 bytes

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

Pruébalo en línea!

La expresión de cierre devuelve 0 para una ola de calor o> 0 más.

Creado en colaboración con Roland Schmitz y Mathis.

¿Cómo funciona si funciona? Cada secuencia de números se repite con una operación de reducción que comienza en el valor de reducción 1. Si se ve un número> = 25, la reducción se multiplica por 2. Si se ve un número> = 30, la reducción se multiplica por 2 y por 3 = 6. Si se ve un número <25, la reducción comienza nuevamente en 1. Si la reducción es divisible por 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, se encuentra una ola de calor y el resultado de la reducción la operación del módulo es 0, lo que da como resultado un valor de reducción de 0. Solo cuando se encuentra una ola de calor, la reducción puede convertirse en 0. Una vez que el valor de reducción es 0, será 0 para todas las reducciones futuras, es decir, también para el resultado final.

— Udo Borkowski
fuente
3

Python 2 , 66 63 bytes

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

Pruébalo en línea!

-3 bytes gracias a Lynn

¿Cómo funciona si funciona? Cada secuencia de números se repite con una operación de reducción que comienza en el valor de reducción 1. Si se ve un número> = 25, la reducción se multiplica por 2. Si se ve un número> = 30, la reducción se multiplica por 2 y por 3 = 6. Si se ve un número <25, la reducción comienza nuevamente en 1. Si la reducción es divisible por 864 = 2 * 2 * 2 * 2 * 2 * 3 * 3 * 3, se encuentra una ola de calor y el resultado de la reducción la operación del módulo es 0, lo que da como resultado un valor de reducción de 0. Solo cuando se encuentra una ola de calor, la reducción puede convertirse en 0. Una vez que el valor de reducción es 0, será 0 para todas las reducciones futuras, es decir, también para el resultado final.

Una versión más legible pero más larga se ve así:

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

Quitar espacio extra / paréntesis y la sustitución x if cond else ypor (y,x)[cond]da

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

Lynn sugirió acortar la condición 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

Resultando en 

lambda a:reduce(lambda b,c:(b*(6,2)[c<30]%864,1)[b*25>b*c],a,1)
— Udo Borkowski
fuente
También debe incluir la declaración de importación :)
— Muhammad Salman
1
En realidad no necesita importar reducir functools, ¡es un Python 2 incorporado !
— Lynn
1
Puede verificar si b*25>b*cy guardar 3 bytes; esto podría aplicarse a muchas de las soluciones que adoptan este enfoque en diferentes idiomas :)
— Lynn
@ Lynn Muchas gracias. Actualicé la solución en consecuencia.
— Udo Borkowski
2

Pyth, 23 bytes

f&glT5&>T]25gePPT30SM.:

Pruébalo aquí

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.
— Mnemotécnico
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.