Stampa le date di tutte le domeniche nel 2017 nel seguente formato: dd.mm.yyyy.
Uscita prevista:

01.01.2017
08.01.2017
15.01.2017
22.01.2017
29.01.2017
05.02.2017
12.02.2017
19.02.2017
26.02.2017
05.03.2017
12.03.2017
19.03.2017
26.03.2017
02.04.2017
09.04.2017
16.04.2017
23.04.2017
30.04.2017
07.05.2017
14.05.2017
21.05.2017
28.05.2017
04.06.2017
11.06.2017
18.06.2017
25.06.2017
02.07.2017
09.07.2017
16.07.2017
23.07.2017
30.07.2017
06.08.2017
13.08.2017
20.08.2017
27.08.2017
03.09.2017
10.09.2017
17.09.2017
24.09.2017
01.10.2017
08.10.2017
15.10.2017
22.10.2017
29.10.2017
05.11.2017
12.11.2017
19.11.2017
26.11.2017
03.12.2017
10.12.2017
17.12.2017
24.12.2017
31.12.2017

Python 2 , 81 byte

x=0
exec"print'%05.2f.2017'%(x%30.99+1.01);x+=7+'0009ANW'.count(chr(x/7+40));"*53

Provalo online!

Nessuna libreria di date, calcola direttamente le date. Il trucco principale è considerare il dd.mmvalore decimale. Ad esempio, 16.04.2017(16 aprile) corrisponde al numero 16.04. Il numero viene stampato formattato come xx.xxcon .2017allegato.

Il giorno e il mese vengono calcolati aritmeticamente. Ogni settimana aggiunge 7 giorni come x+=7. Prendere il xmodulo 30.99gestisce il rollover sottraendo 30.99ogni volta che il numero del giorno diventa troppo grande. Questo combina -31per ripristinare i giorni con +0.01per aumentare il mese.

Il rollover presuppone che ogni mese abbia 31 giorni. I mesi con meno giorni vengono regolati spostando xverso l'alto su determinati numeri settimanali con +[8,8,8,17,25,38,47].count(x/7). Questo elenco mostra i numeri delle settimane che terminano in questi brevi mesi, 8triplicati perché febbraio è inferiore di 3 giorni a 31.

Questo elenco può essere compresso in una stringa prendendo i valori ASCII più 40. Lo spostamento di +40potrebbe essere evitato usando caratteri non stampabili, e si potrebbe accedere più brevemente come oggetto byte in Python 3.

PHP, 48 byte

while($t<53)echo gmdate("d.m.2017
",605e3*$t++);

PHP, 46 byte (per offset UTC non negativi)

while($t<53)echo date("d.m.2017
",605e3*$t++);

Python 2 , 90 79 byte

-5 byte con l'aiuto di xnor (evitare di contare le settimane stesse)
-1 byte grazie a xnor (aggiungere nuovamente in e per 605000 come 605e3)

from time import*
i=0
exec"print strftime('%d.%m.2017',gmtime(i));i+=605e3;"*53

Provalo online!

0secondi dall'epoca sono le 00:00:00 del 1 ° gennaio 1970, che, come il 2017, non è stato un anno bisestile. 605000secondi è 1 settimana, 3 minuti, 20 secondi. L'aggiunta di 52 di queste "settimane" non ci porta oltre la mezzanotte.

Bash + coreutils, 44 byte

seq -f@%f 0 605e3 32e6|date -uf- +%d.%m.2017

può salvare 2 byte -use si assume GMT

• Grazie a Digital Trauma sottolinea il -fparametro per il datequale salva 10 byte;
• E utilizzare 2017 in formato stringa consente di risparmiare più byte quale idea proviene dalla risposta data dall'utente63956

• @0 è 1970-1-1
• 605000è di una settimana ( 604800) più 200 sec
  • 200 sec. dovrebbe funzionare solo perché ci sono solo 52 settimane in un anno
• @32000000 è poco più di un anno

PowerShell, 51 47

0..52|%{date((date 2017-1-1)+7.*$_)-u %d.%m.%Y}

Abbastanza semplice. 01/01/2017 è una domenica, quindi è ogni sette giorni seguenti. Possiamo salvare due byte se abbiamo solo bisogno che lo script funzioni nella mia vita:

0..52|%{date((date 17-1-1)+7.*$_)-u %d.%m.%Y}

Excel VBA 106 91 79 byte

Sub p()
For i = #1/1/2017# To #12/31/2017#
If Weekday(i) = 1 Then MsgBox i
Next
End Sub

salvato 15 byte grazie a @Radhato

Supponendo che l'1 / 1/2017 sia domenica, si risparmieranno altri 12 byte.

Sub p()
For i = #1/1/2017# To #12/31/2017#
MsgBox i
i = i + 6
Next
End Sub

Grazie @Toothbrush 66 byte

Sub p:For i=#1/1/2017# To #12/31/2017#:MsgBox i:i=i+6:Next:End Sub

Modifica: (Sub e End Sub non necessari) 52 byte

For i=#1/1/2017# To #12/31/2017#:MsgBox i:i=i+6:Next

PHP, 67 byte

Usando il fatto che PHP assegna automaticamente il valore 1 a variabili di ciclo non dichiarate e utilizzando i tempi di Linux,

<?php for(;54>$t+=1;)echo date("d.m.Y\n",604800*($t)+1482624000);?>

k6, 32 byte

`0:("."/|"."\)'$2017.01.01+7*!53

Breve spiegazione:

                2017.01.01+7*!53 /add 0, 7, 14, ..., 364 to January 1st
   ("."/|"."\)'$                 /convert to string, turn Y.m.d into d.m.Y
                                 /   split by ".", reverse, join by "."
`0:                              /output to stdout (or stderr), line by line

Purtroppo, questo sembra funzionare solo nell'interprete a sorgente chiuso e solo su richiesta.

Pyke , 26 24 byte

53 Fy17y"RVs6)c"%d.%m.%Y

Provalo online!

53 F                     - for i in range(53):, printing a newline between each
    y17y"                -  Create a time object with the year 2017. (Month and days are initialised to 1.)
         RV  )           -  Repeat i times:
           s6            -   Add 1 week
              c"%d.%m.%Y -  Format in "dd.mm.yyyy" time

O 11 byte

Se consentito ignorare il formato di output

y17y"52VDs6

Provalo online!

y17y"       - Create a time object with the year 2017. (Month and days are initialised to 1.)
     52V    - Repeat 52 times:
        D   -  Duplicate the old time
         s6 -  Add 1 week

R, 79 67 58 byte

cat(format(seq(as.Date("2017/01/01"),,7,53),"\n%d.%m.%Y"))

Il primo gennaio, domenica, questo frammento crea una sequenza di giorni, ogni 7 giorni a partire dal 01-01-2017 al 31-12-2017, formattandoli nel formato desiderato e stampandoli.

Befunge-98 (PyFunge) , 99 95 93 85 byte, Newline finale di foglie

Tutte le ottimizzazioni sono state fatte da @JoKing grazie a loro

s :1g2/10g\%:d1p10g\`+:b`#@_:1\0d1g#;1+:a/'0+,a%'0+,'.,j;a"7102"4k,d1g7+
>8><><>><><>

Provalo online!

Mi sentivo come se ci stessimo perdendo un po 'di esostericità qui, quindi ho trovato una soluzione nella mia lingua esosterica preferita.

Spiegazione :
>8><><>><><>Codifica la durata dei 12 mesi
sMemorizza il vecchio giorno nello spazio vuoto
:1g2/Ottieni un valore ASCII dalla riga inferiore e dividilo per due, questo ci dà la durata di un determinato mese Ex: 8 = 56 in ASCII => 56 / 2 = 28 => Il mese (febbraio) ha 28 giorni
10g\%Ottieni il giorno precedentemente salvato e modulo per la lunghezza del mese che ci consente di passare la data al mese successivo
:d1pSalva una copia del nuovo giorno aggiornato
10g\`+Prova se la vecchia data > nuova data => siamo passati al mese successivo => aggiungi 1 al contatore del mese
:b`Test se il contatore del mese> 11 significa che abbiamo raggiunto la fine dell'anno (usando l'indicizzazione 0)
#@_Basato sul precedente se termina il programma
:1\0d1gRiordina lo stack quindi sembra così:Month, 1, Month, 0, Day
#salta la prossima istruzione (duh)
1+:a/'0+,a%'0+,'.,Converti il ​​numero in 1 indicizzazione, stampa, aggiungi .a alla fine
j;Usa lo 0 dalla pila per non saltare e usa il ;per andare di nuovo al programma di stampa quindi usa il 1 per saltare al ;successivo time
a"7102"4k,Stampa 2017\n
d1gOttieni nuovamente il valore del giorno 7+Aggiungi una settimana prima di ripetere

JavaScript, 111 106 byte

for(i=14833e8;i<1515e9;i+=605e6)console.log(new Date(i).toJSON().replace(/(....).(..).(..).*/,'$3.$2.$1'))

Nota: la console di Stack Exchange non è abbastanza lunga per visualizzare l'intero elenco, quindi ecco la prima metà come snippet separato:

for(i=14833e8;i<15e11;i+=605e6)console.log(new Date(i).toJSON().replace(/(....).(..).(..).*/,'$3.$2.$1'))

Il formato personalizzato mi costa 40 byte ...

Perl 5 , 64 byte

use POSIX;print strftime"%d.%m.%Y\n",0,0,0,7*$_+1,0,117for 0..52

Provalo online!

Il compito assegnato era il 2017, non ogni anno, quindi ho scritto:

• 117 (che è perlish per l'anno 2017, 1900 + 117)
• +1 perché il 1 ° gennaio è una domenica nel 2017
• 0..52 perché il 2017 ha 53 domeniche

POSIX è un modulo principale ed è sempre installato con Perl5. Fare lo stesso senza usare moduli in 101 byte, rimuovendo gli spazi bianchi:

$$_[5]==117&&printf"%02d.%02d.%d\n",$$_[3],$$_[4]+1,$$_[5]+1900
  for map[gmtime(($_*7+3)*86400)],0..1e4

Rubino, 75 byte

Soluzione semplice per capire le date con Time.

t=Time.new 2017
365.times{puts t.strftime("%d.%m.%Y")if t.sunday?
t+=86400}

SAS, 52 50 byte

Salvato 2 byte grazie a @ user3490.

data;do i=20820to 21184 by 7;put i ddmmyyp10.;end;

Mathematica 90 84 byte

Abbastanza prolisso. numbermaniac e Scott Milner hanno salvato rispettivamente 5 e 1 byte.

Column[#~DateString~{"Day",".","Month",".","Year"}&/@DayRange["2017","2018",Sunday]]

VBA, 81 byte (forse 64)

Sub p()
For i = 0 To 52
MsgBox format(42736 + i * 7, "dd.mm.yyyy")
Next i
End Sub

Il mio primo post Basandosi sulla soluzione di newguy rimuovendo il controllo per i giorni feriali e specificando solo ogni 7 giorni. La rimozione delle date consente di risparmiare 12 byte al pezzo. 42736 è l'1 / 1/2017. Il formato della data di uscita dipende dall'impostazione del sistema. È permesso? In tal caso, sono 64 byte perché non è necessario il metodo di formattazione .

MsgBox #1/1/2017# + i * 7

AHK , 67 byte

d=20170101
Loop,52{
FormatTime,p,%d%,dd.MM.yyyy
Send,%p%`n
d+=7,d
}

Qui non succede nulla di magico. Ho provato a trovare un mezzo più corto di FormatTime ma non ci sono riuscito.

Java 8+, 104 100 99 byte

()->{for(int t=0;t<53;)System.out.printf("%1$td.%1$tm.2017%n",new java.util.Date(t++*604800000L));}

Java 5+, 109 105 104 byte

void f(){for(int t=0;t<53;)System.out.printf("%1$td.%1$tm.2017%n",new java.util.Date(t++*604800000L));}

Utilizza le funzionalità di data del printfformato.

Provalo tu stesso!

risparmi

1. 104 -> 100: modificato i valori di loop e il multiplicando.
2. 100 -> 99: golf il ciclo

T-SQL, 94 byte

DECLARE @ INT=0,@_ DATETIME='2017'W:SET @+=1SET @_+=7PRINT FORMAT(@_,'dd.MM.yyy')IF @<52GOTO W

se non ti piace SQL GOTO o WHILE, ecco una soluzione CTE da 122 byte

WITH C AS(SELECT CAST('2017'AS DATETIME)x UNION ALL SELECT x+7FROM C WHERE X<'12-31-17')SELECT FORMAT(x,'dd.MM.yyy')FROM C

Rubino, 60 + 7 = 67 byte

Usa la -rdatebandiera.

(d=Date.new 1).step(d+365,7){|d|puts d.strftime"%d.%m.2017"}

Groovy, 81 77 63 60 56 byte

d=new Date(0);53.times{printf('%td.%<tm.2017%n',d);d+=7}

Quanto sopra può essere eseguito come script groovy.

Il mio primo codice golf entry. Fortunatamente, l'anno 1970 non è stato un anno bisestile, quindi può usarlo come base.

Grazie a Dennis, ecco un: provalo online!

C #, 138 111 102 byte

Hai salvato altri 9 byte grazie a Johan du Toit !

Salvato 27 byte grazie ai suggerimenti di Kevin Cruijssen !

()=>{for(int i=0;i<53;)Console.Write(new DateTime(2017,1,1).AddDays(7*i++).ToString("dd.MM.yyyy\n"));}

Funzione anonima che stampa tutte le domeniche nel 2017.

Programma completo con metodo ungolfed:

using System;

class P
{
    static void Main()
    {
        Action f =
        ()=>
        {
            for (int i = 0; i < 53; )
                Console.Write(new DateTime(2017, 1, 1).AddDays(7 * i++).ToString("dd.MM.yyyy\n"));
        };



        f();
    }
}

C #, 110 109 byte

using System;()=>{for(int i=42729;i<43100;Console.Write(DateTime.FromOADate(i+=7).ToString("dd.MM.yyy\n")));}

Puoi goderti questo programma online qui

In questa soluzione noi:

• Utilizzare OLE Automation Date (OADate) per evitare "AddDay ()" da datetime.
  FromOADate()sembra grande ma è uguale anew DateTime(2017,1,1)

• Avvia il loop nell'ultima domenica del 2016. per consentirci di incrementare +=solo con l'operatore . Questo operatore restituisce il valore dopo l'incremento.

• Incrementa di 7 giorni per passare da domenica a domenica prima di stampare la data.

• Ci fermiamo una volta colpita l'ultima domenica del 2017.

• Utilizzare Debuginvece di Consoleper salvare due caratteri

• Evitare di avere dichiarazioni e assegnazioni variabili esplicite

TSQL, 112 105 byte

SELECT CONVERT(VARCHAR,DATEADD(d,number*7,42734),104)FROM master..spt_values WHERE type='p' AND number<53

dimostrazione

Sintassi di conversione T-SQL

JavaScript (ES6), 123 byte

È il mio primo post qui, ciao!

a=x=>`0${x}.`.slice(-3);[].map.call('155274263153',(x,i)=>{for(j=0;j<4+(2633>>i&1);j++)console.log(a(+x+j*7)+a(i+1)+2017)})

Questa soluzione utilizza dati hardcoded ed è progettata per funzionare in modo specifico per l'anno 2017. Non si basa su API data / ora.

Per quanto riguarda le cifre nella stringa 155274263153, ogni cifra è un numero a sé stante e indica la prima domenica di ogni mese consecutivo. La produzione per l'intero anno può essere generata aggiungendo successivamente 7 a quelli.

Che dire del numero magico 2633, usato nel loop?
Bene ... 2633(decimale) è 101001001001in binario. Cosa potrebbero 1significare quelli ? A partire da destra, vengono impostati il ​​1o, 4o, 7o, 10o e 12o bit. Ciò corrisponde a mesi che hanno cinque domeniche, a differenza di quelli che ne hanno solo quattro. Golfed fino a questa espressione pulito, inizialmente si presentava così: for(j=0;j<4+ +[0,3,6,9,11].includes(i);j++).

Immagino che le parti rimanenti siano abbastanza autoesplicative.

T-SQL, 79 77 byte

Dopo aver aiutato Salman A a migliorare la sua risposta . Ho deciso di scrivere il mio usando un loop e PRINT.

Ho finito con questa soluzione da 90 byte.

DECLARE @d DATETIME=42734 WHILE @d<43100BEGIN PRINT CONVERT(VARCHAR,@d,104)SET @d=@d+7 END

Quindi ho esaminato l'attuale leader in T-SQL che era 94 byte da TUTTO TUTTO con questa risposta . Questo ragazzo aveva trovato degli ottimi trucchi.

1. Nomina solo la variabile @
2. Esegui il ciclo con GOTOanziché LOOP reale
3. Salva un personaggio usando FORMATinvece di CONVERT. (Solo SSMS2012 +)

Usando questi trucchi, questa soluzione è stata ridotta alla soluzione sottostante che è 79 byte.

DECLARE @ DATETIME=42734G:PRINT FORMAT(@,'dd.MM.yyy')SET @+=7IF @<43100GOTO G

Ottava , 37 byte

Molto più breve di tutte le altre lingue non golf, ed è persino legato a Jelly! Ben fatto Octave! :)

disp(datestr(367:7:737,'DD.mm.2017'))

Provalo online!

Fortunatamente, l'anno 2 ADsembra esattamente lo stesso dell'anno 2017 AD. Entrambi iniziano e finiscono di domenica, e nessuno dei due è un anno bisestile. Ciò consente di risparmiare molti byte, poiché 367:7:737è un po 'più breve di 736696:7:737060.

Questo converte il numero di giorni da allora 01.01.0001, in una stringa sul formato DD.mm, con un finale .2017.

Haskell , 133 130 byte

import Data.Time.Calendar
((\[f,g,h,i,j]->i:j:'.':f:g:".2017\n").drop 5.show)=<<take 53(iterate(addDays 7)$fromGregorian 2017 1 1)

Provalo online!

Senza una libreria di calendari, 148 144 140 byte

(\l->last l!l++length l!l++"2017\n").fst.span(>0).(<$>scanl((+).(+28))0[3,0,3,2,3,2,3,3,2,3,2]).(-)=<<[1,8..365]
a!_=['0'|a<=9]++show a++"."

Questo è divertente poiché l'uso di un operatore per la funzione di riempimento consente di risparmiare due byte anche se il secondo argomento non è utilizzato, poiché sono necessarie meno parentesi - p(last l)è più lungo di last l!l. Funziona calcolando le day/monthcoppie sottraendo le date di inizio del mese cumulative dal giorno dell'anno. Le date di inizio del mese sono compresse come ( scanl((+).(+28))0[3,0,3,2,3,2,3,3,2,3,2]). Il numero del mese è il numero di elementi positivi e il numero del giorno è l'ultimo elemento positivo.

Provalo online!

C #, 116 114 113 byte

for(long i=(long)636188256e9;i<636502857e9;i+=(long)605e10)Out.Write(‌​new DateTime(i).ToString("dd.MM.yyyy\n"));

Può essere eseguito nelle finestre interattive di Visual Studio (o in qualsiasi altro REPL C # basato su Roslyn)

Fino a 113 byte: grazie a Kevin Cruijssen.