Avance Bonne année 2016!

40

Votre entrée sera un entier entre 1970 et 2090 (inclus), représentant une année. Votre programme devrait afficher l'année suivante où le jour du Nouvel An tombe le même jour de la semaine que l'année d'entrée.

Cas de test:

Voici les exemples d'entrées et de sorties

2001 => 2007
2047 => 2058
2014 => 2020
1970 => 1976
1971 => 1982
1977 => 1983
2006 => 2012

Bonus de 20%: sortie le jour de la semaine du jour de l'an

2001 => 2007 (Mon)
2047 => 2058 (Tue)
2014 => 2020 (Wed)
1970 => 1976 (Thu)
1971 => 1982 (Fri)
1977 => 1983 (Sat)
2006 => 2012 (Sun)

30% de bonus: sortieAdvance Happy New Year, <year>

2010 => Advance Happy New Year, 2016

Bonus de 50%: Faites les deux bonus ci-dessus

2010 => Advance Happy New Year, 2016 (Fri)

Ecrivez un programme qui lit les entrées de STDIN ou accepte les arguments de ligne de commande ou une fonction qui prend un argument.

Remarque: veuillez ajouter un lien pour tester votre code si possible.

Classement:

Vasu Adari
la source
6
Je pense que chaque défi lié aux dates nécessite de faire le calcul des années bissextiles comme un sous-problème, et il devient obsolète.
xnor
Connexe: cette question .
Addison Crump
@xnor Si ce n'était pas le cas, cela aurait été juste un +7. C'est à dire "trop ​​large"
Erik the Outgolfer
@EriktheGolfer No. Lorsque j'ai écrit ce commentaire, ma réponse a été acceptée.
Dennis

Réponses:

1

Gelée, 9 octets

%4*3%7+5+

Il s'agit d'une chaîne monadique qui prend un argument de ligne de commande entier en entrée. Il utilise mon (x+5+(x%4)**3%7)algorithme.

Essayez ici . Bien que ce soit la version actuelle de Jelly, cela fonctionne également dans cette version , antérieure au défi. (Merci @Dennis!)

lirtosiast
la source
Ceci est incroyable! Je peux confirmer que cela fonctionne avec cette révision de l'interpréteur Jelly, antérieure au défi.
Dennis
31

Mathematica, 45 37 27 24 octets

#+5[6,6,11][[#~Mod~4]]&

Améliorations grâce à @ MartinBüttner (10 octets) et à @ChipHurst (3 octets supplémentaires).

Martin
la source
7
Oh wow. Personne ne semble avoir remarqué ce schéma, mais ça marche.
Lynn
4
Voici une version légèrement plus courte:#+5[6,6,11][[#~Mod~4]]&
Chip Hurst
@ChipHurst très intelligent avec 5[6, 6, 11][[0]]:)
martin
18

CJam, 21 12 11 octets

{_9587Cb=+}

@martin a trouvé une méthode très simple!

Essayez-le ici .

EDIT: Merci, Dennis!

Lynn
la source
1
@Mauris Pourriez-vous ajouter une explication?
Vasu Adari
@ Vasu: Ce code est une fonction anonyme qui implémente la même 5 6 6 11astuce que dans d'autres réponses, mais la liste est codée comme "les chiffres de 9587 en base 12" .
Lynn
Je l'ai Merci. Je voulais que vous ajoutiez une explication afin que les personnes qui vérifient votre réponse puissent comprendre son fonctionnement par rapport au langage.
Vasu Adari
10

gs2, 12 octets

V@¶4☻s%☺♀i50

Traduction de ma réponse CJam. Encodé dans CP437 comme d'habitude. Essayez-le en ligne !

Lynn
la source
Le lien mène au code qui produit 2spooky4me, et si je coupe et colle le code ci-dessus, je me trompe d’année: imgur.com/VAkXT0k (par "mauvaise année", j’entends un an plus tôt que l’année prévue)
question_asker
J'avais oublié un octet. Essayez maintenant.
Lynn
J'ai édité le lien aussi.
Lynn
Cool, ça marche maintenant
question_asker
8

JavaScript (ES6), 50 49 20 octets (pas de bonus)

a=>a+[5,6,6,11][a%4]

L'algorithme de @martin se révèle beaucoup plus petit, alors je suis parti avec.

J'ai choisi une approche mathématique car JavaScript a tendance à être prolixe. Le code est suffisamment court pour que les bonus ne le rendent que plus long.

Voici ma réponse précédente (49 octets) et ma réponse originale (50 octets):

F=(a,b=a)=>((a+--a/4|0)-(b++/4+b|0))%7?F(++a,b):b

F=(a,b=a)=>(f=c=>(c--+c/4|0)%7)(a)-f(++b)?F(a,b):b

Ils travaillent en prenant l'année et en calculant un nombre (0-6) pour représenter le "jour de début de l'année". Étant donné que la plage de dates de ce défi est comprise dans la plage d'années qui suivent les règles simples des années bissextiles (ne pas ignorer 2000), le calcul est relativement simple. Ensuite, il suffit de comparer en avant pour trouver les années qui commencent avec la même valeur. La récursivité s'est avérée être le moyen le plus concis de procéder.

Mwr247
la source
7

Pyth, 14 12 11 octets

+QC@"♣♠♠♂"Q

Les quatre octets de la chaîne devraient être 05 06 06 0B.

EDIT: Merci, FryAmTheEggman!

EDIT: Merci, Dennis!

Lynn
la source
6

JavaScript (ES6), 104 octets - 50% de bonus = 52

y=>eval('for(a=0;a!=(b=(new Date(""+y++)+"").slice(0,3));a=a||b)`Advance Happy New Year, ${y} (`')+b+")"

Explication

y=>
  eval(`                  // eval enables for loop without {} or return
    for(
      a=0;                // a = first day of input year
      a!=                 // check if the day of the current year is equal to the first
        (b=(new Date(     // b = day of current year
          ""+y++)+"")     // cast everything as strings!
            .slice(0,3)); // the first 3 letters of the date string are the day name
      a=a||b              // set a to the day on the first iteration
    )

      // return the string
      \`Advance Happy New Year, \${y} (\`
  `)+b+")"

Tester

utilisateur81655
la source
6

Code machine Z80, 12 octets

Une procédure Z80 à stocker dans 0000h, appelée avec l'entrée dans HLet tous les autres registres effacés:

.org 0000h
              ; Bytes   ; Explanation
  ;---------------------------------------------------------------
  DEC B       ; 05      ; 
  LD B, 6     ; 06 06   ;   
  DEC BC      ; 0B      ;
  LD A, 3     ; 3E 03   ;   A = 3
  AND L       ; A5      ;   A = input & 3
  LD E, A     ; 5F      ;   A = input & 3     DE = input & 3
  LD A, (DE)  ; 1A      ;   A = [input & 3]   DE = input & 3
  LD E, A     ; 5F      ;   A = [input & 3]   DE = [input & 3]
  ADD HL, DE  ; 19      ;   HL = input + offset
  RET         ; C9      ;

Les trois premières instructions sont des "NOP", mais sont indexées en tant que données plus tard dans le code. Au retour, la sortie est en HL.

Lynn
la source
Oui, je l'ai ajouté à l'article.
Lynn
Ne semble pas juste pour les années 2097 et 2098, qui nécessitent des ajouts de 7 et 12, respectivement.
Toby Speight
1
Le PO indique que l'année d'entrée sera dans la fourchette 1970-2090.
Lynn
6
Je n'aime vraiment pas les questions qui sont changées après avoir répondu!
Toby Speight
2
Êtes-vous autorisé à spécifier que l'entrée est en DEet donc vous pouvez utiliser LD A, 3; AND E; LD L, A; LD L, (HL);?
Neil
5

Python 3, 140 100 102 84,5 154 * 0.5 = 77 octets

Je pourrais probablement écrire une meilleure solution avec l'algorithme de Sakamoto, mais cela ira pour le moment.

J'avais raison. Voici une implémentation utilisant l'algorithme de Sakamoto.

def s(y):
 d=lambda j:(j+j//4)%7
 for i in range(y,y+15):
  if d(i)==d(y-1):return"Advance Happy New Year, %d (%s)"%(-~i,"SMTWTFSuouehranneduit"[d(i)::7])

Explication:

def day_of_the_week(year):
    return (year + year//4 - 1 + 0 + 1) % 7
    # The month code for January is 0, and you add 1 from January *1*.
    # The -1 is to correct for starting on Saturday 
    # and so that it cancels out the 1 from January 1.

def new_years(this_year):
# But in Sakamoto's algorithm, if the month is January or February, we must subtract 1.
    weekdays = "SunMonTueWedThuFriSat"
    for item in range(this_year, this_year + 15):
        if day_of_the_week(this_year - 1) == day_of_the_week(item):
            day = weekdays[day_of_the_week(item)*3 : day_of_the_week(item)*3+3]
            return "Advance Happy New Year, %d (%s)"%(item + 1, day)
        # So we subtract from every year we check, including this_year
        # And add 1 back in at the end
        # And print the greeting, the year, and the corresponding day of the week
Sherlock9
la source
J'ai mis à jour la question. Vous n'avez pas besoin de vérifier pendant des années.
Vasu Adari
1
Que diriez-vous w="SMTWTFSuouehranneduit"et ensuite imprimer w[d(i)::7]?
Lynn
4

Sérieusement, 35 17 octets

[5,6,6,11] astuce sauve la journée.

4,;)%[5,6,6,11]E+

Essayez-le en ligne

Explication:

4,;)%[5,6,6,11]E+
4,;)%              push input, input % 4
     [5,6,6,11]E   push (input % 4)th element of [5,6,6,11]
                +  add to the input

Ancienne version:

,;;D`45/*≈7@%`;╝ƒ╗35*r+`╛ƒ╜=`M1@íu+

Essayez-le en ligne

Explication:

,;;D`45/*≈7@%`;╝ƒ╗35*r+`╛ƒ╜=`M1@íu+
,;;                                  push 3 copies of the input (n)
   D                                 decrement the top copy of n
    `45/*≈7@%`;╝                     push Sakamoto's algorithm as a function and save a copy in register 1
                ƒ╗                   call Sakamoto's algorithm function and save result in register 0
                  35*r+              push [n, n+1, ..., n+14]
                       `    `M       map the function:
                        ╛ƒ╜=           push Sakamoto's algorithm, call, push 1 if equal to value in register 0 else 0
                              1@í    get the index of the first 1
                                 u+  increment and add n

Algorithme de Sakamoto:

45/*≈7@%
45/*      multiply by 5/4
    ≈     floor
     7@%  mod 7
Mego
la source
4

C, 31 octets

Suite à la modification de la question qui limite la plage d’entrée à 1970-2090, cela devient assez trivial:

f(x){return"\5\6\6\13"[x%4]+x;}

Sans les années non bissextiles, il existe une simple séquence d'intervalles 5,6,6,11 pour la première répétition du même jour.

Solution complète au problème initial (non limité à 2090), 90 octets:

f(x){return(x-1)%100>89&&(x+9)/100%4?"\6\14\5\6\6\6\6\7\14\6"[x%10]+x:"\5\6\6\13"[x%4]+x;}

Programme de test:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    while (*++argv)
        printf("Advance Happy New Year, %d\n", f(atoi(*argv)));
    return !argc;
}

Essai:

$ ./66656 2001 2047 2014 1970 1971 1977 2006
Advance Happy New Year, 2007
Advance Happy New Year, 2058
Advance Happy New Year, 2020
Advance Happy New Year, 1976
Advance Happy New Year, 1982
Advance Happy New Year, 1983
Advance Happy New Year, 2012
Toby Speight
la source
4

R, 143 136 * 0,5 = 68 octets

G=function(y)strftime(paste(y,1,1,sep='-'),'%a')
d=seq(y<-scan(),y+14);sprintf("Advance Happy New Year, %i (%s)",d[G(d)==(w=G(y))][2],w)

Utilisez %Ale nom de la journée complète au lieu de «% a», selon l’état souhaité.

R, 120 * 0,7 = 84 octets

G=function(y)as.POSIXlt(paste(y,1),,"%Y %j")$wday
d=seq(y<-scan(),y+14);cat("Advance Happy New Year,",d[G(d)==G(y)][2])

R, 90 octets

G=function(y)as.POSIXlt(paste(y,1),,"%Y %j")$wday
d=seq(y<-scan(),y+14);d[G(d)==G(y)][2]

Toutes les réponses ci-dessus sont des travaux dérivés basés sur la réponse @plannapus. Utilisez le ;séparateur pour éviter d’avoir besoin sourcedu fichier ou de l’exécuter en tant que script en ligne de commande.

Tensibai
la source
1
+1 j'ai complètement oublié weekdays, gentil.
Plannapus
@plannapus Merci :) (j'ai compté les sauts de lignes, ai demandé au système de fichiers en fait, comme je suis sous windows c'est 2 octets mais je n'ai pas de nouvelle ligne à la fin qu'un fichier POSIX devrait avoir, donc il est juste de le garder comme ça effectivement)
Tensibai
3

R, 145 octets -50% -> 72,5

y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%a");x=y+1;while(F(x)!=F(y))x=x+1;sprintf("Advance Happy New Year, %i (%s)",x,F(x))

Exemples:

> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%a");x=y+1;while(F(x)!=F(y))x=x+1;sprintf("Advance Happy New Year, %i (%s)",x,F(x))
1: 2006
2: 
Read 1 item
[1] "Advance Happy New Year, 2012 (Sun)"
> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%a");x=y+1;while(F(x)!=F(y))x=x+1;sprintf("Advance Happy New Year, %i (%s)",x,F(x))
1: 1977
2: 
Read 1 item
[1] "Advance Happy New Year, 1983 (Sat)"
> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%a");x=y+1;while(F(x)!=F(y))x=x+1;sprintf("Advance Happy New Year, %i (%s)",x,F(x))
1: 2014
2: 
Read 1 item
[1] "Advance Happy New Year, 2020 (Wed)"

R, 97 octets (sans bonus)

y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%w");x=y+1;while(F(x)!=F(y))x=x+1;x

En retrait, avec de nouvelles lignes:

y = scan() #Takes input from stdin
F = function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%w") #Year to Weekday
x = y+1
while(F(x) != F(y)) x = x+1
x

Cas de test:

> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%w");x=y+1;while(F(x)!=F(y))x=x+1;x
1: 1977
2: 
Read 1 item
[1] 1983
> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%w");x=y+1;while(F(x)!=F(y))x=x+1;x
1: 2006
2: 
Read 1 item
[1] 2012
> y=scan();F=function(y)format(as.POSIXct(paste(y,1),,"%Y %j"),"%w");x=y+1;while(F(x)!=F(y))x=x+1;x
1: 2016
2: 
Read 1 item
[1] 2021
planificateur
la source
Je ne comprends pas ce souhait de faire une ligne laide, un retour en calèche n'est pas plus coûteux qu'une ;...
Tensibai
vous pouvez enregistrer 1 caractère en supprimant le premier y=scan;et en utilisant, x=y<-scan()+1je pense
Tensibai
et vous pouvez en économiser sept autres en vous servant as.POSIXlt(paste(y,1),,"%Y %j")$wdayde votre corps fonctionnel
Tensibai
@Tensibai Si vous ne le mettez pas sur une seule ligne et ne le collez pas directement dans la console, vous scanlirez la deuxième ligne comme entrée. x=y<-scan()+1avec 2014 comme stdin vous donnera x = 2015 et y = 2015 (c'est-à-dire que l'affectation est y <- scan()+1) et si vous essayez de le faire, x=1+y<-scan()cela vous donnera une erreur ( Error in 1 + y <- scan() : target of assignment expands to non-language object) car il essaie d'assigner scan()à 1+y.
Plannapus
@Tensibai Quant à votre dernier conseil, les résultats de ...$wday sont le numéro du jour de la semaine: mais ici, j'ai besoin du nom du jour de la semaine afin que je puisse imprimerAdvance Happy New Year, 2012 (Sun)
plannapus
3

VBA, 130 * 0,50 = 65 octets

Sub k(y)
i=1
Do While Weekday(y+i)<>Weekday(y)
i=i+1
Loop
MsgBox "Advance Happy New Year," &y+i &WeekdayName(Weekday(y+i))
End Sub

VBA facilite la recherche des jours de la semaine ... Si seulement ce n'était pas aussi prolixe à ce sujet.

JimmyJazzx
la source
3

PHP, 120 139 octets - 50% = 60 octets

Une approche fonctionnelle:

$s=strtotime;for($d=date(D,$s(($y=$argv[1]).$_="-1-1"));$d!=date(D,$s(++$y.$_)););echo"Advance Happy New Year, $y ($d)";

Prend une entrée de la ligne de commande, comme:

$ php ahny.php 2001

La méthode POO semble être plus longue, comme toujours (143 octets):

$s=strtotime;for($d=date(D,$s($x=($y=$argv[1])."-1-1"));$d!=date(D,$s(++$y."-1-1")););echo"Advance Happy New Year, $y ($d)";

Édite

  • Enregistré 18 octets . Au lieu d'ajouter un an en utilisant le modificateur PHP+1year simplement l’année donnée.
  • Enregistré 1 octet en stockant -1-1dans une variable.
insertusernamehere
la source
3

C, note 53 52 (104 octets)

f(x){x+="0116"[x%4];printf("Advance Happy New Year, %d (%.3s)",x-43,"MonTueWedThuFriSatSun"+x*5/4%7*3);}

Idée empruntée à Toby Speight ; ajout de l'affichage bonus du jour de la semaine.

Raccourcissez la chaîne en déplaçant les codes de caractères dans une plage plus confortable. Dû choisir le bon montant (par exemple 43) pour que le code de calcul de jour court x*5/4%7fonctionne.

anatolyg
la source
Je suppose que votre code de personnage limite ceci aux encodages compatibles ASCII?
Toby Speight
Oui. Les codes doivent être supérieurs à 31, le nombre minimal à ajouter aux codes serait donc 27, ce qui correspond à la chaîne " !!&".
Anatolyg
2

Mathematica, 145 * 50% = 74 73,5 72,5 octets

d=DateValue;StringForm["Advance Happy New Year, `` (``)",NestWhile[#+1&,(a=#)+1,#!=#2&@@DateObject@{{a},{#}}~d~"DayName"&],{a}~d~"DayNameShort"]&

Utilise les fonctions de date standard.

LegionMammal978
la source
2

Pyth, 23 octets

L%+/b4b7.VQIqyby-Q1+1bB

Ne se qualifie pour aucun des bonus.

Essayez ici .

Semblable à la réponse en python pur.

                        - Q = eval(input()) (autoassigned)
L                       - y = lambda b:
   /b4                  - b floordiv 4
  +   b                 - + b
 %     7                - mod 7


        .VQ             - for b in range(Q, infinate):
           Iqyby-Q1     - if y(b) == y(Q-1):
                   +1b  - print b+1
                      B - break
Bleu
la source
2

Java, (1 à 0,2) * 323 (1 à 0,5) * 350 348 339 = 258,4 175 174 169,5 octets

import java.text.*;class D{public static void main(String[]a){long y=new Long(a[0]);int i=0;for(;!s(y).equals(s(y+(++i))););System.out.printf("Advance Happy New Year, %d (%s)",y+i,s(y+i));}static String s(long y){try{return new SimpleDateFormat("E").format(new SimpleDateFormat("d/M/yyyy").parse("1/1/"+y));}catch(Exception e){}return"";}}

Pouah.

Ungolfed:

import java.text.*;
class D{
    public static void main(String[]a){
        long y=new Long(a[0]);
        int i=0;
        for(;!s(y).equals(s(y+(++i))););
        System.out.printf("Advance Happy New Year, %i (%s)",y+i,s(y+i));
    }
    static String s(long y){
        try{
            return new SimpleDateFormat("E").format(new SimpleDateFormat("d/M/yyyy").parse("1/1/"+y));
        }catch(Exception e){}
        return"";
    }
}

Essayez-le en ligne!

Merci à @Kenney pour avoir signalé que je pouvais raccourcir avec new Longet printf! :RÉ

Addison Crump
la source
long y=new Long(a[0])enregistre 6 (12) octets et en utilise printfun autre (3).
Kenney
2

GNU coreutils, 52 51 49 bytes

(Programme de 98 octets - bonus de 50%)

seq -f$1-1-1\ %gyear 28|date -f- +'Advance Happy New Year, %Y (%a)'|sed /`date -d$1-1-1 +%a`/!d\;q

L'entrée provient de l'argument de ligne de commande et la sortie est sur stdout.

Explication

# generate 28 input years from $1 + 1 onwards (28 is always enough)
seq -f '$1-1-1 %g year' 28
|
# convert all of these as potential outputs
date -f- +'Advance Happy New Year, %Y (%a)'
|
 # Select the first one where the dayname matches that of input year
sed "/`date -d$1-1-1 +%a`/!d;q"

Essai:

Tous les paramètres régionaux peuvent être Cou POSIX.

$ for i in 2001 2047 2014 1970 1971 1977 2006; do ./66656.sh $i; done
Advance Happy New Year, 2007 (Mon)
Advance Happy New Year, 2058 (Tue)
Advance Happy New Year, 2020 (Wed)
Advance Happy New Year, 1976 (Thu)
Advance Happy New Year, 1982 (Fri)
Advance Happy New Year, 1983 (Sat)
Advance Happy New Year, 2012 (Sun)

Limitation: cela ne fonctionne que jusqu'en 2147485519 (bien que la question soit maintenant modifiée pour permettre une limite inférieure).

Toby Speight
la source
2

MATL , 28 octets

i0:14+t1tI$YO8H$XO!st1)=f2))

Exemple

>> matl i0:14+t1tI$YO8H$XO!st1)=f2))
> 1970
1976

Code expliqué

i           % input year
0:14+       % vector with that year and the next 14
t1tI$YO     % first day of each year
8H$XO       % transform into three letters specifying weekday
!s          % sum those three letters to reduce to unique numbers
t1)         % get first of those numbers (corresponding to input year)
=f2)        % find index of second matching
)           % index with that to obtain output year
Luis Mendo
la source
2

Perl 6 ,  70   23 octets

{($^a+1...{[==] ($a,$_).map: {Date.new(:year($_)).day-of-week}})[*-1]} # 70 bytes

{($_ X+5,6,6,11)[$_%4]} # 23 bytes

usage:

for «2001 2047 2014 1970 1971 1977 2006 2010» {
  printf "%d => %d\n", $_, {($_ X+5,6,6,11)[$_%4]}( $_ )
}
2001 => 2007
2047 => 2058
2014 => 2020
1970 => 1976
1971 => 1982
1977 => 1983
2006 => 2012
2010 => 2016
Brad Gilbert b2gills
la source
2

J, 14 octets

+5 6 6 11{~4&|
Alephalpha
la source
2

Japt, 12 octets

U+"♣♠♠♂"cU%4

Comme avec la réponse Pyth, les quatre octets de la chaîne devraient être 05 06 06 0B. Essayez-le en ligne!

U+"♣♠♠♂"cU%4  // Implicit: U = input integer
  "♣♠♠♂"      // Take this string.
        cU%4  // Take the char code at U%4.
U+            // Add U.
              // Implicit: output last expression
ETHproductions
la source
2
Merci pour ce cadeau de Noël d'une prime! Mais quelqu'un peut-il me dire comment je l'ai gagné?
ETHproductions
J'ai parcouru l'histoire. Apparemment, le PO a tenté de récompenser une réponse, mais il a oublié d'attribuer la prime. La communauté a donc choisi de transmettre la moitié de la réputation à cette réponse (je pense qu'elle fonde son choix sur des votes récents).
2

Gelée , 14 octets

%4=0,3×-,5S++6

Essayez-le en ligne!

Jusqu’à aujourd’hui, Jelly n’avait pas d’indexation de tableaux, ce qui doit être fait ci-dessus. Depuis la dernière validation, l'indexation de tableaux a été implémentée en tant que , donnant la solution suivante ( 10 octets ).

ị6,6,11,5+

Essayez-le en ligne!

Dennis
la source
1
Je pense que Jelly peut épargner 7 caractères pour 10 à 16 constantes.
lirtosiast
1

C # (6.0) .Net Framework 4.6 173 octets - 30% = 121,1 octets

void n(int y)=>Console.Write($"Advance Happy New Year, {Enumerable.Range(1,15).Select(i=>new DateTime(y+i,1,1)).First(x=>x.DayOfWeek==new DateTime(y,1,1).DayOfWeek).Year}");
Stephan Schinkel
la source
1

Javascript ES7, 17 octets

a=>a+5+(a%4)**3%7

C'est la première fois que j'utilise JS. J'ai trouvé cela en utilisant un script Python, et je pense que c'est optimal. Cela fonctionne parce que 0**30 mod 7, 1**3et 2**3les deux 1 et 3**36.

lirtosiast
la source
1
L' opérateur d'exponentiation** n'est-il pas une fonctionnalité de l' ES7 ? Ou utilisez-vous Babel ?
insertusernamehere
@insertusernamehere Fixe.
lirtosiast
1

Python, 23 octets

lambda a:a+5+(a%4)**3%7

Un port de ma réponse JavaScript.

lirtosiast
la source