Una data può essere rappresentata da un numero intero senza segno in quanto tale: AAAAMMGG. Quello che devi fare è scrivere il programma o la funzione più breve che individua la data più recente il cui numero era divisibile per un determinato numero n(compresa la data di oggi) e quindi restituisce quella data nel formato mostrato sopra. Se non c'è mai stata una data (tra 00000101 e oggi incluso) divisibile per l'intero dato, dovresti restituire -1.

Esempi

Current Date     Input     Output

30 July, 2014      4       20140728
30 July, 2014      7       20140729
28 July, 2014      4       20140728
28 July, 2014      7       20140722
28 July,    5    90000     -1

Ingresso

È possibile leggere da STDIN o accettare un argomento di funzione o addirittura aspettarsi che l'input sia archiviato in una variabile. L'input sarà un numero intero senza segno.

Produzione

Scrivi a STDOUT o restituisci (o salva in una variabile) il numero intero che rappresenta la data nel formato AAAAMMGG.

restrizioni

È possibile utilizzare qualsiasi libreria standard offerta dalla propria lingua. Si applicano scappatoie standard .

Condizioni vincenti

Questo è un code-golf , quindi vince il programma più piccolo (in byte). In caso di pareggio, vince la risposta con il maggior numero di voti.

Mathematica, 93 60 byte

For[i=0,(r=DatePlus@i--~FromDigits~100)>0&&!n∣r,];r~Max~-1

Si aspetta che l'input venga archiviato n.

Nota che la linea verticale ∣è il carattere unicode per "divide", che ho contato come 3 byte (UTF-8).

Modifica: trovato un trucco per evitare le DateStringspecifiche gonfiate e di formato :).

Modifica: totalmente dimenticato il -1requisito. Riparato ora.

Ecco una spiegazione

For[i=0,            i--                        ,];         (* i is the number of days AFTER
                                                              today. Hence, we decrement 
                                                              it. *)
For[i=0,   DatePlus@i--                        ,];         (* If no reference date is
                                                              provided, DatePlus will add
                                                              the given number of days to
                                                              today's date. The result is a 
                                                              list of 3 integers, luckily 
                                                              in order {year,month,day} *)
For[i=0,   DatePlus@i--~FromDigits~100         ,];         (* Interpret these as the digits
                                                              of a base 100 number. The 
                                                              beauty is that FromDigits
                                                              doesn't care about digits 
                                                              greater than the base and 
                                                              just carries them over. *)
For[i=0,(r=DatePlus@i--~FromDigits~100)        ,];         (* Store the number in r. *)
For[i=0,(r=DatePlus@i--~FromDigits~100)>0      ,];         (* Make sure it's positive. *)
For[i=0,(r=DatePlus@i--~FromDigits~100)>0&&!n|r,];         (* And keep going while n does 
                                                              not divide r. *)
For[i=0,(r=DatePlus@i--~FromDigits~100)>0&&!n|r,];r~Max~-1 (* Clamp result to -1. *)

Nota che l'ho usato |invece che ∣nella spiegazione, perché quello Unicode fa casino con il monospacing.

Python 2 - 150

import datetime as d,re
def f(n):
 t=d.date.today()
 while t:
    c=int(re.sub("-","",str(t)))
    if c%n<1:return c
    try:t-=d.timedelta(1)
    except:return-1

Grazie @ chill0r per il suggerimento di rimuovere giorni =, e Jason S per il suggerimento che il blocco try può essere ridotto a una riga.

C # 136

Con le specifiche riviste, una funzione che accetta un int senza segno e restituisce un int.

int F(uint n){var d=System.DateTime.Now;int i;try{while((i=int.Parse(d.ToString("yyyMMdd")))%n>0)d=d.AddDays(-1);}catch{i=-1;}return i;}

152 caratteri con input / output variabili

Sfruttando i requisiti di input / output sciolti, l'input deve essere memorizzato nella variabile n(attualmente contando tutti i caratteri tranne il valore letterale intero) e l'output viene fornito con la variabile s.

class P{static void Main(){var n=4;var d=System.DateTime.Now;string s;try{while(int.Parse(s=d.ToString("yyyMMdd"))%n>0)d=d.AddDays(-1);}catch{s="-1";}}}

204 caratteri con STDIN / STDOUT:

using System;class P{static void Main(){int n=int.Parse(Console.ReadLine());var d=DateTime.Now;string s;try{while(int.Parse(s=d.ToString("yyyMMdd"))%n>0)d=d.AddDays(-1);}catch{s="-1";}Console.Write(s);}}

T-SQL (2012) - 148

Suppone che ci sia una variabile libera @n con il valore n.

declare @ date=getdate()while convert(char,@,112)%@n>0 and'00010101'<@ set @=dateadd(d,-1,@)print iif(convert(char,@,112)%@n=0,convert(char,@),'-1')

Golflua 90 86

n=I.r()d="%Y%m%d"i=O.d(d)+0j=0@i>0?i%n==0w(i)O.q()$j=j+1i=O.d(d,O.t()-j*86400)+0$w(-1)

Una versione di Lua ungolfed sarebbe,

n = io.read()
d = "%Y%m%d"
i = os.date(d)+0   -- implicitly casts os.date(d) to int
j = 0
while i>0 do
   if i % n == 0 then
      print(i)
      os.exit()
   end
   j = j+1
   i = os.date(d,os.time()-j*86400)+0
end
print(-1)

MATLAB: 61

-1,s=str2num(datestr(1:now,'YYYYmmDD')),d=s(~mod(s,n)),d(end)

Presuppone che il divisore sia archiviato n. Il risultato verrà memorizzato in una variabile chiamata ans.

Versione commentata:

-1                                     % Store -1 in ans in case we don't find anything
s=str2num(datestr(1:now,'YYYYmmDD'))   % Make a list of date numbers
d=s(~mod(s,n)),                        % Select only those who are dividable and prepend -1
d(end)                                 % Store last found value in ans, if anything is found

Genererà un errore se non viene trovato alcun risultato, ma la risposta è ancora disponibile nella variabile nonostante ciò.

L'errore potrebbe essere evitato al costo di 2 caratteri extra:

s=str2num(datestr(1:now,'YYYYmmDD')),d=[-1;s(~mod(s,n))],d(end)

PHP (92 = 85 + 7)

Si aspetta che l'input venga archiviato $n.

for($d=date("Ymd");!($d%$n==0&checkdate($d/100%100,$d%100,substr($d,0,4))|$d<0);$d--);echo$d

Ho appena ricordato perché non mi piace più PHP =)

EDIT: ora anche il -1 delle specifiche è implementato.

JavaScript (ES6) 115

Si aspetta il numero nella variabile n, il risultato è memorizzato nella variabile r. Ogni giorno viene controllato, a partire dalla data corrente e dal decremento - deve esserci un modo migliore.
Inoltre, utilizzando le funzioni di data javascript standard, tutte le date sono gregoriane fino all'anno 1 (con gli anni bisestili di conseguenza errati prima della riforma gregoriana).

for(z=new Date,t=n+1;t>n&&t%n;)
  d=z.getDate(),
  t=z.getFullYear()*1e4+(z.getMonth()+1)*100+d,
  z.setDate(d-1);
r=t>n?t:-1

C # - 144 (O 124 in LINQPad) + 1 per ogni cifra in n

Questo si aspetta che l'input sia nella variabile n. Entro la fine dell'esecuzione il valore desiderato sarà nella variabile r. Questo però considera 00010101la prima data, poiché la data 00000101non esiste. Suggerimenti di miglioramento sono sempre ben accetti.

class P{static void Main(){int n=7,r;var d=System.DateTime.Now;try{for(;(r=int.Parse(d.ToString("yyyMMdd")))%n>0;d=d.AddDays(-1));}catch{r=-1;}}}

Versione LINQPad:

int n=7,r;var d=System.DateTime.Now;try{for(;(r=int.Parse(d.ToString("yyyMMdd")))%n>0;d=d.AddDays(-1));}catch{r=-1;}r.Dump();

Groovy - 301 300 caratteri

Molto semplice (e lento), senza trucchi per nascondere il fatto che utilizza Joda Time.

golfed:

@Grab(group='joda-time', module='joda-time', version='2.3')
import org.joda.time.*
import org.joda.time.format.*
f={DateTimeFormat.forPattern("yyyyMMdd").print(new LocalDate().minusDays(it)) as int}
n=args[0] as int;b=0;x=-1;c=0
while(!b){if(f(c++)%n==0){x=f(--c);b=1};if(f(0)-c<=101){b=1}}
println x

Esempio di esecuzione (il 30/07/2014):

$ groovy D.groovy  7
20140729
$ groovy D.groovy  16
20140720
$ groovy D.groovy  90000
-1

Ungolfed:

@Grab(group='joda-time', module='joda-time', version='2.3')

import org.joda.time.*
import org.joda.time.format.*

f = { DateTimeFormat.forPattern("yyyyMMdd").print(new LocalDate().minusDays(it)) as int }

n = args[0] as int
b = 0 
x = -1
c = 0

while (!b) {
    if(f(c++)%n==0) { x=f(--c); b=1}
    if(f(0)-c<=101){b=1}
}

println x

R, 146 139

D=function(n){
z=as.double(gsub("-","",y<-Sys.Date()))
d=F
while(z>100&!d){
y=y-1 
z=as.double(gsub("-","",y))
d=!z%%n}
ifelse(z>100,z,-1)}

Buona fortuna con una data che non funziona. microbenchmarkriferisce che ci vogliono circa mezzo secondo per tornare indietro di 15 giorni. Al 31 luglio 2014, ci vorranno circa 20 milioni di secondi (~ 23 giorni) per uscire -1, almeno in base al retro della busta.

modifica : alcune scorciatoie nei commenti

Matlab 104

function d=f(v);for d=fix(now):-1:1 d=str2num(datestr(d,'YYYYmmDD'));if~mod(d,v)return;end;end;d=-1;end

Ungolfed:

function d = f(v)
   for d=fix(now):-1:1
       d = str2num(datestr(d,'YYYYmmDD'));
       if ~mod(d,v)
          return; 
       end
   end
   d = -1;
end

EDIT: sono riuscito a ottimizzarlo un po ', ma @DennisJaheruddin ha la vera soluzione qui

Python 3 - 151 148 byte, generatori

from datetime import*
t=date.today()
f=lambda n:next((y for y in(int((t-timedelta(o)).strftime("%Y%m%d"))for o in range(t.toordinal()))if y%n<1),-1)

Grazie @ nyuszika7h per il import*suggerimento

Rubino 103

require'date'
f=->{d=Date.today 
(s=d.strftime('%Y%m%d').to_i
return s if s%n<1
d-=1)while d.year>0
-1}

Ingresso

Si aspetta che il valore del divisore sia presente nella variabile n.

Produzione

Il valore di ritorno della ffunzione

Esempio online: http://ideone.com/LoYxG4

Java: 373 caratteri

Questa è una porta della risposta Groovy e utilizza Joda Time.

golfed:

import org.joda.time.*;
import org.joda.time.format.*;
public class D {
static int f(int i){return Integer.parseInt(DateTimeFormat.forPattern("yyyyMMdd").print(new LocalDate().minusDays(i)));}
public static void main(String[] args){
int n=Integer.parseInt(args[0]);int b=0,c=0,x=-1;
while(b!=1){if(f(c++)%n==0){x=f(--c);b=1;};if(f(0)-c<=101){b=1;}}
System.out.println(x);}}

Esecuzioni di esempio (con joda-time-2.4.jar su classpath:

$ java D 7
20140729
$ java D 4
20140728
$ java D 16
20140720
$ java D 90000
-1

Ungolfed:

import org.joda.time.*;
import org.joda.time.format.*;

public class D {
    static int f(int i) {
        return Integer.parseInt(DateTimeFormat.forPattern("yyyyMMdd").print(new LocalDate().minusDays(i)));
    }

    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        int b = 0,c = 0,x = -1;

        while(b!=1) {
            if(f(c++)%n==0) { x=f(--c);b=1; }
            if(f(0)-c<=101) { b=1; }
        }

        System.out.println(x);
    }
}

Bash + coreutils (8.21), 67 byte

seq -f-%gday $[9**9]|date -f- +[pq]sp[_1pq]sq%Y%m%ddA1=qd$1%%0=p|dc

• seqgenera numeri interi da 1 a 9 ⁹ , uno per riga e lo formatta come-<x>day
• reindirizza questo a date -fcui interpreta ogni riga e genera la data formattata in dcun'espressione come [pq] sp [_1pq] sq 20140728 d A1 =q d 7% 0=p(spazi aggiunti per la leggibilità)
  • [pq] definire una macro per stampare la parte superiore dello stack, quindi uscire
  • sp salva macro nel registro p
  • [pq] definire una macro per premere -1, stampare la parte superiore dello stack, quindi uscire
  • sq salva macro nel registro q
  • 20140728 intero di data incorporato
  • d duplicato in cima allo stack
  • A1 push 101 (00000101)
  • =qpop top 2 valori dello stack: confronta data e 101 e chiama la macro qse uguale
  • 7 spingere il divisore
  • % pop divisore e divide, divide e spingi il resto
  • 0 spingere 0
  • =ppop top 2 valori dello stack: confronta il resto e 0 e chiama la macro pse uguale
  • d duplicato in cima allo stack
  • pviene chiamata macro : stampa il numero intero della data e si chiude dccompletamente
• dcle espressioni vengono convogliate dcper la valutazione. Una volta dcstampato il valore corretto e chiuso, il resto della pipeline viene demolito

Produzione:

$ ./lastdivdate.sh 4
20140728
$ ./lastdivdate.sh 7
20140729
$ ./lastdivdate.sh 123456
17901120
$ ./lastdivdate.sh 77777
19910912
$ ./lastdivdate.sh 7777777
-1
$ 

Poiché questo programma genera numeri interi da 1 a 9 ⁹ , sarà valido fino a poco più di 1 milione di anni nel futuro. Spero che questa limitazione sia accettabile ;-)

Grazie @ WumpusQ.Wumbley per abbreviare il ritorno di -1.

PYTHON: 134 byte

Non riuscirò a battere l'attuale leader, e non è molto meglio della migliore risposta Python, ma ho deciso di pubblicare la mia migliore soluzione Python.

from datetime import*
def y(a,n):
 s=a.strftime("%Y%m%d")
 if int(s)%n==0:yield s
 try:x=y(a-timedelta(1),n)
 except:yield -1
 yield x

Ungolfed:

from datetime import *
def y(a, n):
    s=int(a.strftime("%Y%m%d"))
    if s%n==0:
        yield s
    try:
        x=y(a-timedelta(1), n)
    except:
        yield -1
    yield x

JavaScript (ES5) - 94

Si aspetta l'input in una variabile xe inserisce l'output o.

for(i=Date.now();i>-7e13&&(o=(new Date(i)).toISOString().replace(/-|T.*/g,''))%x;i-=864e5)o=-1

k4 (84) (73)

f:{f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;.z.D];x]}

Questo è solo un taglio iniziale con il primo algoritmo che mi è venuto in mente; Sono sicuro che sia possibile migliorare sia le prestazioni che la lunghezza.

Questa versione codifica la parte "oggi" (questa è la .z.D); cambiarlo in una data letterale ( yyyy.mm.dd) o in un numero intero nel sistema q date (giorni dal 1 ° gennaio 2000) per eseguire i casi di test. (q non analizzerà i letterali delle date prima dell'inizio del XVIII secolo, quindi per le date precedenti, dovrai calcolare il valore e utilizzare direttamente l'intero appropriato. 1 gennaio, "AD 0", dalle specifiche, gira out to be -730457, che viene utilizzato nel codice funzione. Il 28 luglio 5 d.C., dall'ultimo test case, risulta essere -728450.)

I casi di test indicati:

  {f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;2014.07.30];x]}4
20140728
  {f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;2014.07.30];x]}7
20140729
  {f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;2014.07.28];x]}4
20140728
  {f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;2014.07.28];x]}7
20140722
  "d"$-728450
0005.07.28
  {f d@*|&~.q.mod[(f:{$[^x;-1;.($x)@&~"."=$x]})'d:{"d"$x+!1+"i"$y-x}[-730457;-728450];x]}90000
-1

modificare:

g:.,/$`\:`$$:;f:{$[Z=r:{(z>x)&.q.mod[g z]y}[Z:-730458;y]{x-1}/x;-1;g"d"$r]}

Si tratta di un approccio diverso che utilizza uno degli operatori di convergenza per ridurre la data fino a quando non ne trova una divisibile o attraversa il confine 1/1/0000. Fa anche la conversione da data a intero in modo leggermente diverso.

I casi di test, questa volta tutto in una volta:

  g:.,/$`\:`$$:;{$[Z=r:{(z>x)&.q.mod[g z]y}[Z:-730458;y]{x-1}/x;-1;g"d"$r]}'[2014.07.30 2014.07.30 2014.07.28 2014.07.28,"d"$-728450;4 7 4 7 90000]
20140728 20140729 20140728 20140722 -1

VBA 343 byte (modulo)

Sub divD(i As Long)
a = Now()
b = Format(a, "yyyymmdd")
    Do While b / i <> Int(b / i)
    a = DateAdd("d", -1, a)
    b = Format(a, "yyyymmdd")
        If b = "01000101" Then
            MsgBox -1
            Exit Sub
        End If
    Loop
MsgBox b
End Sub

PowerShell - 76

Ciò dipende dal numero memorizzato nella variabile $n.

try{@(0..$n|%{'{0:yyyyMMdd}'-f(date).AddDays(-$_)}|?{!($_%$n)})[0]}catch{-1}