Desafío

Escriba un programa que salude a un usuario según la hora del día (GMT) que sea.

Salida

Una cadena (impresa o devuelta) de acuerdo con estas reglas:

• Si el horario es de 06:00 a 11:59 el saludo debe ser "Buenos días"
• Si son las 12:00 a las 17:59, el saludo debe ser "Buenas tardes"
• Si el horario es de 18:00 a 19:59 el saludo debe ser "Buenas tardes"
• Si el horario es de 20:00 a 05:59, el saludo debe ser "Zzz"

Aclaraciones

• No hay entrada
• Los horarios y saludos deben ser exactamente como se muestran
• La zona horaria es +0 GMT

Ejemplos

Time: 14:45 -> Good afternoon

Time: 05:59 -> Zzz

Time: 9:23 -> Good morning

Time: 18:00 -> Good evening

JavaScript (ES6), 87 bytes

Como notó TFeld , mi fórmula original era demasiado complicada. Solo podemos hacer:

_=>['Zzz','Good morning','Good afternoon','Good evening'][new Date().getHours()%20/6|0]

Pruébalo en línea!

O pruebe esta versión que toma la hora como parámetro.

JavaScript (ES6), 90 bytes

_=>['Zzz','Good morning','Good afternoon','Good evening'][new Date().getHours()*7%20%7>>1]

Pruébalo en línea!

O pruebe esta versión que toma la hora como parámetro.

Fórmula

Dada la hora actual , encontramos el índice de saludo apropiado i con:$h$$i$

Lo bueno de esta fórmula es que no requiere ningún paréntesis una vez convertido a JS:

h * 7 % 20 % 7 >> 1

Mesa

 Hour |  *7 | mod 20 | mod 7 | >> 1
------+-----+--------+-------+------
   0  |   0 |    0   |   0   |   0
   1  |   7 |    7   |   0   |   0
   2  |  14 |   14   |   0   |   0
   3  |  21 |    1   |   1   |   0
   4  |  28 |    8   |   1   |   0
   5  |  35 |   15   |   1   |   0
   6  |  42 |    2   |   2   |   1
   7  |  49 |    9   |   2   |   1
   8  |  56 |   16   |   2   |   1
   9  |  63 |    3   |   3   |   1
  10  |  70 |   10   |   3   |   1
  11  |  77 |   17   |   3   |   1
  12  |  84 |    4   |   4   |   2
  13  |  91 |   11   |   4   |   2
  14  |  98 |   18   |   4   |   2
  15  | 105 |    5   |   5   |   2
  16  | 112 |   12   |   5   |   2
  17  | 119 |   19   |   5   |   2
  18  | 126 |    6   |   6   |   3
  19  | 133 |   13   |   6   |   3
  20  | 140 |    0   |   0   |   0
  21  | 147 |    7   |   0   |   0
  22  | 154 |   14   |   0   |   0
  23  | 161 |    1   |   1   |   0

Python 2 , 120 106 102 bytes

import time
print['Zzz','Good morning','Good afternoon','Good evening'][int(time.time()/3600%24%20/6)]

Pruébalo en línea!

Verificable aquí: ¡ Pruébelo en línea!

Similar a la respuesta de Arnauld , pero ligeramente diferente:

h  %20 /6
---------
0   0   0
1   1   0
2   2   0
3   3   0
4   4   0
5   5   0
6   6   1
7   7   1
8   8   1
9   9   1
10  10  1
11  11  1
12  12  2
13  13  2
14  14  2
15  15  2
16  16  2
17  17  2
18  18  3
19  19  3
20  0   0
21  1   0
22  2   0
23  3   0

Salvado:

• -3 bytes, gracias a Arnauld
• -1 byte, gracias a NP

R, 97 95 93 Bytes

Usando los métodos encontrados anteriormente en R

c("Zzz","Good morning","Good afternoon","Good evening")[as.POSIXlt(Sys.time(),"G")$h%%20/6+1]

Explicación:

c("Zzz","Good morning","Good afternoon","Good evening")      # Creates a vector with the greetings
[                                                            # Open bracket. The number in the bracket will extract the corresponding greeting from the vector below
as.POSIXlt(                                                  # as.POSIXlt converts the object to one of the two classes used to represent date/times
Sys.time(),                                                  # Retrieves the current time on the OS
"G")                                                         # Converts the time to the desired time zone. Does output a warning, but still converts properly to GMT
$h                                                           # Extracts the hour from the object created by as.POSIXlt
%%20/6                                                       # Methodology as used by other golfers
+1]                                                          # Vectors in R start from 1, and not 0 like in other languages, so adding 1 to the value ensures values range from 1 to 4, not 0 to 3

Ejemplo

Observe cómo esta línea de código, sin agregar 1, tiene 10 elementos cortos

c('Zzz','Good morning','Good afternoon','Good evening')[0:23%%20/6]

[1] "Zzz"            "Zzz"            "Zzz"            "Zzz"            "Zzz"            "Zzz"           
[7] "Good morning"   "Good morning"   "Good morning"   "Good morning"   "Good morning"   "Good morning"  
[13] "Good afternoon" "Good afternoon"

Agregar 1 asegura que el resultado obtenido sea mayor que 0

c('Zzz','Good morning','Good afternoon','Good evening')[as.integer(0:23)%%20/6+1]

[1] "Zzz"            "Zzz"            "Zzz"            "Zzz"            "Zzz"            "Zzz"           
[7] "Good morning"   "Good morning"   "Good morning"   "Good morning"   "Good morning"   "Good morning"  
[13] "Good afternoon" "Good afternoon" "Good afternoon" "Good afternoon" "Good afternoon" "Good afternoon"
[19] "Good evening"   "Good evening"   "Zzz"            "Zzz"            "Zzz"            "Zzz"

T-SQL, 153 bytes

SELECT CASE WHEN a>18THEN'Good afternoon'WHEN a>12THEN'Good morning'WHEN a>2THEN'Zzz'ELSE'Good evening'END
FROM(SELECT(DATEPART(hh,GETUTCDATE())+6)%24a)a

Prueba el violín de SQL

Explicación:

SELECT
  CASE WHEN a>18 THEN'Good afternoon' --CASE returns the first value in order whose condition is met
       WHEN a>12 THEN'Good morning'
       WHEN a>2  THEN'Zzz'
       ELSE 'Good evening'
       END
FROM( SELECT (      --Use a subquery to treat the time like a 1x1 table - shorter than declaring a variable
    DATEPART(hh,    --Returns the hour part (hh) of the date
      GETUTCDATE()) --Returns current UTC time (as far as the SQL Server is concerned)
        +6)%24      --Virtual time zone where no period crosses midnight, so everything is ordered
        a)          --Give column a 1-letter alias
        a           --Give subquery an alias so SQL Server doesn't complain

Perl 5 , 77 bytes

$_=(gmtime)[2]%20;say$_<6?Zzz:"Good ".($_<12?morning:$_<18?afternoon:evening)

Pruébalo en línea!

Excel, 97 bytes

=VLOOKUP(Hour(Now()),{0,"Zzz";6,"Good morning";12,"Good afternoon";18,"Good evening";20,"Zzz"},2)

Comience con la lista de casos

0 <= HORA <6: "Zzz"
6 <= HORA <12: "Buenos días"
12 <= HORA <18: "Buenas tardes"
18 <= HORA <20: "Buenas noches"
20 <= HORA: "Zzz "

Luego, use un rango basado en Vlookup(predeterminado si omite el 4to argumento) con una matriz de valores:

H= 0El | "Zzz"
H= 6El | "Good morning"
H=12El | "Good afternoon"
H=18El | "Good evening"
H=20El |"Zzz"

{0,"Zzz"; 6,"Good morning"; 12,"Good afternoon"; 18, "Good evening"; 20,"Zzz"}

Experimenté con el uso MOD(HOUR(NOW())+18,24de retroceder la hora en 6 y reducir los casos en 1, pero eso resultó en 99 bytes. :(

05AB1E , 36 bytes

”‚¿”…•´¯âžÖ#1ú«…Zzz¸«ža•1Ý;`{ùí4²•èè

Pruébalo en línea!

”‚¿”                                 # Push 'Good'
    …•´¯âžÖ                          # Push 'morning afternoon evening'
           #                         # Split on spaces.
            1ú                       # Pad each with 1 space.
              «                      # Concat good onto it: ['Good morning',...,'Good evening']
               …Zzz¸«                # Concat 'Zzz' onto it.
                     ža              # Get current hour.
                       •1Ý;`{ùí4²•   # Push 33333000000111111222.
                                  è  # indexes[current_hour]->i[6:00AM]->0
                                   è # phrases[indexes[current_hour]]->p[i[6AM]]->'Good morning'.

Powershell, 82 72 bytes

La respuesta del puerto de TFeld

('Zzz','Good morning','Good afternoon','Good evening')[(date).Hour%20/6]

Lisp común , 103 bytes

(nth(floor(mod(nth-value 2(get-decoded-time))20)6)'("Zzz""Good morning""Good afternoon""Good evening"))

Sin golf

(nth (floor (mod (nth-value 2 (get-decoded-time))
                 20)
            6)
     '("Zzz" "Good morning" "Good afternoon" "Good evening"))

Common Lisp generalmente ignora los espacios en blanco siempre que pueda determinar inequívocamente dónde termina cada sub-expresión, por lo que gran parte del golf aquí solo está eliminando espacios en blanco. Common Lisp también brinda la capacidad de que las funciones devuelvan múltiples valores, con todos menos el primero descartado si la persona que llama no ha solicitado explícitamente los valores de retorno 2º / 3º / etc. Esto permite que las funciones devuelvan datos auxiliares, como la floorfunción realiza la división del piso, pero como un valor de retorno secundario devuelve el resto. Esto también permite que las funciones eviten la sobrecarga de tener que empaquetar sus valores de retorno en una estructura de datos si es probable que la persona que llama lo desestructura inmediatamente. (get-decoded-time)(Realmente una abreviatura para(decode-universal-time (get-universal-time))) devuelve la mayoría de los valores de casi cualquier función estándar en lisp común ... 9, para ser exactos. El tercer valor de retorno ((nth-value 2 ...)) es la hora actual en 24 horas. Entonces solo se calcula el índice adecuado en la lista de respuestas y se lo pasa nth. Tengo que usar flooraquí ya que CL devolvería una fracción adecuada si lo usara /para la división.

Pruébalo en línea!

Lote, 178 bytes

@for /f "tokens=3" %%a in ('wmic path Win32_UTCTime') do @set/ag=%%a%%20/6
@for %%a in (Zzz.0 "Good morning.1" "Good afternoon.2" "Good evening.3") do @if %%~xa==.%g% echo %%~na

Utiliza la fórmula de @ TFeld. La versión dependiente de la configuración regional tiene solo 128 bytes:

@set/ag=%time:~,2%%%20/6
@for %%a in (Zzz.0 "Good morning.1" "Good afternoon.2" "Good evening.3") do @if %%~xa==.%g% echo %%~na

C # (.NET Core) , 177 bytes

using System;namespace a{class b{static void Main(string[] a){Console.WriteLine(new String[]{"Zzz","Good morning","Good afternoon","Good evening"}[DateTime.Now.Hour%20/6|0]);}}}

Pruébalo en línea!

Japt , 52 bytes

`Zzz,Good ¶rÍÁ,Good af’rÍ9,Good evÀxg`q, gKd %20/6|0

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 91 bytes

Write("Zzz,Good morning,Good afternoon,Good evening".Split(',')[DateTime.UtcNow.Hour%20/6])

Pruébalo en línea!

Utiliza Utc Now para obtener la hora UTC.

Si puede ser una función en lugar de un programa completo:

C # (compilador interactivo de Visual C #) , 88 bytes

()=>"Zzz,Good morning,Good afternoon,Good evening".Split(',')[DateTime.UtcNow.Hour%20/6]

Pruébalo en línea!

Prueba con todas las horas (código robado descaradamente de Arnauld)

05AB1E , 45 42 bytes

ža7*20%7%2÷U”‚¿”Xi'•´ëX<i'¯âë'žÖ]ðýX>i…Zzz

(h*7%20%7)//2portado de la respuesta de JavaScript de @ Arnauld (ES6) .

Pruébelo en línea o verifique todas las horas .

Respuesta original de 45 bytes:

žaDV6÷U”‚¿”Xi'•´ëX<i'¯âë'žÖ]ðýX3%>iY2÷9Êi…Zzz

Pruébelo en línea o verifique todas las horas .

Explicación:

ža                 # Get the current hours
  DV               # Duplicate it, and store it in variable `Y`
    6÷U            # Integer-divide it by 6, and store it in variable `X`
”‚¿”               # String "Good"
    Xi             # If `X` is 1:
      '•´          #  Use string 'morning'
    ëX<i           # Else-if `X` is 2:
        '¯â        #  Use string 'afternoon'
    ë              # Else:
     'žÖ           #  Use string 'evening'
           ]       # Close all if-elses
            ðý     # Join the two string literals with a space
X3%>i              # If `X` modulo-3 is 0:
     Y2÷9Êi        # And if `Y` integer-divided by 2 is not 9:
           …Zzz    #  Output string "Zzz" instead
                   # (Implicit else:
                   #   output top of stack, which is the "Good ...")

Vea la explicación aquí para entender por qué ”‚¿”es "bueno"; '•´es "mañana"; '¯âes "tarde"; y 'žÖes "tarde".

Noether, 106 bytes

"Good "~g{2D~d5>d12<&}{g"morning"+P}d{11>d18<&}{g"afternoon"+P}d{17>d20<&}{g"evening"+P}d{20>d6<&}{"Zzz"P}

Pruébalo en línea!

El comando 2Ddevuelve la parte de hora de la hora actual y el resto es una carga de sentencias if.

Haskell, 174 bytes

import Data.UnixTime
v h|h<10="Zzz"|1>0="Good "++y h
y h|h<16="morning"|h<22="afternoon"|1>0="evening"
main=do;t<-getUnixTime;print$v$mod(div(read.show.utSeconds$t)3600+4)24

C (gcc) , 127 bytes

El único truco realmente astuto es forzar las horas unsigned intpara que pueda forzar los valores nocturnos a> 14. Como la struct tmestructura solo tiene números enteros, puedo fingir que es una matriz que se está pasando gmtime_r.

char*s[]={"morning","afternoon","evening"};t,u[9];f(){t=time(0);gmtime_r(&t,u);printf(u[2]-6U>13?"Zzz":"Good %s",s[u[2]/6-1]);}

Pruébalo en línea!

J, 65 bytes

Otro puerto de la respuesta de TFeld.

('Zzz','Good '&,&>;:'morning afternoon evening'){~<.6%~20|3{6!:0''

• 3{6!:0'' obtiene la hora, que es el índice 3 del vector de tiempo actual, del valor incorporado 6!:0''
• <.6%~20| es el piso de ((mod de hora 20) dividido por 6)
• úselo como índice {~en una matriz de caracteres de 4x14 que contiene los saludos.
• ahorrar unos cuantos caracteres mediante la concatenación ( ,) la cadena Gooda las palabras morning, afternoony eveningque se dividen en los espacios en blanco por el J "palabras" tokenizer ( ;:). Técnicamente es para tokenizar las oraciones J, pero dado que J tiene palabras simples, termina dividiéndose en espacios en blanco.