एक समारोह या कार्यक्रम है कि स्ट्रिंग आदानों लेता लिखें, पूरी तरह से लिखे गए, अंग्रेजी महीने के नाम शीर्षक मामले में: January, February, March, आदि (शून्य / सीआर / वामो समाप्त ठीक है, कुछ गैर-अल्फा चरित्र के साथ सीमांकित अगर आपने ऐसा चुना) और या तो

दो इनपुट की तुलना करता है, एक सत्य मान लौटाता है यदि दूसरा इनपुट पहले की तुलना में अधिक (महीने के क्रम में) है। समान मानों का परिणाम एक गलत मूल्य है
या कालानुक्रमिक क्रम में उनमें से एक मनमाना अनुक्रम (सूची, सीमांकित स्ट्रिंग, आदि)

(चुनौती का क्रूस एक ऐसी पद्धति / अभिव्यक्ति को परिभाषित कर रहा है जो सही शाब्दिक रूप देता है। कुछ भाषाओं में एक या दूसरे के साथ छोटा उत्तर हो सकता है)

आप strptimeमहीने के नाम को नंबर में बदलने के लिए या महीने के नामों की प्री-कैन्ड मैपिंग के लिए किसी भी आंतरिक समय पार्सिंग विधियों (जैसे ) का उपयोग नहीं कर सकते । स्ट्रिंग्स के गुणों का उपयोग करें, एक पारदर्शक लुक-अप टेबल जिसे आप परिभाषित करते हैं, या कुछ चतुर।

उदाहरण

फंक्शनिंग के उदाहरण, हालांकि पहले नियमों द्वारा निषिद्ध है ...

import datetime
def is_later_month(a, b):
    '''
    Example of prohibited code because it relies on language 
    features about how to parse month names
    '''
    return datetime.strptime(a, '%B') < datetime.strptime(b, '%B')

नीचे दिए गए संस्करण हालांकि ठीक हैं, क्योंकि हम उस जानकारी को कोड करते हैं

months = {
    'January':  1, 'February':  2, 'March':      3,
    'April':    4, 'May':       5, 'June':       6,
    'July':     7, 'August':    8, 'September':  9,
    'October': 10, 'November': 11, 'December':  12,
}
def is_later_month(a, b):
    """
    Returns True/False when comparing two months.
    """
    return months[a] < months[b]

या आप एक छँटाई समारोह कर सकते हैं

months = {'as above...'}
def sort_months(l):
    """
    Sorts list and returns it. Different input and output than the above, 
    but equally valid. Sorting versus comparing might be shorter in your
    favorite language.
    """
    return sorted(l, key=lambda x: months[x])

उदाहरण परीक्षण

assert is_later_month('January', 'February')
assert is_later_month('January', 'December')
assert is_later_month('November', 'December')
assert not is_later_month('July', 'July')
assert not is_later_month('October', 'September')

code-golf date sorting

— निक टी
स्रोत

महीने के नाम को संख्या में अनुवाद करने के लिए आप किसी भी आंतरिक समय पार्सिंग विधियों (जैसे स्ट्रैप्टम) का उपयोग नहीं कर सकते हैं। यह थोड़ा अस्पष्ट है। क्या हम किसी भाषा के पूर्वनिर्धारित शाब्दिक का उपयोग कर सकते हैं जिसमें महीनों के नाम शामिल हैं?

— लुइस मेंडो

मैं अपना उत्तर हटा दूंगा। लेकिन यह अभी भी स्पष्ट नहीं है कि क्या अनुमति है और क्या नहीं है।

— लुइस मेंडो

समस्या यह है कि आप उन सभी संभावित तरकीबों का अनुमान नहीं लगा सकते हैं, जैसे कि पूर्वनिर्धारित सरणियाँ। शायद एक बेहतर विकल्प स्ट्रिंग्स के कम सामान्य सेट का उपयोग करना होता, जैसे कि मेकअप नाम। लेकिन अब बहुत देर हो चुकी है, मुझे लगता है कि

— लुइस मेंडो

क्या मैं स्पष्ट व्यक्त कर रहा हूँ? यदि पायथन में एक बिल्डिन monthsथा जो सभी महीने के नामों की एक सूची थी, तो मैं months[x] < months[y]एक उत्तर के रूप में मना करना चाहता हूं । महीने के नामों की सूची में कुछ और अजीब विशेषताएं (अलग-अलग लंबाई, सामान्यता) हैं जो चुनौती को यादृच्छिक रूप से उत्पन्न स्ट्रिंग्स पर आसान / कठिन बनाती हैं।

— Nick T

हां, मुझे लगता है कि यह स्पष्ट है। मुझे बस इस बात का डर है कि इस तरह के अन्य मामले भी हो सकते हैं जिन्हें आपने स्पष्ट रूप से खारिज नहीं किया है (लेकिन मुझे नहीं पता कि कौन से हैं)

— लुइस मेंडो

41

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

11ị“bMAanlseovc”iµÞ

यह एक विवादास्पद लिंक है जो एक सूची को तर्क के रूप में लेता है और इसे सॉर्ट करता है। इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

जेली मॉड्यूलर, 1-आधारित इंडेक्सिंग का उपयोग करती है। यदि हम 11 अक्षरों को प्राप्त करने के लिए अक्सर महीनों के नामों को दोहराते हैं, तो हमें निम्नलिखित सरणी मिलती है।

J a n u a r y J a n u
F e b r u a r y F e b
M a r c h M a r c h M
A p r i l A p r i l A
M a y M a y M a y M a
J u n e J u n e J u n
J u l y J u l y J u l
A u g u s t A u g u s
S e p t e m b e r S e
O c t o b e r O c t o
N o v e m b e r N o v
D e c e m b e r D e c

11 ^वें (अंतिम) कॉलम में, सभी वर्ण अलग-अलग हैं, इसलिए हम महीनों के क्रम की पहचान करने के लिए उनका उपयोग कर सकते हैं।

यह काम किस प्रकार करता है

11ị“bMAanlseovc”iµÞ  Monadic link. Argument: A (array of months)

                 µ   Combine the preceding chain into a link.
                  Þ  Sort A by that link.
11ị                    Select the 11th character of the month's name.
   “bMAanlseovc”       Find the index of that character in "bMAanlseovc".
                       For 'u' ("January"), this returns 0 (not found).

— डेनिस
स्रोत

1

बस उत्सुक, आप "bMAanlseovc" के साथ महीने की रैंकिंग कैसे कर रहे हैं? पहले चरित्र मैच का सूचकांक?

— ljeabmreosn

मैंने एक स्पष्टीकरण जोड़ा है।

— डेनिस

8

वाह, यह वास्तव में चालाक है!

— ljeabmreosn

15

x86 मशीन कोड, 26 25 बाइट्स

Hexdump:

ff 32 8b 01 34 c0 68 30 5f 43 01 59 f7 e1 91 5a
80 f2 c0 f7 e2 3b c8 d6 c3

विधानसभा कोड:

    push dword ptr [edx];
    mov eax, [ecx];
    xor al, 0xc0;
    push 0x01435f30;
    pop ecx;
    mul ecx;
    xchg eax, ecx;
    pop edx;
    xor dl, 0xc0;
    mul edx;
    cmp ecx, eax;
    _emit 0xd6;
    ret;

निम्नलिखित हैश फ़ंक्शन को महीने के नामों को उचित क्रम में रखने के लिए होता है (ब्रूट बल द्वारा पाया जाता है):

(x ^ 0xc0) * 0x01435f30

यह इनपुट स्ट्रिंग के पहले 4 बाइट्स (32 बिट्स) पर लागू होता है, थोड़ा-एंडियन ऑर्डर में व्यवस्थित होता है। फिर परिणाम की तुलना करना और SALCपरिणाम रजिस्टर (अल) सेट करने के लिए उपयोग करना:

-1 (सच) यदि महीने क्रम में हैं
0 (गलत) यदि दूसरा महीना पहले महीने से पहले आता है (या वे समान हैं)

— anatolyg
स्रोत

4

मैं प्रसन्न हूँ। कोड-गोल्फ विशिष्ट भाषा का उपयोग किए बिना कोड का एक बहुत छोटा टुकड़ा।

— शुबेरफू

13

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

Oḅ32 354*%991µÞ

यहां कोई ऑनलाइन इंटरप्रेटर लिंक नहीं है क्योंकि यह एक धीमी सबमिशन है। प्रोग्राम हैशिंग फ़ंक्शन 354^(input interpreted as base 32 int) % 991को सॉर्ट कुंजी के रूप में उपयोग करता है , जो सही क्रम में आउटपुट देने के लिए होता है। कार्यक्रम जल्द ही किसी भी समय समाप्त नहीं होगा क्योंकि घातांक के परिणाम विशाल हैं - "सितंबर" के लिए, 0.24 क्वाड्रिलियन अंकों के साथ एक संख्या की गणना करने की आवश्यकता है!

जेली स्पष्टीकरण:

              Þ         Sort by...
             µ          Monadic link consisting of...

O                       Convert month string to code points
 ḅ32                    Take base 32
     354*               Perform 354 to the power of the result
         %991           Take modulo 991

अवधारणा स्क्रिप्ट के पायथन प्रमाण - powमॉड्यूलर घातांक के उपयोग पर ध्यान दें , जो बहुत अधिक कुशल है:

import random

def base_convert(string, base):
    total = 0

    for c in string:
        total = total * base + ord(c)

    return total

def month_hash(month):
    return pow(354, base_convert(month, 32), 991)

months = ["January", "February", "March", "April", "May", "June", "July",
    "August", "September", "October", "November", "December"]
random.shuffle(months)

print(months)
print(sorted(months, key=month_hash))

— Sp3000
स्रोत

5

"कोई भी ऑनलाइन दुभाषिया लिंक यहाँ नहीं है क्योंकि यह एक धीमी गति से सबमिशन है।" किस मामले में, आप महीनों को हाथ से सॉर्ट कर सकते हैं। ;-)

— 12

हो सकता है कि आप pow / mod को ऑप्टिमाइज़ करने के लिए एक फीचर रिक्वेस्ट PR कर सकते थे ...

— निक टी

@ निकट यह एक उत्कृष्ट विचार है, लेकिन दुर्भाग्य से इंटरप्रेटर के सेट अप (जिस तरह से प्रत्येक ऑपरेटर को अलग से परिभाषित किया गया है) के साथ, यह थोड़ा मुश्किल हो सकता है। और जेली उन ऑपरेटरों के साथ अच्छी तरह से काम नहीं करती जिनके पास दो से अधिक तर्क हैं, इसलिए एक अलग ऑपरेटर को परिभाषित करने से बहुत काम नहीं होगा ...

— Sp3000

एक अलग ऑपरेटर या कुछ भी नहीं, बस यह देखने के लिए कुछ गहन आत्मनिरीक्षण किया जाता है कि क्या मॉड्यूलर ऑपरेशन के बाद एक शक्ति संचालन होता है। आसान लगता है? : पी

— निक टी

5

पायथन, 64 61 57 बाइट्स

lambda x,y,g='bMAanlseovc'.find:g((x*4)[10])<g((y*4)[10])

लैम्ब्डा इनपुट के रूप में दो महीने लेता है और उनकी तुलना करता है। Ideone पर इसका परीक्षण करें ।

3 बाइट को बंद करने के लिए @ljeabmreosn को धन्यवाद और 3 और के लिए मार्ग प्रशस्त!

— डेनिस
स्रोत

2

अंत में, आप उस काले जादू के पीछे के रहस्य को प्रकट करते हैं जिसका उपयोग आपने जल्दी से अपने जेली उत्तर में सही महीने की गणना करने के लिए किया था!

— वैल्यू इंक

1

काम s[10%len(s)]करने के लिए बदल जाएगा (4*s)[10]?

— ljeabmreosn

1

@ljeabmreosn जो वास्तव में काम करता है। धन्यवाद!

— डेनिस

1

अभी तक लंबर में डिफ़ॉल्ट तर्कों का <हड़ताल> अब </ हड़ताल> का उपयोग नहीं देखा गया है:

— निक टी

4

पायथन, 81 71 बाइट्स

lambda x,y,m='anebarprayunulugepctovec':m.index(x[1:3])<m.index(y[1:3])

https://repl.it/CluN/1

mदो महीने के दूसरे और तीसरे अक्षर के सूचकांक की तुलना करता है ।

83 बाइट संस्करण महीनों की सूची को सॉर्ट करने के लिए:

lambda x:sorted(x,key=lambda i:'JanFebMarAprMayJunJulAugSepOctNovDec'.index(i[:3]))

— atlasologist
स्रोत

3

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

@ एटलसोलॉजिस्ट के उत्तर से छंटनी की महीने का उपयोग करता है ।

->a{a.sort_by{|i|"anebarprayunulugepctovec".index i[1,2]}}

63 बाइट्स पर तुलनात्मक फ़ंक्शन थोड़ा लंबा है

->a,b{m=->i{"anebarprayunulugepctovec".index i[1,2]};m[a]<m[b]}

— मूल्य स्याही
स्रोत

3

जे, 66 65 बाइट्स

इस तथ्य का उपयोग करता है कि f (m) = 2 * (ord (m [0]) + ord (m [-1])) // len (m) 12 महीनों के सीमित डोमेन में एक वैध कार्य है:

>/@:('7/HEäWa<+0'&i.@(3 :'u:<.(#>y)%~+:+/3&u:({.>y),({:>y)')"0)"1

उपयोग:

   bigger =: >/@:('7/HEäWa<+0'&i.@(3 :'u:<.(#>y)%~+:+/3&u:({.>y),({:>y)')"0)"1
   bigger ('May'; 'March')
1
   bigger ('May'; 'June')
0

(किसी भी तरह से यह सबसे अच्छा विचार नहीं है, लेकिन मैं किसी की रैंकिंग चाल चोरी नहीं करना चाहता था!)

यहाँ @ एटलसोलॉजिस्ट की विधि का उपयोग करते हुए एक छोटा संस्करण है :

जे, 63 बाइट्स

m=:[:}.3{.]
[:>/(12 2$'anebarprayunulugepctovec')i.([:m[),:[:m]

उपयोग:

   bigger =: [:>/(12 2$'anebarprayunulugepctovec')i.([:m[),:[:m]
   'January' bigger 'May'
0
   'June' bigger 'May'
1

और @ डेनिस की चतुर विधि का उपयोग करते हुए बहुत छोटा संस्करण :

जे, 34 बाइट्स

>&:('ubMAanlseov'&i.@:{.@:(10&|.))

— ljeabmreosn
स्रोत

3

हास्केल, 74 बाइट्स

मेरा पहला कोड गोल्फ, याय! इस एक का सामान्य विचार जेली में शीर्ष उत्तर से प्रेरित है, और यह तथ्य कि जब महीने के नाम चक्रित होते हैं, तो 11 वां वर्ण हमेशा अद्वितीय होता है।

e s=head.drop 10$cycle s;a#b=elem(e b)$tail$dropWhile(/=e a)"ubMAanlseovc"

यहां यह देखने के लिए कि यह कैसे काम करता है, एक अन-गोल्ड संस्करण है:

order :: String
order = "ubMAanlseovc"

eleventhChar :: String -> Char
eleventhChar
  = head . drop 10 $ cycle

inOrder :: String -> String -> Bool
inOrder m1 m2
  = elem (eleventhChar m2) (tail $ dropWhile (/= eleventhChar m1) order)

eसमारोह eleventhChar समारोह (उदासी monomorphism प्रतिबंध मुझे लगता है कि के कारण 4 बाइट बंद पट्टी नहीं कर सकते हैं) और प्रतिनिधित्व #करने के लिए इन्फ़िक्स समारोह मेल खाती inOrderकार्य करते हैं।

एक छोटा सा समाधान है, लेकिन अधिक बाइट्स को बंद करने के तरीके हो सकते हैं (मुझे यह लिखते समय कुछ मिला!)

— कुंज
स्रोत

आप को छोटा कर सकता e s=head.drop 10$cycle sहै जैसे आप का उपयोग करके अपने स्पष्टीकरण में किया था .के बजाय $: e=head.drop 10.cycle। हालाँकि सूची सूचकांक ऑपरेटर !!का उपयोग करना और भी कम है:e=(!!10).cycle

— Laikoni

शानदार सुझाव। कभी-कभी आप इन बातों को नजरअंदाज कर देते हैं। बहुत बहुत धन्यवाद। शीघ्र ही इसे संपादित करेंगे।

— बोवर

2

जावा, 133 123

golfed:

boolean f(String a,String b){return h(a)<h(b);}int h(String s){return"anebarprayunulugepctovec".indexOf(s.substring(1,3));}

मैं कोडांतरक उत्तर की तरह एक चतुर तकनीक की खोज कर रहा था, लेकिन यह पता लगाने में बहुत लंबा समय लग रहा था इसलिए मैं उसी तकनीक के साथ गया जिसका उपयोग हर कोई करता था।

Ungolfed:

import java.util.Random;

public class SortTheMonthsOfTheYear {

  public static void main(String[] args) {
    // @formatter:off
    String[] MONTHS = new String[] {
        "January", "February", "March",
        "April",   "May",      "June",
        "July",    "August",   "September",
        "October", "November", "December"
    };
    // @formatter:on

    Random r = new Random();
    for (int i = 0; i < 100; ++i) {
      int m1 = r.nextInt(MONTHS.length);
      int m2 = r.nextInt(MONTHS.length);
      System.out.println("Input: " + MONTHS[m1] + " < " + MONTHS[m2]);
      System.out.println("Expected: " + (m1 < m2));
      System.out.println("Actual:   " + new SortTheMonthsOfTheYear().f(MONTHS[m1], MONTHS[m2]));
      System.out.println();
    }
  }

  // Begin golf
  boolean f(String a, String b) {
    return h(a) < h(b);
  }

  int h(String s) {
    return "anebarprayunulugepctovec".indexOf(s.substring(1, 3));
  }
  // End golf

}

आप substringइसके बजाय उपयोग कर सकते हैंcharAt

— anatolyg

@anatolyg धन्यवाद, मुझे यकीन नहीं है कि वह कैसे मुझसे बच गया। मैं इसलिए भी हटा पा रहा था "" +क्योंकि charअब कोई कच्चे एस नहीं हैं।

2

लिनक्स 44 40 बाइट्स पर एआरएम मशीन की भाषा

e28fc001     add ip, pc, #1
e12fff1c     bx ip
6803         ldr r3, [r0, #0]
6808         ldr r0, [r1, #0]
4a05         ldr r2, [pc, #20]
f08303dd     eor.w r3, r3, #221
f08000dd     eor.w r0, r0, #221
4353         muls r3, r2
4350         muls r0, r2
4283         cmp r3, r0
bfac         ite ge
2000         movge r0, #0
2001         movlt r0, #1
4770         bx lr
2f68f24c

मैंने अनातोलीग के समाधान की तुलना में एक अलग हैश फ़ंक्शन का उपयोग किया और कुछ बाइट्स को बचाने के लिए अंगूठे के निर्देशों का उपयोग करने की कोशिश की (हालांकि मैंने 8 बाइट्स को अंगूठे मोड में प्रवेश किया)।

आप इसे रास्पबेरी पाई या एंड्रॉइड डिवाइस पर GNURoot के साथ आज़मा सकते हैं।

int main(int argc,char**argv){
return ((int(*)(char*,char*))"\
\1\xc0\x8f\xe2\
\x1c\xff\x2f\xe1\
\3\x68\x8\x68\
\5\x4a\x83\xf0\
\xdd\3\x80\xf0\
\xdd\x43\x53\x43\
\x50\x4a\x83\x42\
\xac\bf\0\x20\
\1\x20\x70\x47\
\x4c\xf2\x68\x2f\
")(argv[1],argv[2]);}

चलाने के लिए जैसे कुछ दर्ज करें

$ ./foo January February; echo $?

वर्तमान संस्करण अब समानता मामले (और अन्य) को सही ढंग से संभालता है।

— ceilingcat
स्रोत

मुझे लगता है कि आपको उस कोड की आवश्यकता नहीं है जो स्पष्ट रूप से अंगूठे मोड में स्विच करता है। मुझे जो याद है, उससे आपको केवल यह बताने की जरूरत है कि लिंकर आपकी प्रक्रिया अंगूठा मोड में है, और लिंकर आपकी प्रक्रिया के पते में LSB को 1 पर सेट कर देगा, इसलिए प्रोसेसर आपके कोड को कॉल करने पर स्वचालित रूप से थंब मोड में स्विच हो जाएगा।

— अनातोली

इसके अलावा, क्या करता bfacहै?

— अनातोली

@anatolyg ite geसशर्त रूप से अगले निर्देश ( movge r0, #0) को क्रियान्वित करता है r3 >= r0, अन्यथा, उसके बाद जो निर्देश निष्पादित होता है ( movlt r0, #1)। मुझे लगता है कि यहां कुछ बाइट्स दस्तक देने के लिए जगह है, लेकिन मुझे इस पर काम करने का समय नहीं मिला :-)

— छत

1

पर्ल 6 , 55 बाइट्स

*.sort({index 'anebarprayunulugepctovec',.substr(1,2)})

यह तुलना संस्करणों के लिए कुछ और बाइट्स की आवश्यकता होगी:

{[<] @_».&{index 'anebarprayunulugepctovec',.substr(1,2)}}
{[<] .map: {index 'anebarprayunulugepctovec',.substr(1,2)}}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @months = <
  January February March April May June July
  August September October November December
>;

my &month-sort = *.sort({index 'anebarprayunulugepctovec',.substr(1,2)});

plan 100;

for ^100 {
  # ｢.pick(*)｣ returns all elements in random order
  is-deeply month-sort(@months.pick(*)), @months.List;
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

हास्केल, 118 अक्षर

data M=Ju|Fr|Mc|Ai|My|Je|Jy|Au|St|Oo|Ne|De deriving(Ord,Eq,Read)
r=read.([head,last]<*>).lines.take 4
a#b=(r a::M)<r b

इस तथ्य का उपयोग करता है कि प्रत्येक महीने का नाम अपने पहले और चौथे अक्षर (या मई के लिए 3) में एक डेटा प्रकार को परिभाषित करने के लिए अद्वितीय है जो स्वचालित रूप से पार्स और भाषा की तुलना में हो सकता है। 'आर' फ़ंक्शन पहले चार वर्णों (या कम) को हथियाने के द्वारा एक स्ट्रिंग को परिवर्तित करता है, फिर पहले और अंतिम को उठाता है। तब मूल्यों की तुलना करने के लिए 'a # b' एक ऑपरेटर है:

*Main> "June" # "March"
False
*Main> "June" # "July"
True
*Main> "January" # "July"
True
*Main> "January" # "November"
True
*Main> "December" # "November"
False

संभवतः अधिक कुशल तरीके से किया जा सकता था, लेकिन मैं महीनों का प्रतिनिधित्व करने के लिए एक उपयोगी डेटा प्रकार का उपयोग करके इसे करने की कोशिश करना चाहता था।

— जूल्स
स्रोत

1

पॉवरशेल, 96 88 63 बाइट्स

$input|Sort{'anebarprayunulugepctovec'.IndexOf((-join$_[1,2]))}

जैसे

PS C:\Code> 'February', 'January', 'December', 'April' | .\monthsort.ps1
January
February
April
December

अब सूची को क्रम में क्रमबद्ध करने की दूसरी चुनौती है; पिछले संस्करणों ने दो महीने के परीक्षण की तुलना की:

v2.
$l,$r=$args|%{-join$_[1,2]};($d='anebarprayunulugepctovec').indexof($l)-lt$d.IndexOf($r)

v1.
$l,$r=$args|%{-join$_[1,2]};$r-match('an|eb|ar|pr|ay|un|ul|ug|ep|ct|ov|ec'-split$l)[1].Trim('|')

e.g.

PS C:\code> .\Test-MonthsInOrder.ps1 January February
True

माह नाम के दूसरे दो वर्णों के आधार पर।

— TessellatingHeckler
स्रोत

1

पायथन 83 82 बाइट्स

lambda x,y,m=(lambda a:'2&9<@FD6A?L%'.find(chr(sum(map(ord,a[:3]))%77))):m(x)<m(y)

टेस्ट: https://repl.it/repls/TimelyDecimalBrowsers

पहले 3 वर्णों का योग बनाता है और खोज करने के लिए एक एकल वर्ण बनाता है।

— Baris
स्रोत

0

जावास्क्रिप्ट, 118 बाइट्स

u=p=>{p=p.split` `.sort();c=[];for(i=0;i<12;i++){c.push(p["4 3 7 0 8 6 5 1 11 10 9 2".split` `[i]]);}return c.join` `}

छुटकारा पाने cऔर उपयोग करने के द्वारा, और अधिक गोल्फिंग की जा सकती है array.map, लेकिन अभी मेरे पास यही है ...

— गंजा बंटा
स्रोत

for(i=0;i<12;)c.push(p[[4,3,7,0,8,6,5,1,11,10,9,2][i++]]);

— Pinkfloydx33

0

बैश, 101 बाइट्स

यह फ़ंक्शन__लेटर जैसा है

f(){ s=ubMAanlseovc a=$1$1$1 b=$2$2$2 c=${a:10:1} d=${b:10:1} e=${s%$c*} f=${s%$d*};((${#e}<${#f}));}

परीक्षा

$ f January December && echo later || echo not later
not later

— user58494
स्रोत

0

k4, 29

{x@<"ubMAanlseovc"?(*|11#)'x}

@ डेनिस के जेली उत्तर का एक बंदरगाह ।

यह तुलनित्र है, तुलनित्र नहीं; दिलचस्प है, तुलनित्र एक ही एल्गोरिथ्म द्वारा तुच्छ रूप से लागू करने योग्य है, और केवल एक बाइट लंबे समय तक:

{(<)."ubMAanlseovc"?(*|11#)'x}

— हारून डेविस
स्रोत

0

बैश + कोरुटिल्स, 94 बाइट्स 93 बाइट्स

s(){ x=FMAyulgSOND;for y;{ rev<<<${y:0:3}|tr -d -C $x|tr $x C-M;echo B$y;}|sort|cut -f2 -dB;}

यह एक परिवर्तन के साथ आने का एक प्रयास है जो कि शाब्दिक रूप से है। यदि आप ट्रांसफॉर्म की को करीब से देखते हैंFMAyulgSOND देखते हैं तो आप दिसंबर के माध्यम से फरवरी को देख सकते हैं (जनवरी ट्रांसफ़ॉर्म होने के बाद खाली हो जाता है; इसे विभाजक के रूप में 'बी' के उपयोग से ऊपर खींच लिया जाता है)। उलट, काट-छाँट, और गैर-कुंजी अक्षरों को हटाने से इस चाल को खींचने की अनुमति मिलती है।

सी लोकेल का उपयोग करके 90 बाइट्स

s(){ x=FMAyulgSOND;for y;{ rev<<<${y:0:3}|tr -d -C $x|tr $x C-M;echo \␉$y;}|sort|cut -f2;}

... जहाँ where टैब वर्ण है।

सी लोकेल का उपयोग करके 80 बाइट्स

s(){ x=anebarprayunulugepctovec;for y;{ echo ${x%${y:1:2}*}\␉$y;}|sort|cut -f2;}

... @ एटलसोलॉग की विधि का उपयोग करना। अधिक स्थानों के साथ काम करने के लिए इस दृष्टिकोण का उपयोग करने का एक तरीका है।

टेस्ट / प्रयोग

s December November October September August July June May April March February January

आउटपुट:

January
February
March
April
May
June
July
August
September
October
November
December

— एच वाल्टर्स
स्रोत

वर्ष के महीनों को क्रमबद्ध करें

उदाहरण

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

पृष्ठभूमि

यह काम किस प्रकार करता है

x86 मशीन कोड, 26 25 बाइट्स

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

पायथन, 64 61 57 बाइट्स

पायथन, 81 71 बाइट्स

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

जे, 66 65 बाइट्स

जे, 63 बाइट्स

जे, 34 बाइट्स

हास्केल, 74 बाइट्स

जावा, 133 123

लिनक्स 44 40 बाइट्स पर एआरएम मशीन की भाषा

पर्ल 6 , 55 बाइट्स

परीक्षा:

हास्केल, 118 अक्षर

पॉवरशेल, 96 88 63 बाइट्स

पायथन 83 82 बाइट्स

जावास्क्रिप्ट, 118 बाइट्स

बैश, 101 बाइट्स

k4, 29

बैश + कोरुटिल्स, 94 बाइट्स 93 बाइट्स

सी लोकेल का उपयोग करके 90 बाइट्स

सी लोकेल का उपयोग करके 80 बाइट्स