निकटतम विशेष आम वर्ष कब है?

Question

एक आम वर्ष एक ऐसा वर्ष है जो एक लीप वर्ष नहीं है और जहां वर्ष का पहला और अंतिम दिन एक ही दिन होता है। एक विशेष आम वर्ष वह है जो सोमवार को शुरू होता है और सोमवार को भी समाप्त होता है।

आपकी चुनौती एक ऐसा कार्यक्रम / समारोह तैयार करना है, जब एक वर्ष के लिए इनपुट को सबसे आम वर्ष मिले, यदि वह एक सामान्य वर्ष है तो स्वयं को आउटपुट करना है। यदि वर्ष इससे पहले के करीब है, तो इससे पहले कि वह बड़ा उत्पादन करता है।

इनपुट

रेंज में परीक्षण करने के लिए वर्ष का प्रतिनिधित्व करने वाला पूर्णांक 1600 <= x <= 2100।

उत्पादन

एक पूर्णांक निकटतम विशेष आम वर्ष का प्रतिनिधित्व करता है।

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

2017 -> 2018
2018 -> 2018
1992 -> 1990
1600 -> 1601
2100 -> 2103
1728 -> 1731 (lies between 1725 and 1731)

टिप्पणियाँ

दिए गए रेंज में सभी 54 साल पहले से ही लिंक किए गए विकिपीडिया लेख में दिखाए गए हैं। मैं उन्हें संदर्भ के लिए यहां भी प्रदान करूंगा:

1601, 1607, 1618, 1629, 1635, 1646, 1657, 1663, 1674, 1685, 1691
1703, 1714, 1725, 1731, 1742, 1753, 1759, 1770, 1781, 1787, 1798
1810, 1821, 1827, 1838, 1849, 1855, 1866, 1877, 1883, 1894, 1900
1906, 1917, 1923, 1934, 1945, 1951, 1962, 1973, 1979, 1990
2001, 2007, 2018, 2029, 2035, 2046, 2057, 2063, 2074, 2085, 2091
2103 (Needed for 2097 to 2100)

Comments

बस लोगों को बाहर जाने में मदद करने के लिए, अनुक्रम जाना प्रतीत होता है 6, 11, 11। IE 6 साल बाद पहला है, 11 साल बाद दूसरा है, 11 साल बाद दूसरा है, 6 साल बाद दूसरा है, आदि

— Skidsdev

@ माय्यूब काफी नहीं। वास्तविक अनुक्रम "6, 11, 11, 6, 11, 11, 6, 11, 11, 6, 12, 11, 11, 6, 11, 11, 6, 11, 11, 6, 11, 12, 11 है।" , 6, 11, 11, 6, 11, 11, 6, 11, 6, 6, 11, 6, 11, 11, 6, 11, 11, 6, 11, 11, 6, 11, 11, 6, 11 , 11, 6, 11, 11, 6 "(12 के नोट और 6, 11, 6, 6, 11, 6)

— मार्टिन एंडर

चूंकि कैलेंडर प्रत्येक 400 वर्षों में दोहराता है, अनुक्रम का प्रासंगिक (आवधिक) भाग "6, 11, 11, 6, 11, 11, 6, 11, 11, 6, 12, 11, 6, 11, 11, 11 है।" , 6, 11, 11, 6, 11, 12, 11, 6, 11, 11, 6, 11, 11, 6, 11, 6, 6, 11, 6, 11, 6, 11, 11, 11, 6 , 11, 11 "है। अगर तीन अनियमितताओं के कारण कोई भी इसके साथ बाइट्स बचा सकता है, तो मैं प्रभावित होऊंगा।

— मार्टिन एंडर

मेरे लिए 2k पर बधाई! : पी

— थेथालकोडर

a year that is not a leap year and where the first and last day of the year are on the same dayउस परिभाषा का दूसरा भाग बेमानी है। सभी गैर-लीप वर्ष उसी दिन शुरू होते हैं और समाप्त होते हैं, ठीक 52 सप्ताह और एक दिन (365 दिन) लंबे होते हैं।

— जॉन गॉर्डन

Answer 1

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

“Þıİs|9ṗ[¿¶F’ṃ“©€¿‘⁽£d;+\ạÐṂ⁸Ṁ

एक पूर्णांक वर्ष लेने और वापस करने के लिए एक अद्वैत लिंक।

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें।

कैसे?

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

“Þıİs|9ṗ[¿¶F’ṃ“©€¿‘⁽£d;+\ạÐṂ⁸Ṁ - Main link: number y
                   ⁽£d         - augmented base 250 literal = 1601
“Þıİs|9ṗ[¿¶F’                  - base 250 literal = 20129386383114231907032071
              “©€¿‘            - code page index list = [6,12,11]
             ṃ                 - base decompression = [6,11,11,6,11,11,6,11,11,6,12,11,11,6,11,11,6,11,11,6,11,12,11,6,11,11,6,11,11,6,11,6,6,11,6,11,11,6,11,11,6,11,11,6,11,11,6,11,11,6,11,11,6,12]
                      ;        - concatenate = [1601,6,11,11,6,11,11,6,11,11,6,12,11,11,6,11,11,6,11,11,6,11,12,11,6,11,11,6,11,11,6,11,6,6,11,6,11,11,6,11,11,6,11,11,6,11,11,6,11,11,6,11,11,6,12]
                       +\      - reduce with addition = [1601,1607,1618,1629,1635,1646,1657,1663,1674,1685,1691,1703,1714,1725,1731,1742,1753,1759,1770,1781,1787,1798,1810,1821,1827,1838,1849,1855,1866,1877,1883,1894,1900,1906,1917,1923,1934,1945,1951,1962,1973,1979,1990,2001,2007,2018,2029,2035,2046,2057,2063,2074,2085,2091,2103]
                            ⁸  - link's left argument, y
                          ÐṂ   - filter keep if maximal:
                         ạ     -   absolute difference
                             Ṁ - maximum (alternatively tail, Ṫ, since increasing)

Answer 2

PHP, 67 बाइट्स

for(;date(LN,mktime(0,0,0,1,1,$y=$argn+$i))>1;)$i=($i<1)-$i;echo$y;

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

या

for(;date(LN,strtotime("1/1/".$y=$argn+$i))>1;)$i=($i<1)-$i;echo$y;

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

विस्तारित

for(;
date(LN,mktime(0,0,0,1,1,$y=$argn+$i)) # N is 1 for Monday and L is 0 for Non leap year
>1;) # loop so long as expression is not 1
  $i=($i<1)-$i; # set $i 0,1,-1,2,-2 ...
echo$y; # Output Year

तारीख

Comments

एक बाइट सहेजें:$i=($i<1)-$i;

— क्रिस्टोफ

Answer 3

अजगर 2 , 129 124 118 बाइट्स

a=[11,11,6]*13
a[29:29]=a[19:19]=12,
a[10:10]=6,6
n=input()
o=[2401-n]
for i in a*2:o+=o[-1]-i,
print n+min(o,key=abs)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों की कोशिश करें सबसे
पहले, अनुक्रम उत्पन्न (उलट) होता है a, फिर2401 - input_year अनुक्रम पर घटाए जाने वाले शुरुआती मूल्य के रूप में उपयोग किया जाता है।
इस तरह सूची में oसभी सामान्य वर्षों और इनपुट के बीच अंतर होगा, निकटतम वर्ष शून्य (सकारात्मक या नकारात्मक) के निकटतम संख्या होगी, फिर (min, key=abs)इनपुट के साथ इसे वापस जोड़ा जाएगा।

साथ में datetime , 119 बाइट्स

lambda i:i+min([y-i for y in range(2200,1500,-1)if datetime(y,1,1).weekday()<1and y%400],key=abs)
from datetime import*

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

Comments

क्या यह अनुक्रम से दूर वर्षों की सूची उत्पन्न करता है?

— TheLethalCoder

@TheLethalCoder थोड़े, थोड़ा स्पष्टीकरण जोड़ा

— रॉड

Answer 4

05AB1E , 41 बाइट्स

6xD<Š)•HΘ%A°,SΔA)u•3вè.pO0¸ì1601+DI-ÄWQϤ

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

व्याख्या

6xD<Š)                                     # push the list [11,6,12]
      •HΘ%A°,SΔA)u•                        # push the number 20129386383114231907032071
                   3в                      # convert to a base-3 digit list
                     è                     # use this to index into the first list
                      .p                   # get list of prefixes
                        O                  # sum each sublist
                         0¸ì               # prepend 0
                            1601+          # add 1601 to each
                                 D         # duplicate
                                  I-       # subtract input from each
                                    Ä      # calculate absolute value
                                     WQÏ   # keep only the years that have the 
                                           # smallest absolute difference from input
                                        ¤  # get the last one

Answer 5

जावास्क्रिप्ट (ईएस 6), 77 बाइट्स

f=(y,z=y,d=m=>new Date(y,m,!m||31).getDay()-1)=>d(0)|d(11)?f(z<y?z-1:z+1,y):y

<input type=number value=2001 oninput=o.textContent=f(+this.value)><pre id=o>2001

Answer 6

गणितज्ञ, 70 बाइट्स

Max@Nearest[Select[Range[7!],!LeapYearQ@{#}&&DayName@{#}==Monday&],#]&

वर्ष ५०४० (= and!) तक के सभी विशेष सामान्य वर्षों की सूची बनाता है और फिर एक टाई के मामले में अधिकतम लेते हुए, इनपुट के सबसे करीब पाता है।

Comments

यह उस तरह का उत्तर था जिसकी मैं अपेक्षा कर रहा था, सूची तैयार करें और उसकी तुलना करें। यह देखना दिलचस्प होगा कि क्या कोई उत्तर खोजने के लिए "अनुक्रम" का उपयोग कर सकता है।

— TheLethalCoder

Whaaaa ... PHP ने Mathematica को हराया?

— बिशप

मैं आपके कोड के साथ खेल रहा था और इस के साथ आया था: (n = 1; t = #; जबकि [! DayName @ {t} == सोमवार || LeapYearQ @ {t}, n ++; t = # - (- 1) ) ^ n * मंजिल [n / 2]]; t) और क्या आप इसे //.t/ के साथ बदलकर गोल्फ कर सकते हैं; आदि? मैंने कोशिश की, लेकिन मैं नहीं कर सकता ...

— J42161217

Answer 7

जावा 7, 217 बाइट्स

import java.util.*;int c(int y){return d(y,1);}int d(int y,int x){Calendar c=Calendar.getInstance(),d=Calendar.getInstance();c.set(y,0,1);d.set(y,11,31);return c.get(7)==d.get(7)&c.get(7)==2?y:d(y+x,x>0?-++x:-(--x));}

स्पष्टीकरण:

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

import java.util.*;                   // Required import for Calendar

int c(int y){                         // Method with integer parameter and integer return-type
  return d(y,1);                      //  Call second method with additional parameter
}                                     // End of method (1)

int d(int y,int x){                   // Method (2) with two integer parameters and integer return-type
  Calendar c=Calendar.getInstance(),  //  Create two Calendar instances
           d=Calendar.getInstance();
  c.set(y,0,1);                       //  Set one to 01 January yyyy
  d.set(y,11,31);                     //  and one to 31 December yyyy
  return c.get(7)==d.get(7)           //  If both are the same day of the week
         &c.get(7)==2?                //  and it is a Monday:
          y                           //   Return the input-year
         :                            //  Else:
          d(y+x,                      //   Recursive-call with year + `x`
                x>0?-++x:-(--x));     //   and change `x` to the next to check
                                      //   +1,-2,+3,-4,+5,-6,etc.
}                                     // End of method (2)

Comments

अगर एक्स हमेशा 1 होने जा रहा है, क्यों नहीं बस int सी () {} और परिवर्तन को दूर int d(int y, int x){}करने के लिएd(int y){int x = 1;...}

— ब्रायन एच

@BrianH। क्योंकि मैं एक पुनरावर्ती-कॉल करता xहूं, जो उपयोग करता है , इसलिए यदि मैं इसे 1विधि के शीर्ष पर हर बार रीसेट करता हूं, तो xगलत है और पुनरावर्ती-कॉल विफल हो जाएगा।

— केविन क्रूज़सेन

Answer 8

MATL , 32 31 बाइट्स

`G@2&\wEq*-XJtQv24KUhBh9XO77-}J

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

Answer 9

सी #, 183 बाइट्स

गेंद को थोड़ा सा लुढ़कने के लिए, यहाँ एक कार्यान्वयन है जो मैंने खुद किया है। मुझे पूरा यकीन है कि यह अभी भी नीचे गिरा हो सकता है अगर कोई भी नए जवाब के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करना चाहता है।

namespace System.Linq{n=>Enumerable.Range(1,9999).Where(y=>!DateTime.IsLeapYear(y)&(int)new DateTime(y,1,1).DayOfWeek==1).GroupBy(y=>Math.Abs(n-y)).OrderBy(g=>g.Key).First().Last();}

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

पूर्ण / स्वरूपित संस्करण, यह भी दिए गए रेंज के लिए सभी आउटपुट दिखाता है जब भागा।

namespace System.Linq
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int, int> f = n =>
                Enumerable.Range(1, 9999)
                          .Where(y => !DateTime.IsLeapYear(y)
                                    & (int)new DateTime(y, 1, 1).DayOfWeek == 1)
                          .GroupBy(y => Math.Abs(n - y))
                          .OrderBy(g => g.Key)
                          .First()
                          .Last();

            for (int y = 1600; y <= 2100; ++y)
            {
                Console.WriteLine($"{y} -> {f(y)}");
            }

            Console.ReadLine();
        }
    }
}

Answer 10

रूबी, 145 बाइट्स

f=->i{i+(1.upto(i).map{|m|Time.new(y=i+m).monday?&&Time.new(y,6).friday?? m:Time.new(y=i-m).monday?&&Time.new(y,6).friday?? -m :nil}.find{|a|a})}

इनपुट के रूप में प्रारंभ वर्ष लेने वाले एक लंबो को परिभाषित करता है - f[2017] => 2018

रूबी मानक पुस्तकालय प्यार करता हूँ! wday==1के रूप में एक ही लंबाई है monday?और असीम रूप से कम शांत :)। विशेष आम वर्ष की जांच इस तथ्य से की जाती है कि सोमवार से शुरू होने वाले एक आम वर्ष में, 1 जून शुक्रवार है ("शुक्रवार" समान दिन का सबसे छोटा नाम है!)

दुर्भाग्य से, यह दोनों दिशाओं में खोज करने में अच्छा नहीं है।