Adori il pranzo. Tuttavia, sei a dieta e vuoi assicurarti di non pranzare accidentalmente il pranzo due volte in un giorno. Quindi è necessario creare un programma per aiutarti a essere sicuro.

Tuttavia, una complicazione è che pranzi in un programma molto strano. L'ora in cui pranzi è il MESE: GIORNO PM (puoi utilizzare UTC o il fuso orario localizzato). Esatto, se il giorno è il 14 luglio , pranzerai alle 19:14 .

Per il tuo programma, devi utilizzare la data e l'ora correnti (non accettare input) e generare un valore di verità costante se hai già pranzato per il giorno (o è ora di pranzo ora) o un valore di falsa coerente se non l'hai fatto.

Esempi: (ora in cui si esegue program => output)

• 4 maggio 11:35 => false (pranzerai alle 17:04)
• 3 giugno 17:45 => falso (pranzerai alle 18:03)
• 28 luglio 20:30 => vero (hai pranzato alle 19:28)
• 15 dicembre 15:25 => vero (hai pranzato alle 12:15)
• 29 febbraio 14:29 => true (è esattamente l'ora di pranzo)
• 12 ottobre 12:00 AM => false (giornata appena iniziata)

Riferimento:

Come funziona un orologio a 12 ore

Swift 3 , 310 byte

import Foundation;var n=String(describing:Date());var k=n.startIndex;print(Int(n[n.index(k,offsetBy:5)...n.index(k,offsetBy:6)])!*60+Int(n[n.index(k,offsetBy:8)...n.index(k,offsetBy:9)])!+720<=Int(n[n.index(k,offsetBy:11)...n.index(k,offsetBy:12)])!*60+Int(n[n.index(k,offsetBy:14)...n.index(k,offsetBy:15)])!)

Controlla!

Questo stampa truee false, rispettivamente, per verità e falsità.

NOTA : Funziona solo fino all'anno 9999, alle 23:59:59, perché utilizza le stringhe per confrontare le date.

05AB1E , 15 18 byte

žežb‚žf12+ža‚т*+`‹

Provalo online!

Spiegazione

žežb‚žf12+ža‚т*+`‹
že                 # Push current day
  žb               # Push current minute
    ‚              # Wrap to array
     žf12+         # Push current month and add 12 to it
       ža          # Push current hour
         ‚         # Wrap these two to array as well
          т*       # Multiply each element in the second array by 100
            +      # Add both arrays together
             `     # Flatten the resulting array to stack
              ‹    # Is the first item smaller than the second one?

Ottava , 61 byte

diff(str2num([(d=datestr(now,'mmddHHMM'))(1:4);d(5:8)]))>1200

Provalo online!

Spiegazione:

Innanzitutto le funzioni:

• now()restituisce l'ora in un formato decimale. Le parentesi sono opzionali.
• datestr converte un numero decimale in una stringa nel formato indicato nel secondo argomento
• str2num converte una stringa in un numero
• diff prende la differenza tra due numeri

Abbattersi:

Prendiamo questo dalla metà:

diff(str2num([(d=datestr(now,'mmddHHMM'))(1:4);d(5:8)]))>1200

datestr(now,'mmddHHMM'): Per prima cosa prendiamo l'ora corrente nowcome input datestre specifichiamo il formato mmddHHMM. Le lettere significano: mm = month, dd = day, HH = hour, MM = minutese AMspecifica che le ore dovrebbe essere su un formato a 12 ore. Nessun separatore incluso, per mantenerlo il più corto possibile. Emette d = 07142117al momento della stesura di questa spiegazione. Mi riferirò a quella parte a partire xda ora.

[(d=x)(1:4);d(5:8)]: Memorizza la stringa sopra, come d, quindi crea un array con due elementi, i primi quattro caratteri, quindi i 5-9 caratteri. Questo dà :

ans =
0714
2122

Dove i numeri sono memorizzati come stringhe, non numeri. Chiameremo il risultato sopra per ysotto.

str2num(y)converte la matrice di caratteri in numeri, dove ogni riga si trasforma in un numero. Questo dà [714; 2122]. Chiameremo il risultato per z.

diff(z)>1200prende la differenza tra i due numeri e verifica se l'ora corrente è 1200 in più rispetto alla data corrente. Questo spiega AM / PM. Questo ci dà il risultato desiderato.

Pyth, 22 21 20 byte

<0+g.d7.d5-.d6+12.d4

-1 byte grazie a @ Mr.Xcoder

Prova questo!

vecchio approccio, 22 20 byte

<+`+12.d4.d5+`.d6.d7

Provalo!

spiegazione

<0+g.d7.d5-.d6+12.d4
              +12.d4   # Add 12 to the current month to make it PM
          -.d6         # subtract that from the current hour: negative it is too early,
                       # positive when it is past this hour, zero when its the same hour
   g.d7.d5             # Is the minute greater or equal than the day? True=1; False=0
  +                    # Add this to the hour result,
                       # so that 0 can turn positive if minutes are true
<0                     # Is the result larger than 0 ?

C #, 174 byte

using System;public class Program{public static void Main(){Console.WriteLine(DateTime.Now>DateTime.Today.AddHours(DateTime.Today.Month+12).AddMinutes(DateTime.Today.Day));}}

Provalo online!

PHP e altre lingue con queste funzioni comuni: da 28 a 29 byte circa:

echo eval(date('Gi-1199>md')); 

o in alternativa

<?=eval(date('Gi-1199>md'))?>

entrambi verranno stampati.

possibilmente con a ?1:0seconda della rappresentazione. Forse i byte vengono tagliati se viene utilizzata una lingua con eco implicito o nessun ';' finale.

Perché uno dovrebbe ottenere i valori in variabili e tutto il resto, quando non è necessario :)
date()lascia nulla come letterali che non è definito, quindi ad esempio 7 May 2017 17:22:43passa l'espressione 1722 - 1200 >= 507a eval (). Byte salvato modificandolo in equivalente 1722 - 1199 > 507.

Chi dice che eval sia morto? ;-)

Java, 81 byte

n->new Date().after(new Date(){{setHours(getMonth()+13);setMinutes(getDate());}})

Provalo online!

Ungolfed:

n -> new Date().after(new Date() { //new Date() returns current date
    { //instance initialization
        setHours(getMonth() + 13); //month + 12 hours for PM + 1 because months are 0 indexed
        setMinutes(getDate()());
    }
})

Haskell, 135 129 byte

import Data.Time
x(ZonedTime(LocalTime d(TimeOfDay h m _))_)|(_,x,y)<-toGregorian d=return(mod x 12<h-12&&y<m)
y=getZonedTime>>=x

questo disimballaggio è abbastanza fastidioso, forse la gestione delle stringhe è più adatta

// edit: pattern guards sicuro 5 byte

Mathematica, 65 64 62 byte

3 programmi

p=Date[][[#]]&;{60,1}.#&/@(p[4;;5]>=p[2;;3]+{12+p@2~Mod~12,0})

{60,1}.#&/@(#[[4;;5]]>=#[[2;;3]]+{12+#[[2]]~Mod~12,0})&@Date[]

{60,1}.#&/@(#[4;;5]>=#[2;;3]+{12+#@2~Mod~12,0})&[Date[][[#]]&]

Questi sono ciascuno con un byte in meno se ≥contano come un singolo byte in Mathematica.

spiegazioni

1. Date[]restituisce un elenco nel modulo {y,m,d,h,m,s}. Così Date[][[4;;5]]sono le ore e i minuti dell'ora corrente.
2. p=Date[][[#]]&;fa puna funzione che accetta gli indici che vogliamo e ci dà quelle parti della data.
3. {60,1}.#&è una funzione anonima che utilizza il prodotto punto {60,1}e l'input per ottenere un modo per confrontare i tempi. È un byte più corto di TimeObject.
4. p@2è equivalente a p[2], il numero del mese.
5. +{12+p@2~Mod~12,0}aggiunge {12,0}il mese e la data in cui non siamo a dicembre e aggiunge {0,0}diversamente. (Grazie, michi7x7!)
6. >= è l'operatore di confronto, ma non possiamo confrontare {ora, minuti} con {mese, data} rettificati ...
7. /@è mappato {60,1}.#&su entrambi i lati della disuguaglianza tra parentesi, in modo da poter confrontare correttamente i tempi.
8. Per i programmi che iniziano con {60,1}.#&, usano #per rappresentare l'input per una grande funzione anonima e &per indicare la fine.
9. @Date[] Applica la grande funzione sulla sua riga (che estrae parti di un elenco) all'elenco date stesso.
10. [Date[][[#]]&] Applica la grande funzione sulla sua linea a un'altra funzione anonima, che estrae parti dell'elenco di date.

indennità

A parte questo, se pranzassimo tra l'una e le 12:59, potremmo risparmiare 25 byte con solo {60,1}.#&[Date[][[#]]]&/@(4;;5>=2;;3).

Puoi testarli tutti incollando il codice nella sandbox di Wolfram Cloud e facendo clic su Gear-> Valuta cella o premendo Maiusc + Invio o Invio tastierino numerico.

JavaScript (ES6), 75 byte

f=
(d=new Date)=>(d.getHours()-d.getMonth()-13||d.getMinutes()-d.getDate())>=0

<input type=button value=Lunch? onclick=o.textContent=f()><tt id=o>

Quei nomi lunghi di funzioni ...

Python 3 , 104 byte

from datetime import*
n=datetime.now();print(n>=n.replace(hour=[0,n.month+12][n.month<12],minute=n.day))

Provalo online!

Tutti i test del datetime. Ho sostituito il 29 febbraio con il 28 febbraio perché la data non valida non funzionava.

R , 92 byte

library(lubridate)
d=Sys.Date()
cat(Sys.time()>ymd_hm(paste0(d,'-',month(d)+12,'-',day(d))))

Provalo online!

                                   month(d)+12,'-',day(d)    # get month and day and paste into a string, adding 12 hours for pm
                      paste0(d,'-',                      )   # add current date to beginning
               ymd_hm(                                    )  # turn whole thing into a date-time object
cat(Sys.time()>                                            ) # compare with current date-time and print

q, 31 byte

x>12:+"T"$(-3!x:.z.P)5 6 13 8 9

Esempio:

q).z.P
2017.07.16D19:35:26.654099000
q)x>12:+"T"$(-3!x:.z.P)5 6 13 8 9
1b

L'interprete è disponibile qui

Vecchia versione

{x:.z.p;x>"T"$":"sv"0"^2$/:string 12 0+`mm`dd$\:x}`

JavaScript, 75 byte

t=new Date,t.setHours(13+t.getMonth()),t.setMinutes(t.getDate()),new Date>t

Che equivale al seguente codice:

function didEat()
  const d = new Date()
  d.setHours(12 /* PM */ + d.getMonth() + 1)
  d.setMinutes(d.getDate())
  return new Date > d
}
didEat()

Python 2.7, 130 byte

from datetime import*
a=str(datetime.now()).split()
print int(''.join(a[0].split('-')[1:]))+1200<int(''.join(a[1].split(':')[:2]))

Provalo online

Nota: potrebbe esserci un problema con il segno. Per favore, mi scuso perché seguo IST ed è abbastanza confuso perché sono le 2:28 qui. Correggi il segno se ritieni che sia sbagliato.

Perl, 45 caratteri

sub c{@a=gmtime;$a[2]-12>$a[4]&&$a[1]>=$a[3]}

Se devo fornire un metodo, sarà 45 per sub c{...}. Se devo stampare say ()||0lo rende anche 47. Lo aggiungerò se è un requisito.

Excel, 52 50 49 byte

=TIME(MONTH(NOW())+12,DAY(NOW()),0)<=MOD(NOW(),1)

L'input è questa formula in qualsiasi cella.
L'output è TRUEo FALSE.

La gestione della data integrata di Excel aiuta molto.
La TIMEfunzione restituisce l'ora del pranzo del giorno come valore orario che, se convertito in una data, verrebbe utilizzato Jan 0, 1900. Lo confrontiamo in NOW - TODAYmodo da ottenere l'ora corrente con un valore di data di 0o Jan 0, 1900.

_{Salvato 2 byte grazie a Wernisch}
^{Salvato 1 byte grazie ad Adam}

JavaScript, 62 caratteri

f=
_=>[,m,d,H,M]=(new Date).toISOString().split(/\D/),+m+12+d<=H+M

Codice di prova di seguito:

console.log(( // May 4, 5:03 PM, false (1 minute before lunch)
  [,m,d,H,M]=(new Date("2017-05-04T17:03Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

console.log(( // May 4, 5:04 PM, true (exact time)
  [,m,d,H,M]=(new Date("2017-05-04T17:04Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

console.log(( // May 4, 5:05 PM, true (1 minute after)
  [,m,d,H,M]=(new Date("2017-05-04T17:05Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

Excel VBA, 55 byte

Funzione di finestra immediata VBE anonima che non accetta input e genera un valore booleano che indica se ho pranzato alla finestra immediata VBE

n=Now:?TimeValue(n)>TimeValue(Month(n)&":"&Day(n)&"PM")

Rubino , 64 + 7 = 71 byte

Richiede il -rtimeflag perché per qualche motivo Time::parseè come, l'unica funzione lo richiede dall'intero Timemodulo.

p Time.parse("#{t=Time.now}"[/.+-(..)-(..) /]+[$1,$2]*?:+'pm')<t

Provalo online! (stampa anche l'ora corrente)

Julia 0.6.0 99 byte

a=split(string(Dates.today()),"-");(Dates.hour(now())<parse(a[2]))&&Dates.minute(now())<parse(a[3])

Julia ha una funzione integrata per utilizzare l'orologio / calendario del computer. Il mio computer è in esecuzione su Ubuntu 16.04 e già con l'orologio a 12 ore, quindi non posso dire se quello che ho fatto funziona con un'altra macchina usando un orologio diverso, ma sembra funzionare sulla mia macchina.

JavaScript ES6, 70 byte

_=>(h=x=>new Date().toJSON().substr(x,5).replace(/\D/,0))(5)+12e3<h(11)

Forse non proprio in alcuni millisecondi ...

Matlab, 241 byte

dt=datestr(now,'mm/dd');
dt(2)
dt(4:5)
CrctLchTm=[' ' dt(2) ':' dt(4:5) ' PM']
CrntTm=datestr(now,'HH:MM PM')
CrntTm(7)=='A'
if ans==1
    Lch='false'
else
    CrctLchTm=str2num([CrctLchTm(2) CrctLchTm(4:5)])
    CrntTm=str2num([CrntTm(2) CrntTm(4:5)])
    CrntTm<CrctLchTm
    if ans==1
        Lch='false'
    else
        Lch='true'             
    end    
end

Spiegazione: Innanzitutto, ottengo la data come stringa. Quindi, isola il mese e il giorno. Poiché il problema afferma che viene sempre interpretato come PM, allora scrivo automaticamente falso se l'ora è in AM. Se l'ora corrente è in PM, allora continuo e confronto solo i numeri dell'ora.

Nota: l'ho formattato in modo leggermente diverso qui per leggibilità.