एडवांस हैप्पी न्यू इयर, 2016!

40

आपका इनपुट एक वर्ष का प्रतिनिधित्व करते हुए, 1970 और 2090 के बीच पूर्णांक होगा। आपके कार्यक्रम को अगले वर्ष आउटपुट करना चाहिए, जिस पर नए साल का दिन सप्ताह के उसी दिन पड़ता है जैसे इनपुट वर्ष।

परीक्षण के मामलों:

नीचे नमूना इनपुट और आउटपुट दिए गए हैं

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

20% बोनस: नए साल के दिन के दिन का आउटपुट

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

30% बोनस: आउटपुटAdvance Happy New Year, <year>

2010 => Advance Happy New Year, 2016

50% बोनस: उपरोक्त दोनों बोनस को करें

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

एक प्रोग्राम लिखें जो STDIN से इनपुट पढ़ता है या कमांड लाइन तर्क स्वीकार करता है, या एक फ़ंक्शन जो एक तर्क लेता है।

नोट: यदि संभव हो तो अपने कोड का परीक्षण करने के लिए एक लिंक जोड़ें।

लीडरबोर्ड:

कोड स्निपेट दिखाएं

code-golf  string  date  new-years 
— वासु अडारी
स्रोत
6
मुझे लगता है कि हर एक तारीख की चुनौती के लिए उप-वर्ष के रूप में लीप वर्ष की गणना करने की आवश्यकता होती है, और यह बासी हो रही है।
— xnor
संबंधित: यह सवाल ।
— Addison Crump
@xnor अगर ऐसा नहीं होता, तो यह सिर्फ एक +7 होता। Ie "बहुत व्यापक"
— आउटगॉल्फ
@EriktheGolfer No. जब मैंने वह टिप्पणी लिखी, तो मेरा उत्तर स्वीकार कर लिया गया था।
— डेनिस

जवाबों:

1

जेली, 9 बाइट्स

%4*3%7+5+

यह एक मोनैडिक श्रृंखला है जो इनपुट के रूप में पूर्णांक कमांड-लाइन तर्क लेता है। यह मेरे (x+5+(x%4)**3%7)एल्गोरिथ्म का उपयोग करता है।

इसे यहाँ आज़माएँ । हालांकि यह जेली का वर्तमान संस्करण है, यह इस संस्करण में भी काम करता है , जो चुनौती से पहले होता है। (साभार @ डेनिस)

— lirtosiast
स्रोत
ये अद्भुत है! मैं इस बात की पुष्टि कर सकता हूं कि यह जेली दुभाषिया के इस संशोधन के साथ काम करता है , जो चुनौती पेश करता है।
— डेनिस
31

मेथेमेटिका, 45 37 27 24 बाइट्स

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

@ मार्टिनबटनर (10 बाइट्स) और @ChipHurst (एक और 3 बाइट्स) के लिए धन्यवाद।

— मार्टिन
स्रोत
7
ओह वाह। किसी को भी इस पैटर्न पर ध्यान नहीं दिया गया है, लेकिन यह काम करता है।
— लिन
4
यहाँ थोड़ा छोटा संस्करण है:#+5[6,6,11][[#~Mod~4]]&
— चिप हर्स्ट
@ChipHurst बहुत चतुर के साथ 5[6, 6, 11][[0]]:)
— martin
18

सीजाम, 21 12 11 बाइट्स

{_9587Cb=+}

@martin को एक बहुत ही सरल विधि मिली!

इसे यहाँ आज़माएँ ।

संपादित करें: धन्यवाद, डेनिस!

— लिन
स्रोत
1
@ मौरिस क्या आप एक स्पष्टीकरण जोड़ सकते हैं?
— वासु अडारी
@Vasu: यह कोड एक अनाम फ़ंक्शन है जो 5 6 6 11अन्य उत्तरों में उपयोग की गई समान चाल को लागू करता है, लेकिन सूची को "आधार 12 में 9587 के अंक" के रूप में एन्कोड किया गया है ।
— लिन
मिल गया धन्यवाद। मैं चाहता था कि आप एक स्पष्टीकरण जोड़ें, ताकि आपके उत्तर की जांच करने वाले लोग यह समझ सकें कि यह wrt भाषा कैसे काम करती है।
— वासु अडारी
10

gs2, 12 बाइट्स

V@¶4☻s%☺♀i50

मेरे CJam उत्तर का अनुवाद। CP437 में हमेशा की तरह एनकोडेड। इसे ऑनलाइन आज़माएं !

— लिन
स्रोत
लिंक उस कोड पर जाता है जो 2spooky4me का उत्पादन करता है, और अगर मैं ऊपर दिए गए कोड को काटता हूं और पेस्ट करता हूं, तो मुझे गलत वर्ष मिलता है: imgur.com/VAkXT0k ("गलत वर्ष" से, मेरा मतलब है कि मैं इच्छित वर्ष की तुलना में एक वर्ष पहले प्राप्त करता हूं)
— question_asker
मैं एक बाइट भूल गया था। अब कोशिश करो।
— लिन
मैंने लिंक भी संपादित किया।
— लिन
कूल, अब यह काम करता है
— question_asker
8

जावास्क्रिप्ट (ईएस 6), 50 49 20 बाइट्स (कोई बोनस नहीं)

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

@Martin द्वारा एल्गोरिथ्म बहुत छोटा साबित होता है, इसलिए मैं इसके साथ गया था।

मैंने एक गणितीय दृष्टिकोण चुना क्योंकि जावास्क्रिप्ट क्रिया है। कोड इतना कम है कि बोनस केवल इसे लंबा बनाते हैं।

यहाँ मेरा पिछला उत्तर (49 बाइट्स), और मेरा मूल उत्तर (50 बाइट्स) है:

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

वे वर्ष लेते हैं और "वर्ष के शुरुआती दिन" का प्रतिनिधित्व करने के लिए एक संख्या (0-6) की गणना करते हैं। क्योंकि इस चुनौती के लिए तिथि सीमा उन वर्षों की सीमा के भीतर है जो सरल लीप वर्ष के नियमों का पालन करते हैं (2000 पर कोई लंघन नहीं), यह गणना करने के लिए काफी सरल है। फिर यह उसी मूल्य से शुरू होने वाले वर्षों को खोजने के लिए आगे की तुलना करने का मामला है। रिकर्सन ऐसा करने का सबसे संक्षिप्त तरीका साबित हुआ।

— Mwr247
स्रोत
7

पायथ, 14 12 11 बाइट्स

+QC@"♣♠♠♂"Q

स्ट्रिंग में चार बाइट्स होना चाहिए 05 06 06 0B।

संपादित करें: धन्यवाद, FryAmTheEggman!

संपादित करें: धन्यवाद, डेनिस!

— लिन
स्रोत
6

जावास्क्रिप्ट (ईएस 6), 104 बाइट्स - 50% बोनस = 52

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

व्याख्या

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+")"

परीक्षा

कोड स्निपेट दिखाएं

— user81655
स्रोत
6

Z80 मशीन कोड, 12 बाइट्स

एक Z80 प्रक्रिया में संग्रहीत किया जाना है 0000h, में इनपुट के साथ बुलाया HL, और अन्य सभी रजिस्टर स्पष्ट:

.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      ;

पहले तीन निर्देश "एनओपी" हैं, लेकिन कोड में बाद में डेटा के रूप में अनुक्रमित किए जाते हैं। लौटने पर, आउटपुट अंदर है HL।

— लिन
स्रोत
हां, मैंने इसे पोस्ट में जोड़ दिया है।
— लिन
वर्ष 2097 और 2098 के लिए सही नहीं लगता है, जिसमें क्रमशः 7 और 12 के परिवर्धन की आवश्यकता होती है।
— टोबे स्पाइट
1
ओपी का कहना है कि इनपुट वर्ष 1970-2090 की सीमा में होने की गारंटी है।
— लिन
6
मुझे वास्तव में ऐसे सवाल पसंद नहीं हैं जो मैंने उत्तर देने के बाद बदल दिए हैं!
— टोबे स्पाइट
2
क्या आपको यह निर्दिष्ट करने की अनुमति है कि इनपुट में है DEऔर इसलिए आप उपयोग कर सकते हैं LD A, 3; AND E; LD L, A; LD L, (HL);?
— नील
5

पायथन 3, 140 100 102 84.5 154 * 0.5 = 77 बाइट्स

मैं शायद सकामोटो के एल्गोरिथ्म के साथ एक बेहतर समाधान लिख सकता था, लेकिन यह अभी के लिए करेगा

मैं सही था। यहां सकामोटो के एल्गोरिदम का उपयोग करते हुए एक कार्यान्वयन है। 

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

स्पष्टीकरण: 

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
स्रोत
मैंने सवाल अपडेट किया है। आपको सदी के वर्षों की जांच करने की आवश्यकता नहीं है।
— वासु अडारी
1
कैसे w="SMTWTFSuouehranneduit"और फिर छपाई के बारे में w[d(i)::7]?
— लिन
4

गंभीरता से, 35 17 बाइट्स

[5,6,6,11] चाल दिन बचाता है।

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

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

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

पुराना संस्करण:

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

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

,;;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

सकामोटो का एल्गोरिथ्म:

45/*≈7@%
45/*      multiply by 5/4
    ≈     floor
     7@%  mod 7
— मेगो
स्रोत
4

सी, 31 बाइट्स

1970-2090 तक इनपुट रेंज को प्रतिबंधित करने वाले प्रश्न को संपादित करने के बाद, यह बहुत तुच्छ हो जाता है: 

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

गैर-छलांग सदी के वर्षों के बिना, एक ही दिन के पहले दोहराने के लिए अंतराल का एक सरल 5,6,6,11 अनुक्रम है।

मूल समस्या का पूर्ण समाधान (2090 पर विवश नहीं), 90 बाइट्स: 

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

परीक्षण कार्यक्रम:

#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;
}

परीक्षण चालन:

$ ./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
— टोबी स्पाईट
स्रोत
4

आर, 143 136 * 0.5 = 68 बाइट्स

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)

%A'% A' के बजाय पूरे दिन के नाम का उपयोग करें , वांछित राज्य पर निर्भर रहें।

आर, 120 * 0.7 = 84 बाइट्स

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

आर, 90 बाइट्स

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

उपरोक्त सभी उत्तर @plannapus उत्तर के आधार पर व्युत्पन्न कार्य हैं। फ़ाइल की ;आवश्यकता से बचने के लिए विभाजक का उपयोग करना sourceया इसे कमांड लाइन पर स्क्रिप्ट के रूप में चलाना।

— Tensibai
स्रोत
1
+1 मैं पूरी तरह से भूल गया weekdays, अच्छा।
— प्लेनैपस
धन्यवाद वास्तव में)
— तेंसिबाई
3

आर, 145 बाइट्स -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))

उदाहरण:

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

आर, 97 बाइट्स (बोनस के बिना)

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

नई लाइनों के साथ प्रस्तुत:

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

परीक्षण के मामलों:

> 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
— plannapus
स्रोत
मैं एक बदसूरत लाइन पर पाने की इस इच्छा को नहीं समझता, एक गाड़ी की वापसी सबसे महंगी नहीं है ;...
— तेनसीबाई
आप पहले को हटाकर y=scan;और x=y<-scan()+1मुझे लगता है कि उपयोग करके 1
— चार्ज
और आप as.POSIXlt(paste(y,1),,"%Y %j")$wdayअपने फंक्शन बॉडी के रूप में उपयोग करके सात और बचत कर सकते हैं
— Tensibai
@ टेन्सिबाई यदि आप इसे एक लाइन पर नहीं डालते हैं और इसे सीधे कंसोल पर पेस्ट करते हैं, scanतो इनपुट के रूप में दूसरी पंक्ति में पढ़ा जाएगा। x=y<-scan()+12014 के रूप में स्टडिन आपको x = 2015 और y = 2015 (यानी असाइनमेंट है y <- scan()+1) देगा और यदि आप x=1+y<-scan()इसे करने का प्रयास करते हैं, तो यह आपको त्रुटि देगा ( Error in 1 + y <- scan() : target of assignment expands to non-language object) क्योंकि यह असाइन scan()करने का प्रयास कर रहा है 1+y।
— प्लेनैपस
@Tensibai आपकी अंतिम सलाह के अनुसार, ...$wdayसप्ताह के दिनों की संख्या है: लेकिन यहां मुझे सप्ताह के नाम की आवश्यकता है ताकि मैं प्रिंट कर Advance Happy New Year, 2012 (Sun)
— सकूं
3

VBA, 130 * 0.50 = 65 बाइट्स 

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

वीबीए सप्ताह के दिनों को इतना आसान बनाता है .... यदि केवल इसके बारे में ऐसा नहीं था।

— JimmyJazzx
स्रोत
3

PHP, 120 139 बाइट्स - 50% = 60 बाइट्स

एक कार्यात्मक दृष्टिकोण:

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

कमांड लाइन से एक इनपुट लेता है, जैसे:

$ php ahny.php 2001

OOP तरीका हमेशा की तरह लंबा (143 बाइट्स) लगता है:

$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)";

संपादित करता

  • बची 18 बाइट । PHP संशोधक का उपयोग करके एक वर्ष जोड़ने के बजाय +1year, मैं अब दिए गए वर्ष को बढ़ाता हूं।
  • एक चर में संग्रहीत करके 1 बाइट को बचाया-1-1 ।
— insertusernamehere
स्रोत
3

सी, स्कोर 53 52 (104 बाइट्स)

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

टोबी स्पाइट से उधार लिया गया आइडिया ; कार्यदिवस का बोनस प्रदर्शन जोड़ा।

चरित्र कोड को अधिक आरामदायक श्रेणी में स्थानांतरित करके स्ट्रिंग को छोटा किया। लघु कार्यदिवस गणना कोड x*5/4%7कार्य करने के लिए सही स्थानांतरण राशि (उदाहरण 43) का चयन करना था ।

— anatolyg
स्रोत
मैं इसे अपने चरित्र कोड सामान ASCII- संगत एन्कोडिंग के लिए प्रतिबंधित करता हूं?
— टोबी स्पाइट
हाँ। कोड 31 से अधिक होना चाहिए, इसलिए कोड को जोड़ने के लिए न्यूनतम संख्या 27 होगी, जिससे स्ट्रिंग दी जाएगी " !!&"।
— अनातोली
2

गणितज्ञ, 145 * 50% = 74 73.5 72.5 बाइट्स

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

मानक तिथि कार्यों का उपयोग करता है।

— LegionMammal978
स्रोत
2

पायथ, 23 बाइट्स

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

किसी भी बोनस के लिए योग्य नहीं है।

इसे यहाँ आज़माएँ ।

शुद्ध अजगर उत्तर के समान।

                        - 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
— नीला
स्रोत
2

जावा, (1-.2) * 323 (1-.5) * 350 348 339 = 258.4 175 174 34.55 बाइट्स

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"";}}

ओह।

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"";
    }
}

इसे ऑनलाइन आज़माएं!

@Kenney को धन्यवाद देने के लिए धन्यवाद कि मैं new Longऔर छोटा कर सकता हूं printf! : डी

— एडिसन क्रम्प
स्रोत
long y=new Long(a[0])6 (12) बाइट्स printfबचाता है , और अन्य 3 (6) बचाता है।
— केनी
2

जीएनयू कोरुटिल्स, 52 51 49 बाइट्स

(98 बाइट्स प्रोग्राम - 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

इनपुट कमांड-लाइन तर्क से है, और आउटपुट स्टैडआउट के लिए है।

व्याख्या

# 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"

परीक्षण चालन:

सभी स्थानीय सेटिंग्स Cया हो सकती हैं 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)

सीमा: यह केवल २१४4४19५५१ ९ तक काम करता है (हालांकि सवाल अब कम सीमा की अनुमति के लिए बदल दिया गया है)।

— टोबी स्पाईट
स्रोत
2

MATL , 28 बाइट्स

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

उदाहरण

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

कोड समझाया गया

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
— लुइस मेंडो
स्रोत
2

पर्ल 6 ,  70   23 बाइट्स

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

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

उपयोग:

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
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

जाप, 12 बाइट्स

U+"♣♠♠♂"cU%4

पायथ उत्तर के साथ, स्ट्रिंग में चार बाइट्स होना चाहिए 05 06 06 0B। इसे ऑनलाइन आज़माएं!

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
स्रोत
2
एक इनाम के इस क्रिसमस उपहार के लिए धन्यवाद! लेकिन क्या कोई मुझे बता सकता है कि मैंने इसे कैसे अर्जित किया?
— ETHproductions
मैंने इतिहास को देखा। जाहिरा तौर पर ओपी ने एक जवाब देने का प्रयास किया, लेकिन इनाम देने के लिए भूल गया, इसलिए समुदाय ने इस जवाब पर आधी प्रतिष्ठा को पारित करने का विकल्प चुना (मुझे लगता है कि यह हाल ही में उठने पर अपनी पसंद को आधार बनाता है)।
2

जेली , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आज तक, जेली के पास कोई सरणी अनुक्रमण नहीं था, इसलिए उपरोक्त को करना होगा। नवीनतम प्रतिबद्ध के बाद से, सरणी अनुक्रमण को ịनिम्न समाधान ( 10 बाइट्स ) के रूप में लागू किया गया है ।

ị6,6,11,5+

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
1
मुझे लगता है कि जेली 10 ~ 16 स्थिरांक के लिए 7 वर्णों को छोड़ सकती है।
— lirtosiast
1

सी # (6.0) .नेट फ्रेमवर्क 4.6 173 बाइट्स - 30% = 121.1 बाइट्स

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}");
— स्टीफ़न शिंकेल
स्रोत
1

जावास्क्रिप्ट ईएस 7, 17 बाइट्स

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

जेएस का उपयोग करते हुए यह मेरा पहला अवसर है। मैंने इसे पायथन स्क्रिप्ट का उपयोग करते हुए पाया, और मेरा मानना ​​है कि यह इष्टतम है। यह काम करता है क्योंकि 0**30 मॉड 7 है, 1**3और 2**3दोनों 1 हैं, और 3**36 है।

— lirtosiast
स्रोत
1
नहीं है घातांक ऑपरेटर** एक ES7 सुविधा? या आप बेबल का उपयोग कर रहे हैं ?
— सम्मिलननामे
@insertusernamehere फिक्स्ड।
— lirtosiast 19
1

पायथन, 23 बाइट्स

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

मेरे जावास्क्रिप्ट उत्तर का एक बंदरगाह।

— lirtosiast
स्रोत
1

पायथ , 12 बाइट्स

++5%^%Q4 3 7

इसे ऑनलाइन आज़माएं! या टेस्ट सूट की जाँच करें।

पायथ , 18 बाइट्स

यह दूसरा दृष्टिकोण मुख्य रूप से @ wizzwizz4 के Pyth उत्तर का एक गोल्फ है ।

J%Q4+?q3J11?qJZ5 6

इसे ऑनलाइन आज़माएं! या टेस्ट सूट की जाँच करें।

व्याख्या

++ 5% ^% Q4 3 7Q - Q का अर्थ है इनपुट का मूल्यांकन और अंत में निहित है।

     % Q4 - इनपुट मॉड 4।
    ^ 3 - घन।
   % 7 - मॉड 7।
 +5 - प्लस 5
+ क्यू - प्लस इनपुट।
— मिस्टर एक्सकोडर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.