Imprimer les dates de tous les dimanches en 2017 dans le format suivant: dd.mm.yyyy.
Production attendue:

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 octets

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

Essayez-le en ligne!

Aucune bibliothèque de dates, calcule les dates directement. L'astuce principale consiste à traiter le dd.mmcomme une valeur décimale. Par exemple, 16.04.2017(16 avril) correspond au nombre 16.04. Le numéro est imprimé au format comme xx.xxen .2017annexe.

Le jour et le mois sont calculés de façon arithmétique. Chaque semaine ajoute 7 jours terminés x+=7. Prendre xmodulo 30.99gère le roulement en soustrayant 30.99chaque fois que le nombre de jours devient trop grand. Cela se combine -31pour réinitialiser les jours avec +0.01pour incrémenter le mois.

Le roulement suppose que chaque mois a 31 jours. Les mois avec moins de jours sont ajustés en poussant xvers le haut sur certains numéros de semaine avec +[8,8,8,17,25,38,47].count(x/7). Cette liste est des numéros de semaine se terminant ces courts mois, avec 8triplé car février est 3 jours de moins que 31.

Cette liste pourrait être compressée en une chaîne en prenant des valeurs ASCII plus 40. Le décalage de +40pourrait être évité en utilisant des caractères non imprimables, et pourrait être accessible plus court en tant qu'objet d'octets en Python 3.

PHP, 48 octets

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

PHP, 46 octets (pour les décalages UTC non négatifs)

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

Python 2 , 90 79 octets

-5 octets avec l'aide de xnor (évitez de compter les semaines elles-mêmes)
-1 octet grâce à xnor (ajoutez en e pour 605000 comme 605e3)

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

Essayez-le en ligne!

0secondes depuis l'époque est 00:00:00 le 1er janvier 1970, qui, comme 2017 n'était pas une année bissextile. 605000secondes est de 1 semaine, 3 minutes, 20 secondes. Ajouter 52 de ces "semaines" ne nous prend pas au-delà de minuit.

Bash + coreutils, 44 octets

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

peut économiser 2 octets -usi GMT est supposé

• Merci Digital Trauma souligner -fparamètre pour datelequel enregistre 10 octets;
• Et utiliser 2017 dans la chaîne de format permet d'économiser plus d'octets dont l'idée provient de la réponse donnée par user63956

• @0 est 1970-1-1
• 605000est d'une semaine ( 604800) plus 200 sec
  • 200 sec. devrait juste fonctionner car il n'y a que 52 semaines par an
• @32000000 est juste un peu plus d'un an

PowerShell, 51 47

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

Assez simple. Le 01-01-2017 est un dimanche, tout comme les sept jours suivants. Nous pouvons économiser deux octets si nous avons seulement besoin que le script fonctionne de mon vivant:

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

Excel VBA 106 91 79 octets

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

économisé 15 octets grâce à @Radhato

En supposant que le 1/1/2017 est dimanche, il économisera 12 octets supplémentaires.

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

Merci @Toothbrush 66 octets

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

Modifier: (Sub et End Sub ne sont pas nécessaires) 52 octets

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

PHP, 67 octets

En utilisant le fait que PHP attribue automatiquement la valeur 1 aux variables de boucle non déclarées, et en utilisant les époques Linux,

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

k6, 32 octets

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

Brève explication:

                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

Hélas, cela ne semble fonctionner que dans l'interprète à code source fermé, sur demande uniquement.

Pyke , 26 24 octets

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

Essayez-le en ligne!

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

Ou 11 octets

Si autorisé à ignorer le format de sortie

y17y"52VDs6

Essayez-le en ligne!

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 octets

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

Le premier janvier étant un dimanche, cet extrait crée une séquence de jours, tous les 7 jours à partir du 01-01-2017 au 31-12-2017, les formate au format souhaité et les imprime.

Befunge-98 (PyFunge) , 99 95 93 85 octets, Feuilles en fin de ligne

Toutes les optimisations ont été faites par @JoKing merci beaucoup à eux

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

Essayez-le en ligne!

J'avais l'impression que nous manquions une certaine esostéricité ici, alors j'ai fait une solution dans ma langue esostérique préférée.

Explication :
>8><><>><><>Encode la durée des 12 mois
sStockez l'ancien jour dans l'espace vide
:1g2/Obtenez une valeur ASCII dans la ligne du bas et divisez-la par deux, cela nous donne la longueur d'un mois donné Ex: 8 = 56 en ASCII => 56 / 2 = 28 => Le mois (février) a 28 jours
10g\%Obtenez le jour précédemment enregistré et modulez-le en fonction de la longueur du mois, ce qui nous permet de passer de la date au mois suivant
:d1pEnregistrer une copie du nouveau jour mis à jour
10g\`+Tester si l'ancienne date > nouvelle date => nous
:b`sommes passés au mois suivant => ajouter 1 au compteur de mois Test si le compteur de mois> 11 cela signifie que nous avons atteint la fin de l'année (en utilisant l'indexation 0)
#@_Basé sur le précédent si terminer le programme
:1\0d1gRéorganiser la pile ça ressemble à ça:Month, 1, Month, 0, Day
#ignorer la prochaine instruction (duh)
1+:a/'0+,a%'0+,'.,Convertir le nombre en indexation 1, imprimer, ajouter un .à la fin
j;Utilisez le 0 de la pile pour ne pas sauter et utilisez le ;pour revenir à la planification d'impression puis utilisez le 1 pour sauter par-dessus le ;suivant temps
a"7102"4k,Imprimer 2017\n
d1gObtenir à nouveau la valeur du jour 7+Ajouter une semaine avant de répéter

JavaScript, 111 106 octets

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

Remarque: la console de Stack Exchange n'est pas assez longue pour afficher la liste complète, alors voici la première moitié sous forme d'extrait distinct:

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

Le format personnalisé me coûte 40 octets ...

Perl 5 , 64 octets

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

Essayez-le en ligne!

La tâche donnée était 2017, pas n'importe quelle année, j'ai donc codé en dur:

• 117 (qui est perlish pour l'année 2017, 1900 + 117)
• +1 car le 1er janvier est un dimanche en 2017
• 0..52 car 2017 ont 53 dimanches

POSIX est un module de base et est toujours installé avec Perl5. Faire de même sans utiliser de modules sur 101 octets, en supprimant les espaces:

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

Rubis, 75 octets

Solution simple pour comprendre les dates avec Time.

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

SAS, 52 50 octets

Enregistré 2 octets grâce à @ user3490.

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

Mathematica 90 84 octets

Assez verbeux. numbermaniac et Scott Milner ont économisé respectivement 5 et 1 octets.

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

VBA, 81 octets (peut-être 64)

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

Mon premier post. S'appuyant sur la solution de newguy en supprimant le chèque pour les jours de la semaine et en spécifiant simplement tous les 7 jours. La suppression des dates permet d'économiser 12 octets par pièce. 42736 est le 1/1/2017. Le format de date de sortie dépend du paramètre système. Est-ce permis? Si c'est le cas, c'est 64 octets car vous n'avez pas besoin de la méthode de formatage .

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

AHK , 67 octets

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

Rien de magique ne se passe ici. J'ai essayé de trouver un moyen plus court que FormatTime mais j'ai échoué.

Java 8+, 104 100 99 octets

()->{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 octets

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

Utilise les capacités de date du printfformat.

Testez-le vous-même!

Des économies

1. 104 -> 100: modification des valeurs de boucle et du multiplicande.
2. 100 -> 99: golfé la boucle

T-SQL, 94 octets

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

si vous n'aimez pas SQL GOTO ou WHILE, voici une solution CTE de 122 octets

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

Ruby, 60 + 7 = 67 octets

Utilise le -rdatedrapeau.

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

Groovy, 81 77 63 60 56 octets

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

Ce qui précède peut être exécuté en tant que script groovy.

Ma première entrée de golf de code. Heureusement, l'année 1970 n'a pas été une année bissextile et peut donc être utilisée comme base.

Merci à Dennis, voici une: Essayez-le en ligne!

C #, 138 111 102 octets

Sauvegardé 9 octets de plus grâce à Johan du Toit !

Enregistré 27 octets grâce aux suggestions de Kevin Cruijssen !

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

Fonction anonyme qui imprime tous les dimanches en 2017.

Programme complet avec méthode non golfée:

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 octets

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

Vous pouvez profiter de ce programme en ligne ici

Dans cette soluion, nous:

• Utilisez OLE Automation Date (OADate) pour éviter "AddDay ()" de datetime.
  FromOADate()semble grand, mais il est égal ànew DateTime(2017,1,1)

• Commencez la boucle le dernier dimanche de 2016. pour nous permettre d'incrémenter avec l'opérateur +=uniquement. Cet opérateur renvoie la valeur une fois l'incrémentation effectuée.

• Incrément de 7 jours pour passer de dimanche à dimanche avant d'imprimer la date.

• Nous nous arrêtons une fois le dernier dimanche de 2017 touché.

• Utilisez Debugau lieu de Consolepour enregistrer deux caractères

• Évitez d'avoir une déclaration et une affectation explicites de variables

TSQL, 112 105 octets

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

Démo

Syntaxe de conversion T-SQL

JavaScript (ES6), 123 octets

C'est mon premier post ici, bonjour!

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)})

Cette solution utilise des données codées en dur et est conçue pour fonctionner spécifiquement pour l'année 2017. Elle ne repose sur aucune API de date / heure.

En ce qui concerne les chiffres de la chaîne 155274263153, chaque chiffre est un nombre propre et désigne le premier dimanche de chaque mois consécutif. La production pour l'année entière peut être générée en ajoutant successivement 7 à ceux-ci.

Et le nombre magique 2633, utilisé dans la boucle?
Eh bien ... 2633(décimal) est 101001001001en binaire. Maintenant, qu'est-ce que cela pourrait 1signifier? En partant de la droite, les 1er, 4e, 7e, 10e et 12e bits sont définis. Cela correspond aux mois qui se trouvent avoir cinq dimanches, par opposition à ceux qui n'en ont que quatre. Golfed jusqu'à cette expression propre, initialement ressemblait à ceci: for(j=0;j<4+ +[0,3,6,9,11].includes(i);j++).

Je suppose que les autres parties sont assez explicites.

T-SQL, 79 77 octets

Après avoir aidé Salman A à améliorer sa réponse . J'ai décidé d'écrire le mien en utilisant une boucle et PRINT.

J'ai terminé avec cette solution de 90 octets.

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

Ensuite, j'ai regardé le leader actuel de T-SQL, qui était de 94 octets de WORNG ALL avec cette réponse . Ce gars avait trouvé de très bonnes astuces.

1. Nommez la variable uniquement @
2. Boucle avec GOTOau lieu d'une boucle réelle
3. Enregistrez un caractère en utilisant FORMATau lieu de CONVERT. (SSMS2012 + uniquement)

À l'aide de ces astuces, cette solution a été réduite à la solution ci-dessous, qui est de 79 octets.

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

Octave , 37 octets

Beaucoup plus court que toutes les autres langues non golfiques, et c'est même à égalité avec Jelly! Bravo Octave! :)

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

Essayez-le en ligne!

Heureusement, l'année 2 ADressemble exactement à l'année 2017 AD. Les deux commencent et se terminent un dimanche, et ni l'une ni l'autre n'est une année bissextile. Cela économise beaucoup d'octets, car il 367:7:737est beaucoup plus court que 736696:7:737060.

Cela convertit le nombre de jours depuis 01.01.0001, en une chaîne sur le format DD.mm, avec un suivi .2017.

Haskell , 133 130 octets

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)

Essayez-le en ligne!

Sans bibliothèque de calendrier, 148 144 140 octets

(\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++"."

C'est drôle car l'utilisation d'un opérateur pour la fonction de remplissage économise deux octets même si le deuxième argument n'est pas utilisé, car moins de parenthèses sont nécessaires - p(last l)est plus long que last l!l. Fonctionne en calculant les day/monthpaires en soustrayant les dates cumulées de début de mois du jour de l'année. Les dates de début du mois sont compressées en tant que ( scanl((+).(+28))0[3,0,3,2,3,2,3,3,2,3,2]). Le numéro du mois est le nombre d'éléments positifs et le numéro du jour est le dernier élément positif.

Essayez-le en ligne!

C #, 116 114 113 octets

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

Peut être exécuté dans les fenêtres interactives de Visual Studio (ou tout autre REPL C # basé sur Roslyn)

Jusqu'à 113 octets: merci à Kevin Cruijssen.