Resulta que mi tostadora está un poco rota. Perdió WiFi (ya sabes, es una de esas tostadoras inteligentes novedosas), ¡y se ha vuelto loco! Como ya no funciona, he tenido que hackear el código fuente de mi desayuno y ejecutarlo Plate.bread.toastAs(3);todas las mañanas. ¿Ayudaras?

Mi tostadora toma una entrada: la cantidad de tiempo que desea tostar su pan. Esto se escribe como min:sec, como 5:45o 0:40(Hasta 59:59). Luego devuelve un valor específico para diferentes niveles de tostado:

0:00-0:30 = Bread
0:31-1:00 = Warm Bread
1:01-2:00 = Toasty
2:01-3:30 = Burnt
3:31 and up = Brûlée (or Brulee)

Pero aquí está el truco: ¡mi tostadora tiene un teclado roto! Su código no puede contener punto y coma o ... dos puntos. Esto podría ser más difícil de lo que el reparador de tostadoras dijo que sería ...

Aquí hay algunos casos de prueba, para que pueda ... probar sus casos?

0:00 = Bread
5:50 = Brulee or Brûlée
2:00 = Toasty
ChicknMcNuggets = Anything
-1:00 = Anything
0:60 = Anything
1 = Anything
60:00 = Anything
1:00:00 = Anything

• Las lagunas estándar están prohibidas

• Se aceptan todas las formas aceptables de entrada / salida.

• El nuevo código de My Toaster no puede contener un punto y coma (;) o dos puntos (:)

• Este es el código de golf , por lo que gana la respuesta más corta (en cada idioma).

Pitón 2 , 124 118 116

t=eval(input().replace("\x3A","."))
print["Bread","Warm Bread","Toasty","Burnt","Brulee"][sum([t>3.3,t>2,t>1,t>.3])]

Pruébalo en línea!

-6 con agradecimiento a @tsh y también gracias por los casos de prueba TIO.

-2 con un par de consejos geniales de @BlackOwlKai

Lanza un ValueErrorpara entradas no válidas que no se pueden convertir a flotante. Para números menores que 0, devuelve "Pan" porque todavía es pan. Adivina si somos realmente estrictos para asegurarnos de que la entrada sea un tiempo válido, pero para mí lo interesante fue cómo evitarlo :en Python.

T-SQL, 409 379 328 318 bytes

DECLARE @i varchar(9)DECLARE @a time='0'+CHAR(58)+@i DECLARE @ int=DATEPART(N,@a),@s int=DATEPART(S,@a)SELECT CASE WHEN @<1AND @s<31THEN'Bread'WHEN @<1OR @=1AND @s=0THEN'Warm Bread'WHEN @<2OR @=2AND @s=0THEN'Toasty'WHEN @<3OR @<4AND @s<31THEN'Burnt'ELSE'Brulee'END WHERE LEN(RIGHT(@i,LEN(@i)-CHARINDEX(CHAR(58),@i)))=2

-30 bytes: Se ha eliminado AS palabras clave, combinados DECLARE declaraciones (gracias a BradC )
-51: bytes modificados declaraciones / cláusula where para tomar ventaja de la funcionalidad de fecha y hora de SQL
-10 bytes: se ha cambiado MINUTE a N y SECOND a S (gracias a BradC )

¿Sabía que SQL no puede dividir cadenas de forma nativa en una capacidad decente? No dejes que STRING_SPLITte engañe; No funciona para esto. O al menos, no soy lo suficientemente inteligente como para entenderlo.

Diferente de la solución T-SQL basada en tablas de BradC .

Sin golf:

-- Input variable
DECLARE @i varchar(9)

-- Time declarations (passes in as form "00:mm:ss")
-- CHAR(58) maps to ':'
DECLARE @a time = '0' + CHAR(58) + @i

-- Integer declarations
DECLARE @ int = DATEPART(N, @a),    -- minutes
        @s int = DATEPART(S, @a)    -- seconds

SELECT CASE
            WHEN @ < 1 AND @x < 31              -- 0:00 - 0:30
                THEN 'Bread'
            WHEN @ < 1 OR @ = 1 AND @x = 0      -- 0:31 - 1:00
                THEN 'Warm Bread'
            WHEN @ < 2 OR @ = 2 AND @x = 0      -- 1:01 - 2:00
                THEN 'Toasty'
            WHEN @ < 3 OR @ < 4 AND @x < 31     -- 2:01 - 3:30
                THEN 'Burnt'
            ELSE 'Brulee'                       -- 3:31 - 59:59
       END

-- Setting input as a time means that you only have to check if the seconds input is two characters, all other checks accounted for
WHERE LEN(RIGHT(@i, LEN(@i) - CHARINDEX(CHAR(58), @i))) = 2

Java 8, 148 bytes

una lambda de StringaString

t->{float n=new Float(t.replace("\72","."))\u003breturn n>3.3?"Brulee"\u003an>2?"Burnt"\u003an>1?"Toasty"\u003an>.3?"Warm Bread"\u003a"Bread"\u003b}

\u003by \u003ason secuencias de escape Unicode de nivel fuente para ;y :respectivamente.

Pruébalo en línea

Sin golf

t -> {
    float n = new Float(t.replace("\72",".")) \u003b
    return
        n > 3.3 ? "Brulee" \u003a
            n > 2 ? "Burnt" \u003a
            n > 1 ? "Toasty" \u003a
            n > .3 ? "Warm Bread" \u003a
            "Bread"
    \u003b
}

Expresiones de gratitud

• -24 bytes gracias a Olivier Grégoire

JavaScript (SpiderMonkey) , 100 bytes

a=>'Bread,Warm Bread,Toasty,Burnt,Brulee'.split`,`[((t=a.replace(/\D/,'.'))>3.3)+(t>2)+(t>1)+(t>.3)]

Pruébalo en línea!

JavaScript (Node.js) , 91 bytes

a=>[,b='Bread','Warm '+b,o='Toasty',o,u='Burnt',u,u][new Date([70,a])/-~18e5+1|0]||'Brulee'

Pruébalo en línea!

PHP, 96 bytes

<?=[Bread,"Warm Bread",$t=Toasty,$t,$u=Burnt,$u,$u,Brulee][min(7,2*$argn+substr($argn,-2)/30)]?>

requiere PHP 5.5 o posterior. Ejecutar como tubería -nFo probarlo en línea .

T-SQL, 143155145 bytes

SELECT TOP 1b FROM i,
(VALUES(31,'Bread'),(61,'Warm Bread'),(121,'Toasty'),(211,'Burnt'),(1E4,'Brulee'))t(a,b)
WHERE a>DATEDIFF(s,0,'0'+CHAR(58)+v)

Los saltos de línea son solo para legibilidad. Método diferente al de la solución SQL basada en variables de Meerkat .

La entrada se toma a través de la tabla i existente con el campo varchar v , según nuestros estándares IO . Esa tabla de entrada está cruzada con una tabla en memoria t con nuestros valores de corte (en segundos) y las etiquetas deseadas.

La magia ocurre en la WHEREcláusula: DATEDIFFcalcula la diferencia en segundos entre la medianoche y nuestra entrada (con un extra 0:adjunto al frente), luego devuelve la etiqueta de coincidencia más baja (a través de TOP 1).

Las entradas no válidas devuelven un valor impredecible o arrojan un error:
Conversion failed when converting date and/or time from character string.

La pregunta era un poco vaga, pero si es necesario, puedo evitar estos errores (y no devolver nada) agregando el siguiente LIKEpatrón a la WHEREcláusula, llevando el total de bytes a 238 211 201 :

AND RIGHT('0'+v,5)LIKE'[0-5][0-9]'+CHAR(58)+'[0-5][0-9]'

EDITAR : Mi envío más corto original estaba fallando para las entradas 24:00, ya que lo estaba tratando como hh:mm. Tuve que agregar el '0'+CHAR(58)+prefijo, que agregó 12 bytes.

EDIT 2 : Afeitado 27 bytes desde el LIKEen mi versión alternativa

EDIT 3 : eliminado ORDER BYde ambas versiones, ya que resultó innecesario en las pruebas. (SQL no garantiza que el orden de clasificación se mantendrá sin un explícito ORDER BY, pero me pareció que funcionaba bien en este caso específico).

05AB1E , 43 42 bytes

þ30тx330)ć‹O„©Ãº™D#θ‚R.•liSÕô6>Āµ·•6ôÀ«™sè

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

þ                # Leave only the digits of the (implicit) input
                 #  i.e. "1:15" → 115
 30              # Push 30
   т             # Push 100
    x            # Pop and push 100 and 100 doubled (200)
     330         # Push 330
        )        # Wrap the stack into a list: [inputDigits,30,100,200,330]
         ć       # Pop and push the head and rest of array as separated items to the stack
          ‹      # Check for each if its smaller than the head (1=truthy, 0=falsey)
                 #  i.e. [30,100,200,330] and 115 → [1,1,0,0]
           O     # Take the sum of this
                 #  i.e. [1,1,0,0] → 2
„©Ãº™            # Push string "warm bread"
     D#          # Duplicate it, and split it by spaces: ["warm","bread"]
       θ         # And only leave the last element: "bread"
        ‚R       # Pair them into a list, and reverse that list: ["bread","warm bread"]
.•liSÕô6>Āµ·•    # Push string "bruleetoastyburnt"
             6ô  # Split into parts of size 6: ["brulee","toasty","burnt"]
               À # Rotate it once towards the left: ["toasty","burnt", "brulee"]
«                # Merge both lists together:
                 #  ["bread","warm bread","toasty","burnt","brulee"]
 ™               # Titlecase each word: ["Bread","Warm Bread","Toasty","Burnt","Brulee"]
  s              # Swap so the number is at the top of the stack again
   è             # Index it into the list (and output implicitly)
                 #  i.e. 2 → "Toasty"

Vea esta sugerencia mía 05AB1E (secciones ¿Cómo usar el diccionario? Y ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender por qué „©Ãº™es "warm bread"y .•liSÕô6>Āµ·•es "bruleetoastyburnt".

þ30тx330)ćalternativamente puede ser 30тx)DOªsþpara el mismo número de bytes: Pruébelo en línea.

Javascript (ES6 +), 180 bytes

Node.js (180 bytes)

let f=(s,i=s.split("\u{3a}"),j=i[0]*60+1*i[1],k="Bread",l=assert(new RegExp("^(.|[0-5].)\u{3a}[0-5].$").test(s)))=>eval("(j<31)?k\u{3a}(j<61)?'Warm '+k\u{3a}(j<121)?'Toasty'\u{3a}(j<211)?'Burnt'\u{3a}'Brulee'")

Navegador (188 bytes):

let f=(s,i=s.split("\u{3a}"),j=i[0]*60+1*i[1],k="Bread",l=console.assert(new RegExp("^(.|[0-5].)\u{3a}[0-5].$").test(s)))=>eval("(j<31)?k\u{3a}(j<61)?'Warm '+k\u{3a}(j<121)?'Toasty'\u{3a}(j<211)?'Burnt'\u{3a}'Brulee'")

Tengo que usar esas secuencias de escape unicode :-) solo una gran cadena de operadores ternarios, con variables definidas por parámetros predeterminados. También una línea, por lo que no hay js con punto y coma

Retina 0.8.2 , 97 bytes

.+(..)
$*1#$1$*
+`1#
#60$*
#1{211,}
Brulee
#1{121,}
Burnt
#1{61,}
Toasty
#1{31,}
Warm #
#1*
Bread

Pruébalo en línea! El enlace incluye casos de prueba. Explantación

.+(..)
$*1#$1$*

Convierta los minutos y segundos a unario.

+`1#
#60$*

Multiplique los minutos por 60 y agregue los segundos.

#1{211,}
Brulee
#1{121,}
Burnt
#1{61,}
Toasty

Decodifica los segundos en la tostada.

#1{31,}
Warm #

Decodifica Pan caliente al notar que #(para las 0:00) se decodifica a Bread.

#1*
Bread

Si aún no tenemos tostadas, entonces el pan todavía está frío.

Perl 6 , 86 79 67 bytes

-4 bytes gracias a nwellnhof! -12 bytes al portar la solución de tsh

{<<Bread'Warm Bread'Toasty Burnt Brulee>>[sum S/\D/./X>.3,1,2,3.3]}

Pruébalo en línea!

C (gcc) , 130 bytes

f(a){if(*strchr(a,58)=48,a=atoi(a),a=(int*[]){"Bread","Warm Bread","Toasty","Burnt","Brulee"}[(a>30)+(a>1e3)+(a>2e3)+(a>3030)]){}}

Pruébalo en línea!

¡Chasquido! 4.2 , 257251 bytes

Minificó la versión de texto un poco más.

No he encontrado ninguna respuesta en Snap !, un lenguaje de programación visual similar a Scratch, así que usaré la sintaxis scratchblocks2, ¡pretendiendo que Snap! Los bloques exclusivos son válidos en scratchblocks2.

Pruébalo en línea! (haga clic en el botón con las dos flechas para ver el código)

when gf clicked
ask[]and wait
set[l v]to(split(answer)by(unicode(58)as letter
set [t v]to(((item(1 v)of(l))*(60))+(item(2 v)of(l
if<(t)<[31
say[Bread
else
if<(t)<[61
say[Warm Bread
else
if<(t)<[121
say[Toasty
else
if<(t)<[211
say[Burnt
else
say[Brulee

R , 127 122 bytes

function(t)cut((x=eval(parse(t=t)))[1]*60+tail(x,1),30*c(0:2,4,7,Inf),c("Bread","Warm Bread","Toasty","Burnt","Brulee"),T)

Pruébalo en línea!

Devuelve a factorcon el nivel apropiado.

-5 bytes gracias a JayCe.

Japt , 48 bytes

`BÎ%
W‡m BÎ%
To†ty
B¨›
BrÔ‡`·g[30LLÑ,330]è<Ur58d

Pruébalo en línea!

Ahorró 5 bytes al leer los consejos ...

Explicación:

`BÎ%...BrÔ‡`·                       Compressed array of possible outputs
             g                      Get the one at the index given by...
                         è          The number of items...
              [30LLÑ,330]           From the list [30,100,200,330]...
                          <Ur58d    Which are less than the input without ":"

Se podría guardar un byte adicional al emitir en minúsculas.

Jalea , 43 41 40 bytes

fØD~~ḌH“Ð2dʠ‘<Sị“¡Ḳḋ\ḞvṾƤSİƓƥeF½ÞØ+®°»Ỵ¤

Pruébalo en línea!

Explicación (antigua)

“¡Ḳḋ\ḞvṾƤSİƓƥeF½ÞØ+®°»es la cadena comprimida Warm Bread\nToasty\nBurnt\nBrulee\nBread, encontrada por el optimizador de compresión .

fØD                               Filter out the non-digits (i.e. colon) from input
   ~~                             Use binary NOT twice to convert to digit list
     Ḍ                          
      HḞ                        Halve and floor. Now we have "01:45" -> 72.
        “Ç1cƥ‘                    The array [14,49,99,164]
              <                   Vectorized less than
               S                  Sum
fØD~~ḌHḞ“Ç1cƥ‘<S                How many threshold times is input less than?
                                           (0 -> Bread, 4 -> Brulee.)
                ị               Index (note 0ị gives the last list item) into
                       ¤        the new dyadic link given by
                 “...»            The long string, decoded and
                      Ỵ           split by newlines.

Inspirado por la respuesta de Kamil Drakari .

-2 bytes usando un fragmento ~~Ḍde Dennis.

Encantamientos rúnicos , 118 bytes

\>`tttt`,kw,kw,kw,ki
\uqn.3X)?\ . 1C)?\.2C)?\'Ŋ)?\"Brulee"
\D"daerB"L" mraW"/
$L"ytsaoT"L?9"tnruB"L?aL?3 F/

Pruébalo en línea!

Utiliza algunos caracteres ASCII no imprimibles (STX, EOT, SOH, STX, VT, SOH, STX, DC2, SOH y STX en ese orden) en la primera línea, que se lee en una secuencia de bytes en el orden en que están va a ser necesario en la pila Luego se realizan 3 operaciones de división ( 't'/2igual :) y escritura reflexiva. Esto pone 3 :comandos (duplicados) donde hay actualmente .(NOP) para comparar no destructivamente la entrada con los umbrales de tiempo. Queda un cuarto :en la pila antes de leer la entrada.

El tiempo se lee como una cadena, luego se divide :y se concatena de nuevo en una cadena. Como los valores anteriores 59:59no tienen ninguna especificación en la salida, los valores como 1:00:00tendrán una salida indefinida (pero determinista). Esta cadena se convierte en un número y se compara con 30, 100, 200 y 330 (el valor de byte de Ŋ). "Bread"(línea 3, la ejecución de RTL) se utiliza dos veces, tanto para Bready Warm Breadresultados, el ahorro de por lo menos 5 bytes.

Ahorra 1 byte al no tener un comando terminador clásico ( ;) al usar Fizzle en la última línea. Esto convence al analizador de que el programa está garantizado para finalizar sin causar que lo haga de inmediato (y, lo que es más importante, que no toque la pila). Las entradas válidas dejarán la pila vacía para que, cuando se repita y toque una, wla IP finalice por realizar una acción ilegal.

Javascript, 115101 bytes

-6 de tsh

d=>[b="Bread","Warm "+b,a="Toasty",a,c="Burnt",c,c][~~(parseInt(d)*1.999+d.slice(-2)/30.1)]||"Brulee"

JavaScript (ES6), 171 bytes

(x,y=Math.ceil(x.split(/\D/).reduce((a,b)=>(+a)*60+(+b))/30))=>["Bread","Bread","Warm Bread","Toasty","Toasty","Burnt","Burnt","Burnt","Brulee","Brulee","Brulee"][y>8?8:y]

Ejecute algunos casos de prueba con este fragmento de pila:

var f=(x,y=Math.ceil(x.split(/\D/).reduce((a,b)=>(+a)*60+(+b))/30))=>["Bread","Bread","Warm Bread","Toasty","Toasty","Burnt","Burnt","Burnt","Brulee","Brulee","Brulee"][y>8?8:y]

var result = document.getElementById("result");
["0:00", "0:30", "0:31", "1:00", "1:01", "2:00", "2:01", "2:30", "2:31", "3:00", "3:01", "3:30", "3:31", "4:00", "4:01", "4:30", "4:31", "5:00", "6:00"].forEach(x => result.innerHTML += `${x}: ${f(x)}\n`);

<pre id="result"></pre>

F #, 177 bytes

let t i=
 let s=i.ToString().Split(char 58)
 let m=int s.[0]*60+int s.[1]
 if m<31 then"Bread"elif m<61 then"Warm Bread"elif m<121 then"Toasty"elif m<211 then"Burnt"else"Brulee"

Pruébalo en línea!

Gracias a Jo King por enderezar mi, umm, innecesariamente literal interpretación del desafío ...

F # está bastante bien para funciones sin punto y coma o dos puntos. El único problema real era que no podía hacerlo i.Splitdirectamente sin una anotación de tipo: F # no habría podido deducir el tipo de en ifunción de la llamada al método. Eso habría requerido definir el tipo directamente en la función, como let t (i:string)=lo que habría estado en contra de las reglas.

Pero podría superarlo fácilmente i.ToString(), lo que me permitió recurrir Splita él. Luego char 58es un carácter de dos puntos, y después de eso es sencillo.