पहला कोड गोल्फ डेकाथलॉन [बंद]


48

कार्य

सभी प्रतियोगी 10 कार्यों की निम्न सूची को हल करने का प्रयास करते हैं:

  1. इनपुट से एक सकारात्मक पूर्णांक n पढ़ें और पहले n गैर-नकारात्मक पूर्णांकों के क्यूब्स का योग लौटाएं ।

    इनपुट के लिए 1, यह वापस आ जाना चाहिए 0

  2. एक सकारात्मक पूर्णांक n को इनपुट से पढ़ें और एक सत्य मान वापस करें यदि केवल और केवल n एक Mersenne प्राइम है

  3. इनपुट से एन पूर्णांकों की एक गैर-रिक्त सूची पढ़ें और उनका माध्य वापस करें ।

    यदि n सम है, तो दो मध्य मानों का कम उपयोग करें।

    उदाहरण के लिए, का माध्य [1 4 3 2]है 2

  4. एक पूर्णांक (धनात्मक, ऋणात्मक या 0), या इनपुट से बेस 10 या अनार्य में एक स्ट्रिंग प्रतिनिधित्व , प्रमुख शून्य के बिना (इनपुट 0 के अपवाद के साथ) अपने अंकों को नकारात्मक में लौटाएं

    आउटपुट को किसी भी सुविधाजनक तरीके (अंकों, सरणी, स्ट्रिंग, आदि) में स्वरूपित किया जा सकता है।

  1. वापसी pneumonoultramicroscopicsilicovolcanoconiosis

  2. वर्तमान तिथि की जाँच करें और Happy New Year!यदि ग्रेगोरियन कैलेंडर के अनुसार उचित हो तो वापस लौटें ।

  3. छद्म-बेतरतीब ढंग से यूनिकोड ब्लॉक CJK यूनिफाइड आइडॉग्स एक्सटेंशन-ए (U + 3400 - U + 4DB5) से 64 अद्वितीय असाइन किए गए कोड बिंदुओं का चयन करें और संबंधित वर्णों की स्ट्रिंग लौटाएं।

    सभी संभावित तारों को चयनित होने की समान संभावना होनी चाहिए।

  4. इनपुट से मुद्रण योग्य ASCII वर्णों के दो तारों को पढ़ें और एक सत्य मान लौटाएं यदि और केवल पहले स्ट्रिंग का चरित्र दूसरे स्ट्रिंग के बाद का रूप बनाता है।

    उदाहरण के लिए, abc, axbxctruthy लौटना चाहिए और bac, axbxcfalsy लौटना चाहिए।

  1. पूर्णांकों की एक बहुआयामी, आयताकार सरणी और एक पूर्णांक पढ़ें n इनपुट से और से गुणा सभी पूर्णांकों के साथ संशोधित सरणी लौट एन

  1. इनपुट से एक गैर-नकारात्मक पूर्णांक n पढ़ें और n ट्रेन वैगनों की एक श्रृंखला लौटाएं , जैसा कि नीचे दिखाया गया है।

    N = 3 के लिए उदाहरण आउटपुट :

     ______   ______   ______ 
    |      | |      | |      |
     ()--() ~ ()--() ~ ()--()
    

    आउटपुट व्हॉट्सएप की किसी भी राशि से घिरा हो सकता है जब तक कि यह उदाहरण में दिखता है।

स्पष्टीकरण

  • 0 न तो सकारात्मक है और न ही नकारात्मक।

  • ट्रेलिंग व्हाट्सएप को हमेशा आउटपुट में अनुमति दी जाती है।

  • इनपुट के कई टुकड़े किसी भी सुसंगत, सुविधाजनक क्रम में पढ़े जा सकते हैं।

नियम

  1. कोई भी उत्तर एक ही प्रोग्रामिंग भाषा में दो अलग-अलग कार्यों को हल नहीं कर सकता है। 1

  2. प्रत्येक व्यक्तिगत कार्य के लिए, मानक नियम लागू होते हैं।

    विशेष रूप से, आप सामान्य I / O चूक के साथ कार्यक्रम या फ़ंक्शन सबमिट कर सकते हैं , लेकिन इन कमियों का लाभ नहीं उठा सकते हैं ।

    टास्क 5 अनिवार्य रूप से एक चुनौती है, इसलिए आउटपुट को हार्डकोड करना न केवल अनुमत है, बल्कि अपेक्षित है।

  3. प्रत्येक कार्य के लिए केवल एक ही उत्तर प्रति उपयोगकर्ता को एक ही समाधान के साथ देना चाहिए।

    कृपया निम्न उदाहरण में अपने उत्तर को प्रारूपित करें:

    ## Task 1, Python, 42 bytes
    
        <code goes here>
    
    Explanation, I/O, required Python version, etc. go here.
    
    ---
    
    ## Task 7, C, 42 bytes
    
        <code goes here>
    
    Explanation, I/O, required compiler (flags), etc. go here.
    

स्कोरिंग

  1. आपके द्वारा हल किए गए प्रत्येक कार्य के लिए, आपको एक बिंदु मिलता है।

    इसका मतलब है कि आपको भाग लेने के लिए सभी कार्यों को हल करने की आवश्यकता नहीं है ।

  2. यदि कार्य n के लिए आपका समाधान उस प्रोग्रामिंग भाषा में सबसे छोटा है, तो आपको एक अतिरिक्त बिंदु मिलता है।

  3. यदि कार्य n के लिए आपका समाधान सभी प्रोग्रामिंग भाषाओं में से सबसे छोटा है, तो आपको एक अतिरिक्त बिंदु मिलता है।

  4. बोनस अंक क्रमशः प्रत्येक कार्य-भाषा संयोजन और प्रत्येक कार्य के लिए केवल एक बार प्रदान किया जाएगा।

    हमेशा की तरह, यदि दो समाधानों में एक ही बाइट गिनती होती है, तो पोस्टिंग टाई ब्रेकर है।

    यदि कोई व्यक्ति बाद में आपको आउटगोल्फ करता है, तो आप बोनस प्वॉइंट खो देते हैं जो अन्य उत्तरदाता कमाता है।

  5. आप अपने जवाब से भाषाओं को जमा कर सकते हैं, जोड़ सकते हैं / हटा सकते हैं या दो कार्यों के लिए उपयोग की जाने वाली भाषाओं को स्वैप कर सकते हैं।

    किसी भी समय कोई भी अपने उत्तर को संपादित करता है, सभी उत्तरों को बचाया जाता है।

  6. एक बार जब आप किसी कार्य के लिए भाषा बदलते हैं, तो आप वरिष्ठता को त्याग देते हैं। 2

उच्चतम स्कोर के साथ उत्तर जीतता है। 3

प्रति-कार्य लीडरबोर्ड

<style>body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}</style><script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><table class=answer-list><thead><tr><td>Task<td>Author<td>Language<td>Score<tbody id=answers></table></div><table style=display:none><tbody id=answer-template><tr><td>{{TASK}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}</table><script>function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function process(){answers.forEach(function(e){var s=e.body_markdown.split("\n").filter(function(e){return"#"==e[0]});s.forEach(function(s){var r=s.match(NUMBER_REG)[0],t=(s.match(SIZE_REG)||[0])[0],a=s.match(LANGUAGE_REG)[1],n=e.owner.display_name;entries.push({task:r,user:n,language:a,size:t})})}),entries.sort(function(e,s){var r=e.task-s.task;return r?r:e.size-s.size});for(var e=0;e<entries.length;e++){var s=jQuery("#answer-template").html();s=s.replace("{{TASK}}",entries[e].task).replace("{{NAME}}",entries[e].user).replace("{{LANGUAGE}}",entries[e].language).replace("{{SIZE}}",entries[e].size),s=jQuery(s),jQuery("#answers").append(s)}}var QUESTION_ID=52152,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*.*?,\s*\[*([^,\]]+)/,entries=[];</script>

संयुक्त लीडरबोर्ड (2015-07-30 20:00 यूटीसी)

User / Task      1 2 3 4 5 6 7 8 9 A   TOTAL   Tie breaker (if any)

DLosc            2 2 3 2 2 2 2 3 2 2      22
Sp3000           2 2 2 2 2 3 2 2 2 2      21
Doorknob         2 2 2 2 2 2 2 2 2 2      20
mathmandan       2 2 2 2 2 2 2 2 2 2      20   Combined byte count.
MickyT           2 2 2 2 2 2 1 2 2 2      19
Alex A.          2 1 2 2 2 2 1 2 2 2      18
Jacob            2 2 2 2 2 1 0 0 0 2      13
alephalpha       2 2 2 0 2 2 0 0 2 0      12
Martin Büttner   2 0 0 2 2 0 0 2 2 2      12   Combined byte count.
kirbyfan64sos    1 2 2 0 2 X 0 2 0 3      12   Per-language wins.
Maltysen         3 0 0 0 3 2 1 X 2 0      11
plannapus        2 2 0 0 2 2 0 2 0 2      10
jimmy23013       0 0 2 3 0 0 3 2 0 0      10   Solved tasks.
Tom              0 3 0 0 2 2 0 X 3 0      10   Combined byte count.
FryAmTheEggman   1 0 2 0 2 0 2 0 2 0       9
Vioz-            1 0 2 2 2 2 0 0 0 0       9   Combined byte count.
Toby Speight     2 0 0 0 2 2 0 0 0 2       8
Ismael Miguel    0 0 0 0 2 2 0 0 0 2       6
Pulga            0 2 2 0 0 0 0 0 0 2       6   Combined byte count.
flawr            2 0 2 0 0 0 0 0 0 0       4     
manatwork        2 0 0 0 0 2 0 0 0 0       4   Combined byte count.
TheNumberOne     1 0 0 0 2 0 0 0 0 0       3

के साथ चिह्नित कार्य Xमौजूद हैं लेकिन अमान्य हैं।

संयुक्त लीडरबोर्ड का निर्माण हाथ से किया गया है। यदि कोई त्रुटि हो तो कृपया मुझे बताएं।


1 भाषाएं अलग-अलग होती हैं यदि वे एक ही भाषा के अलग-अलग संस्करण नहीं हैं, इसलिए केवल एक जावास्क्रिप्ट, एक पायथन और एक TI-BASIC है, लेकिन C, C ++, ऑक्टेव और MATLAB चार अलग-अलग भाषाएं हैं।

2 यदि आप x बाइट्स में भाषा L का उपयोग करके टास्क n को हल करते हैं , तो कोई अन्य व्यक्ति उसी भाषा में उसी बाइट की गिनती के साथ एक ही कार्य को हल करता है, आप भाषा M में बदलते हैं और अपना संपादन वापस करते हैं, तो अन्य उत्तरदाता बोनस बिंदु रखेगा।

3 स्कोरिंग नियम 1, 2 और 3 (उस क्रम में) से अर्जित अंकों की संख्या, सभी हल किए गए कार्यों की संयुक्त बाइट गिनती (कम बेहतर है) और, अंत में, वोट टैली (उच्चतर बेहतर है) टाईब्रेकर के रूप में काम करती है।


6
स्पष्ट करने के लिए, यह चुनौती उन लोगों तक सीमित है जो कम से कम 10 भाषाओं को जानते हैं? मैं एक दोस्त के लिए पूछ रहा हूँ ...
vijrox

2
@ वीजयराममूर्ति: आपको भाग लेने के लिए सभी कार्यों को हल करने की आवश्यकता नहीं है, इसलिए यदि आप केवल एक कार्य को हल करते हैं, तो आपको केवल एक भाषा जानने की आवश्यकता है।
एलेक्स ए।

2
@ जोज़:। हमारे यहां कुछ 9-होल चुनौतियां थीं, लेकिन बाइट्स की संयुक्त राशि से उन्होंने स्कोर बनाए। यह नहीं कि मेरा स्कोरिंग किसी भी तरह से संबंधित है कि डिकैथलॉन कैसे रन बनाए जाते हैं, लेकिन मैं यह स्पष्ट करना चाहता था कि यह एक अलग प्रकार की चुनौती है।
डेनिस

4
@ लॉस्क: यह एक मानक कोड गोल्फ चुनौती होगी। यहां पूरा बिंदु प्रत्येक कार्य के लिए एक अलग भाषा का उपयोग कर रहा है।
डेनिस

3
@ नॉचचार्ल्स: मैंने ग्रेगरी से पूछा और उन्होंने पहली जनवरी को कहा।
डेनिस

जवाबों:


5

टास्क 1, गोल्फस्क्रिप्ट, 8 बाइट्स

~,{+}*.*

मार्टिन सीजेम जवाब के रूप में एक ही विचार ।


टास्क 2, QBasic, 74 71 बाइट्स

INPUT a
r=a>1
FOR i=2 TO a-1
r=r*(a MOD i)
NEXT
?r*((a\2AND a)=a\2)

सिंटैक्स विस्तार के साथ QB64 पर परीक्षण बंद हो गया। 1 कार्यक्रम का थोक परीक्षण करता है कि क्या दी गई संख्या प्रत्येक संख्या 2 <= < mod aको लेते हुए और परिणाम को गुणा करके प्रमुख है। इसका परिणाम यह है कि यदि संख्या अभाज्य नहीं है, तो 0 और अन्यथा नहीं है। अंतिम पंक्ति पूर्णांक विभाजन के साथ बिटवाइज 2 का उपयोग करती है यह जांचने के लिए कि बाइनरी प्रतिनिधित्व सभी लोगों का है, अर्थात फॉर्म 2 एन -1 का है। इसे गुणा करने पर 0 (असत्य) मिलता है यदि कोई संख्या Mersenne प्राइम नहीं है और कुछ नॉनजेरो (सत्य) मान नहीं तो। के लिए एक शॉर्टकट है ।aiarANDaar?PRINT

सबसे बड़ा Mersenne प्राइम मैंने 8191 का परीक्षण किया, 1.#INFजो - का एक परिणाम देता है जो अभी भी सत्य है! (मैंने IFयह सुनिश्चित करने के लिए एक बयान के साथ जाँच की ।)

1 यह कार्यक्रम के शब्दार्थ को नहीं बदलता है। यदि आप उपरोक्त कोड को मानक डॉस QBasic में टाइप करते हैं, तो यह अतिरिक्त स्थानों के साथ ऑटोफ़ॉर्मेट होगा, लेकिन यह बिल्कुल उसी तरह चलेगा।


टास्क 3, पायथ, 6 बाइट्स

ehc2SQ

स्टड से पायथन शैली की सूची पढ़ता है। यहां मुख्य जादू cहॉप ऑपरेटर है: एक इंट और एक सूची दी गई है, यह सूची को एन टुकड़ों में विभाजित करता है। इसलिए c2SQछंटनी की गई इनपुट सूची को आधे में काटें। आसानी से, जब लंबाई विषम होती है, तो पहली छमाही बड़ी होती है, इसलिए औसत हमेशा पहले छमाही का अंतिम तत्व होता है। यह चॉप परिणामों eके head की nd है ।


टास्क 4, सीजेएम, 26 बाइट्स

ri{_2%z\_0>\-2/_3$+?}h;]W%

यह छोटा किया जा सकता है, मुझे संदेह है।

कलन विधि:

  • पूर्णांक पढ़ें।
  • जबकि मूल्य 0 नहीं है:
    • एब्स (i% 2) लें। यह अगला अंक (नीग्रबिट?) है।
    • मुझे -2 से विभाजित करें।
    • Iff i परिणामहीन था, परिणाम में abs (i% 2) जोड़ें। यह एक कोने के मामले को सही करना है: 3 -1 तक जाता है, लेकिन -3 को 2 पर जाना चाहिए, 1 पर नहीं।
  • अतिरेक 0 को छोड़ें, ढेर को एक सरणी में इकट्ठा करें, रिवर्स करें और प्रिंट करें।

तथ्य यह है कि यह एक करते समय लूप 0 मामले का ख्याल रखता है।


टास्क 5, बैश, 50 बाइट्स

echo pneumonoultramicroscopicsilicovolcanoconiosis

समझाने के लिए ज्यादा नहीं।


टास्क 6, पायथन, 78 बाइट्स

from datetime import*
d=date.today()
if d.day<2>d.month:print"Happy New Year!"

पाइथन की आवश्यकता है 2. पाइथन की चैनिंग असमानता ऑपरेटरों का यहां अच्छा शोषण किया जा सकता है।


टास्क 7, एक्शनस्क्रिप्ट, 82 बाइट्स

x=""
while(x.length<64){c=chr(13312+random(6582));if(x.indexOf(c)<0)x+=c}
trace(x)

एक्शनस्क्रिप्ट ECMAScript परिवार का एक सदस्य है। इस कोड के लिए ActionScript 2 की आवश्यकता है - कोड गोल्फ के लिए बहुत बेहतर है क्योंकि मुझे chrसंस्करण 3 के बजाय पदावनत कार्यों का उपयोग करना है String.fromCharCode!

कंसोल कंसोल के लिए आउटपुट है:

टास्क 7 स्क्रीनशॉट


टास्क 8, पिप, 9 19 बाइट्स

रेगेक्स समाधान काफी काम नहीं आया, इसलिए यहां स्ट्रिंग ऑपरेशन के बजाय एक है।

Fcab@>:o&:(b@?c)+1o

पिप के लिए गितुब भंडार

कमांड-लाइन आर्ग्स के रूप में दो स्ट्रिंग्स लेता है। जब aएक परिणाम होता है, तो एक सकारात्मक पूर्णांक (सत्य) को आउटपुट करता है; अन्यथा, परिणाम शून्य (झूठा) होता है, जो कोई आउटपुट नहीं देता है।

स्पष्टीकरण:

                     Cmdline args -> a,b; o = 1 (implicit)
Fca                  For each character in a:
           b@?c      Find character's index in b (nil if not found)
          (    )+1   Add 1; all possible indices except nil are now truthy
       o&:           Logical AND with o
   b@>:              Slice b to everything at index o and afterward (Python b=b[o:])
                     (If c wasn't found, b becomes nil, but we don't care at that point)
                  o  Auto-print o

टास्क 9, प्रोलोग (एसडब्ल्यूआई), 68 बाइट्स

m(L,N,R):-L=[H|T],m(H,N,I),m(T,N,U),R=[I|U];L=[],R=[];R is L*N.

Prolog आमतौर पर कोड गोल्फ में सभी प्रतिस्पर्धी नहीं है, इसलिए मैं इस समाधान से बहुत खुश हूं।

सूची और संख्या और आउटपुट पैरामीटर के लिए इनपुट मापदंडों के साथ एक विधेय m को परिभाषित करता है । ट्रिपल डिसंक्शन की परिभाषा है:LNRm

  • यदि इसके साथ एकीकृत किया Lजा सकता है , तो यह एक सूची है जिसमें कम से कम एक आइटम है। उस सूची के सिर और पूंछ पर पुनरावर्ती रूप से कॉल करें , और परिणामों को फिर से एक नई सूची में डाल दें जो कि एकीकृत है ।[H|T]mR
  • अगर Lसाथ एकीकृत किया जा सकता है [], Rसाथ []ही साथ एकीकृत करें ।
  • अन्यथा, Lएक संख्या माना जाता है; L*Nकी गणना की और उसे सौंपा गया है R

उदाहरण का उपयोग कर चलाए swiplUbuntu पर:

dlosc@dlosc:~/golf$ swipl -qs arrayMult.prolog
?- m([1,2,3],5,R).
R = [5, 10, 15] .

?- m([[3,4],[5,6]],3,R).
R = [[9, 12], [15, 18]] .

?- m([[[1,2],[3,4]],[[5,6],[7,8]]],2,R).
R = [[[2, 4], [6, 8]], [[10, 12], [14, 16]]] .

टास्क 10, सी, 114 112 106 बाइट्स

#define F;printf("\n");for(i=0;i<c;i++)printf(
i;t(c){F" ______  ")F"|      | ")F" ()--() ~");putchar(8);}

gccउबंटू पर परीक्षण किया गया। एक फ़ंक्शन को परिभाषित करता tहै जो पूर्णांक तर्क लेता है। forउत्पादन के लिए तीन छोरों का उपयोग करता है , मैक्रो दुरुपयोग के माध्यम से बहुत गाढ़ा होता है। बैकस्पेस वर्ण का उपयोग करते हुए ~एक अजीब व्हाट्सएप पैटर्न में एक अनुगामी परिणाम को मिटाने के लिए , लेकिनThe output may be surrounded by any amount of whitespace as long as it looks like in the example.

का उदाहरण रन t(3):

dlosc@dlosc:~/golf$ ./a.out

 ______   ______   ______
|      | |      | |      |
 ()--() ~ ()--() ~ ()--() dlosc@dlosc:~/golf$

दुर्भाग्य से, कार्य 8 के लिए आपका कोड a.cइसके बाद की पहचान करता है abc
डेनिस

@Dennis यही है दुर्भाग्यपूर्ण। (अच्छी पकड़, हालांकि, धन्यवाद।) 10 बाइट्स की कीमत पर फिक्स्ड।
DLosc

17

हुजह, पहले सभी कार्यों को पूरा करने के लिए! \ O /

टास्क 1, पर्ल, 32 बाइट्स

$_=eval join"+",map$_**3,0..$_-1

-pध्वज के लिए +1 बाइट । टिप्पणी: पर्ल अजीब है


टास्क 2, सीजेएम, 14 बाइट्स

{_mp\)2mL_i=&}

मेरा पहला सीजेएम कार्यक्रम!


टास्क 3, गोल्फस्क्रिप्ट, 8 बाइट्स

~$.,(2/=

Eval STDIN इनपुट, सॉर्ट, लंबाई, गिरावट, दो से विभाजित करें, फिर उस इंडेक्स के सॉर्ट किए गए एरे का आइटम लें।


टास्क 4, पायथन, 77 बाइट्स

def f(i,d=''):
 while i:i,r=i/-2,i%2;i+=r<0;r+=2*(r<0);d=`r`+d
 return d or 0

24 (!) बाइट्स को शेविंग करने के लिए @ mbomb007 और अन्य 11 के लिए @ Sp3000 को धन्यवाद।


टास्क 5, जावा, 66 बाइट्स

String f(){return"pneumonoultramicroscopicsilicovolcanoconiosis";}

उबाऊ। बाद में गोल्फर भाषाओं के लिए कमरे को बचाने के लिए एक क्रिया भाषा यहाँ पर दस्तक दी।


टास्क 6, बैश, 39 बाइट्स

((`date +%j`<2))&&echo Happy New Year\!

इस बारे में मुझे सिखाने के लिए @manatwork का शुक्रिया %j, इस प्रक्रिया में 10 बाइट्स निकाल कर।


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

a=[];Array(65).join('x').replace(/./g,function(){while(a.push(s=String.fromCharCode(13312+Math.random()*6582))&&a.indexOf(s)==s.length-1);return s})

64 के स्ट्रिंग को उत्पन्न करें x, फिर उन सभी को कॉलबैक फ़ंक्शन के साथ बदलें, जो उन वर्णों का एक यादृच्छिक रिटर्न देता है यदि यह पहले से ही उपयोग किए गए वर्णों की सरणी में नहीं है।


टास्क 8, रस्ट, 130 बाइट्स

fn f(a:String,b:String)->bool{let mut c=b.chars();for x in a.chars(){match c.find(|&y|x==y){Some(_)=>(),None=>return false}};true}

हां, गोल्फ में जंग बहुत खराब है।


टास्क 9, शुतुरमुर्ग, 18 बाइट्स

{:n;'`\d+`{~n*}X~}

संस्करण 0.7.0 । सरणी का निरीक्षण करता है, एक रेगेक्स संख्याओं को उनके गुणित संस्करणों में बदलने के लिए प्रतिस्थापित करता है, और फिर परिणामी स्ट्रिंग को फिर से निकालता है।


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

->n{([' ______  '*n,'|      | '*n,' ()--() ~'*n]*$/).chop}

"\n"एक से अधिक वर्ण है "{actual newline}", जो एक से अधिक वर्ण है $/। काले जादू के विभिन्न टोटकों के साथ {अनिश्चितकालीन लेकिन बड़ी संख्या} बाइट्स बंद करने के लिए @ मार्टिनबटनर को धन्यवाद।


टास्क 6 - $(…)`…`
मैनटवर्क

@manatwork धन्यवाद, संपादित।
दरवाज़े

फिर से सोच, (प्रगति में कैफीन अवशोषण ...), इतना लंबा% डी प्रारूप क्यों? [ `date +%j` = 001 ]या भी ((`date +%j`<2))। (जीएनयू मानकर date, जो निश्चित रूप से "वर्ष का% j दिन (001..366)" प्रारूप का समर्थन करता है।)
मैनटवर्क

@manatwork ऊह, बहुत अच्छा। फिर से धन्यवाद, जवाब देने के लिए जोड़ा गया।
दरवाज़े

टास्क 4 को ((+ + 0xAAAAAAAA) ^ 0xAAAAAAAA) का उपयोग करके छोटा किया जा सकता है।
याकूब

15

टास्क 1, 3 सवर, 14 13 बाइट्स

'><k*>#aa/>sp

( 3var के लिए एसोलंग विकी पेज )

'                  R = n
 >                 A = n
  <k               B = n-1
    *              R = A*B = n(n-1)
     >             A = n(n-1)
      #aa          B = 2
         /         R = A/B = n(n-1)/2
          >s       A = (n(n-1)/2)^2
            p      Output A

एक कोड बिंदु के माध्यम से इनपुट लेता है, जैसे अंतरिक्ष 32 है।

शुक्र है कि फार्मूले को लागू करने के लिए हमें जो भी ऑपरेशन करने n^2 (n-1)^2 / 4पड़ते हैं, वे सिंगल चार्ट्स (डीक्रिमेंटिंग, गुणा और स्क्वेरिंग) हैं, फिर भी 3 बाइट्स Bको 2 पर सेट करना (रीसेट-इन्क्रीमेंट-इन्क्रीमेंट) लगता है।


टास्क 2, रेटिना, 38 33 बाइट्स

^
1
^(..|.(..+)\2+|(.(..)+)\3*)$
<empty>

( रेटिना के लिए गितुब भंडार )

प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है, लेकिन आप ऊपर परीक्षण कर सकते हैं जैसा कि -sध्वज के साथ है ( <empty>कुछ नहीं के साथ प्रतिस्थापित )। इनपुट 1s के साथ unary होना चाहिए, जैसे 11111117 के लिए।

यहां बताया गया है कि प्रत्येक रेगेक्स प्रतिस्थापन (लाइनों की एक जोड़ी द्वारा निर्दिष्ट) करता है:

  1. सामने की ओर एक अतिरिक्त 1 पर टिकें
  2. फॉर्म का कुछ भी 2, 1 + compositeया not power of 2कुछ भी के साथ बदलें ।

यह 1मेर्सन प्राइम के लिए एक अतिरिक्त जोड़ता है , जबकि हर दूसरे नंबर को हटा दिया जाता है।


टास्क 3, रैकेट, 71 बाइट्स

#lang racket
(define(m x)(list-ref(sort x <)(quotient(-(length x)1)2)))

लिस्प जैसी भाषाएं सिर्फ बहुत चिंताजनक हैं। उदाहरण रन:

> (m `(1 3 4 2))
2

टास्क 4,> <>, 31 बाइट्स

:?!v:2%:@-02-,
)?~\l1
!;n>l?

( Esolang wiki पेज के लिए> <> )

उपरोक्त 28 बाइट्स हैं, और एक और 3 बाइट्स के-v लिए पायथन दुभाषिया में ध्वज की आवश्यकता होती है , जैसे कि चलाते हैं

$ py -3 fish.py negabinary.fish -v -137
10001011

> <> के बारे में अच्छी बात यह है कि हम अंकों को एक-एक करके मोडुलो और डिवीजन के माध्यम से गणना कर सकते हैं, जो अंकों को रिवर्स ऑर्डर में देता है, एक स्टैक को प्रिंट करने के लिए एकदम सही।


टास्क 5, पेरेंटेटिक, 1448 1386 बाइट्स

((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))((()(()))((()()())((())()()()()))((()()())((())()()))((()()()())((())()()()()))((()()())((())()()()()()()()()()))((()()())((())()))((()()())((())()()()))((()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()))((()()())((())))((()()())((())()()()()()()()()))((()()())((())()()()()()()))((()()()())((())))((()()())((())()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()()))((()()())((())()()()))((()()())((())))((()()()())((())()()))((()()()())((())))((()()())((())()()))((()()())((())()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()))((()()()())((())()()()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())()()()()()()())))

( जनक के लिए गितुब भंडार )

मेरे पास इसके लिए सीजेएम उत्तर है जो स्ट्रिंग से कम है, लेकिन मैं इसका उपयोग नहीं कर सकता, इसलिए मैंने सोचा कि मैं दूसरे रास्ते पर जाऊंगा।

पायथन 3 जनरेटिंग कोड:

char97 = "((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))"
char108 = "((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))"
open_str = "((()(()))"
close_str = ")"

target = "pneumonoultramicroscopicsilicovolcanoconiosis"
output = [char97, char108, open_str]

for c in target:
    if ord(c) >= 108:
        output.append("((()()())((())%s))"%("()"*(ord(c)-108)))
    else:
        output.append("((()()()())((())%s))"%("()"*(ord(c)-97)))

output.append(close_str)
print("".join(output))

यहाँ इसी लिस्प की तरह कोड है:

(define f (lambda (n) (char (+ n 97))))
(define g (lambda (n) (f (+ n 11))))

(+
   (g 4)  // p
   (g 2)  // n
   (f 4)  // e
   ...
)

जाहिरा तौर पर यह ओवरराइड करने के लिए ठीक था defineनामकरण से gके रूप में ()()है, जो बाइट्स का एक बहुत बचाया।


टास्क 6, सीजेएम, 26 बाइट्स

XY]et1>>"Happy New Year!"*

जाँच करता है कि [month day]स्थानीय समय सारणी का हिस्सा इससे कम है [1, 2]


टास्क 7, पायथन, 73 बाइट्स

from random import*
print(*map(chr,sample(range(13312,19894),64)),sep="")

बस एक सीधा पायथन 3 कार्यान्वयन।


टास्क 8, प्रस्तावना, 46 41 बाइट्स

?(?)#(#)?(v-(#)?)10)!
      ^      1 # (0

( प्रस्तावना के लिए Esolang विकी पेज )

मुझे लगता है कि यह काम करता है - यह शायद अभी भी गोल्फ है, लेकिन यह मेरी पहली बार गैर-तुच्छ गोल्फ में प्रीडल कर रहा है। इनपुट प्रारूप है <needle>NUL<haystack>, कहां NULहै 0x00। यह NUMERIC_OUTPUT = Trueपायथन इंटरप्रेटर के साथ सबसे अच्छा काम करता है , क्योंकि यह इसे आउटपुट 1या 0उपयुक्त बना देगा।

मैंने प्रस्तावना को चुना क्योंकि इसमें दो गुण हैं जो इस कार्य के लिए बहुत अच्छे हैं:

  • यह स्टैक-आधारित है, इसलिए आप पहली बार सुई में पढ़ सकते हैं, फिर एक समय में एक चार चक्कर लगाने की प्रक्रिया करें, और
  • प्रील्यूड के स्टैक में नीचे की ओर 0 की अनंत संख्या होती है, इसलिए आपको उस मामले को संभालने की आवश्यकता नहीं है जहां सुई पात्रों से बाहर निकलती है।

यह बेहतर होता अगर Prelude एक ऑपरेटर नहीं होता।

यहाँ ब्रेकडाउन है:

?(?)#    Read input up to the NUL, discarding the NUL afterwards

(#)      Move the needle to the second voice, effectively reversing the stack
 ^

?(...?)  Read haystack

  v-     Compare top needle char with haystack char by subtraction

  (#)    If equal, pop the needle char
   1 #

10)!     Output 1 if the top needle char is 0 (bottom of stack), 0 otherwise
(0

(-5 बाइट्स @ मार्टिनबरंटनर को धन्यवाद)


टास्क 9, गणितज्ञ, 4 बाइट्स

#2#&

2 {{0, 1}, {1, 0}}मैथेमेटिका में कुछ इस तरह से गुणा किया जाता है, इसलिए यह तर्क को किनारे कर देता है।

जैसा कि @MartinButtner और @alephalpha ने बताया है , 1##&एक और 4 बाइट का जवाब है। स्पष्टीकरण के लिए पूर्व को देखें।


टास्क 10, रेल, 246 237 बाइट्स

$'main'
 0/aima19-@
@------e<
         -(!!)()[ ][ ______ ]{f}[\n\]o()[ ][|      |]{f}[\n\]o()[~][ ()--() ]{f}#
$'f'                 #           #
 -(!x!)(!y!)(!!)()0g<  -(x)o()1g<  -(y)o()1s(y)(x){f}#
                     -/          -/

( रेल के लिए एसोलंग विकी पेज )

मैं रेल से संबंधित कार्य करने का अवसर रेल में नहीं दे सकता था :) व्हॉट्सएप देखने में बहुत ही गोल्फ की तरह लग रहा है, लेकिन ब्रांचिंग के साथ तीन लाइनें लगने के बाद यह थोड़ा सा काम करेगा।

इनपुट STDIN के माध्यम से एक पूर्णांक है, लेकिन EOF होने की आवश्यकता है। ऊपर-बाएँ भाग

 0/aima19-@
@------e<

एक atoi लूप है जो इनपुट को पूर्णांक में परिवर्तित करता है जबकि EOF नहीं ( eनिर्देश द्वारा जांचा गया )।

fअंतिम तीन पंक्तियों पर कार्य करता है x, y, n, और x nइसके द्वारा अलग किए गए स्ट्रिंग समय को आउटपुट करता है y। फ़ंक्शन पुनरावर्ती है, nजब तक कि यह शून्य न हो जाए, तब तक एक-एक बार क्षय होता है। fतीन बार कहा जाता है, प्रत्येक पंक्ति के लिए अलग तार की आपूर्ति। अजीब तरह से, रेल चर नामों को खाली करने की अनुमति देता है, जो कुछ बाइट्स को बचाता है।

अधिकांश बाइट्स दुर्भाग्य से आते हैं (!x!), जो स्टैक के शीर्ष को पॉप करता है और इसे चर पर असाइन करता है x, और (x), जो xस्टैक पर धक्का देता है । यह आवश्यक है क्योंकि रेल में कोई डुप्लिकेट ऑपरेटर नहीं है, इसलिए (!x!)(x)(x)स्टैक के शीर्ष को कॉपी करने का एकमात्र तरीका है।


यदि कार्य 2 rs में थे, तो आप 2 बाइट्स बचाएंगे, और यह केवल 14 बाइट्स की संख्या को एकात्मक के बजाय ले जाएगा। ;)
kirbyfan64sos

जब मैंने रैकेट देखा, तो मुझे लगा कि आपको कोष्ठक पसंद है; लेकिन
पितृसत्तात्मक

13

टास्क 1, सीजेएम, 7 बाइट्स

q~,:+_*

मैं तो बस (शायद) इष्टतम CJam इस में के लिए समाधान प्राप्त करना चाहता था। यह सच है कि पहले की राशि का उपयोग करता है n घनों के वर्ग है n वें त्रिकोणीय संख्या है, जो अपने आप में पहले का योग है n पूर्णांक।

इसका परीक्षण यहां करें।


टास्क 4, विखंडन, 173 88 78 69 68 बाइट्स

गिटहब रिपॉजिटरी फॉर फिशन।

 /@\O/S@+>\
^{ }[<X/ @/;
,\?/@\J^X\
'M~\$ $
UK/W%@]  /
D
?\{\/
0'A Y

मेरा दूसरा यथोचित जटिल विखंडन कार्यक्रम है। :)

इनपुट प्रारूप थोड़ा अजीब है। नकारात्मक इनपुट का समर्थन करने के लिए, पहला वर्ण +या तो -संकेत होने या संकेत को इंगित करने की उम्मीद है । दूसरे वर्ण का बाइट मान तब इनपुट का परिमाण है (चूंकि विखंडन मूल रूप से दशमलव पूर्णांक नहीं पढ़ सकता है)। इसलिए यदि आप चाहते हैं कि 111आप इसे +oSTDIN पर पारित करें। और आप चाहें -56तो इसे पास कर सकते हैं -8। के स्थान पर +और -आप क्रमशः निम्न या उच्च वर्ण कोड वाले किसी भी वर्ण का उपयोग कर सकते हैं। यह कुछ करने के लिए सहायक हो सकता है जैसे -n(जो आपके echoतर्क के रूप में व्यवहार कर सकता है), जैसे, उदाहरण के लिए 0n

आइए देखें कि हम सकारात्मक संख्या के नकारात्मक प्रतिनिधित्व को कैसे पा सकते हैं। हम कम से कम सबसे महत्वपूर्ण बिट की संख्या की गणना करना चाहते हैं (हम उन बिट्स को एक स्टैक पर धक्का देंगे और उन्हें सही क्रम में प्राप्त करने के लिए अंत में सभी को प्रिंट करेंगे)। पहला अंक तो बस संख्या की समानता है, और हम प्रसंस्करण जारी रखने के लिए संख्या को 2 से विभाजित करते हैं। अगला अंक अब नकारात्मक है (मान -2 के साथ) - लेकिन यह ध्यान दिया जाना चाहिए कि जब भी 2-बिट एक सामान्य बाइनरी नंबर में सेट किया जाएगा तो यह बिट सेट हो जाएगा। एकमात्र अंतर यह है कि हमें -2 को सकारात्मक उच्च मूल्यवान अंकों के साथ मुकाबला करने की आवश्यकता है। तो हम क्या करते हैं:

  • हम समानता को फिर से निर्धारित करते हैं - यह अगला नकारात्मक है - और पहले की तरह 2 से विभाजित करें।
  • यदि वह अंक एक था 1, तो हम नकारात्मक संख्या (नकारात्मक और एक बिट के बीच का अंतर एक बार अगले अधिक-महत्वपूर्ण बिट का मूल्य है) का मुकाबला करने के लिए शेष संख्या को 1 से बढ़ाते हैं ।

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

फिर, अगला बिट फिर से एक सकारात्मक मूल्य है इसलिए हम इसे सामान्य रूप से निर्धारित कर सकते हैं। इसका मतलब है कि हम एक ऐसा लूप चाहते हैं जो एक बार में दो बिट्स की गणना करता है, बारी-बारी से और शेष संख्या के लिए गोलाई के बीच बारी-बारी से, लेकिन हम लूप को बीच में दर्ज करना चाहते हैं, इसलिए हम राउंडिंग के साथ शुरू करते हैं।

हम नकारात्मक पूर्णांक कैसे संभाल सकते हैं? समस्या यह है कि विखंडन वास्तव में ऋणात्मक पूर्णांकों पर मनमाना अंकगणित नहीं कर सकता है, क्योंकि जनता हमेशा गैर-नकारात्मक होती है। तो किसी को वास्तव में कुछ जटिल करना होगा जैसे कि परिमाण के साथ काम करना और कहीं और साइन का ट्रैक रखना। हालांकि, एक ऋणात्मक संख्या के नकारात्मक प्रतिनिधित्व को संबंधित सकारात्मक संख्या के आधार पर गणना की जा सकती है:

यदि n नकारात्मक है, की negabinary प्रतिनिधित्व गणना n / 2 (गोल ऊपर ) और की समता संलग्न एन

यह हमारे दो-बिट लूप का पहला चरण है। तो हम सब करने की जरूरत है एक अलग बिंदु पर पाश शुरू होता है अगर संकेत नकारात्मक है।

173 मूल बाइट्स में से अधिकांश बचत इन जानकारियों से हुई जिसने मुझे एकल समता की जाँच के साथ तीन लूप और दो-खंड लूप को एक लूप में संपीड़ित करने की अनुमति दी।

यह पोस्ट बहुत लंबी हो जाएगी अगर मैं सभी कोड के बारे में विस्तार से बताऊंगा, लेकिन मैं नियंत्रण प्रवाह के किसी न किसी लेआउट को देने के लिए कुछ खंडों को इंगित करूंगा, और आप विखंडन संदर्भ के साथ विवरणों को पहेली बना सकते हैं।

 /@\
^{ }[
,\?/
'
U
D
?

शुरू से D, यह ऊर्जा में एक संकेत बिट और एक परमाणु के द्रव्यमान में परिमाण को पढ़ता है जो कि [(सही हो रहा) में समाप्त होता है । यह साइन बिट समांतर जाँच के माध्यम से प्रत्येक पास के बाद वैकल्पिक होगा और निर्धारित करेगा कि क्या हम लूप इनपुट के आधे हिस्से को गोल या नीचे बनाए रखते हैं।

     /S@+>\
    [<X/ @/
 \  @\J^X\
 M  $ $
 K  %@]  /

यह लूप है जो व्यक्तिगत बिट्स की गणना करता है और सही आधे को अगले पुनरावृत्ति में खिलाता है। Sऔर The Jसही वर्तमान साइन बिट के आधार पर आधा की एक प्रतिलिपि बनाने के लिए उपयोग किया जाता है, Xरों नकल करते हैं। >ऊपरी दाएं कोने में गणना करता है वास्तविक बिट जो तब ढेर करने के लिए भेज दिया जाता है Kबाद में पुनः प्राप्त किया जा करने के लिए। मुझे लगता है कि शीर्ष दाएं कोने का लेआउट निफ्टी है और यदि आप विखंडन में रुचि रखते हैं तो निश्चित रूप से विस्तार से अध्ययन करने लायक हैं।

%एक स्विच जो संख्या पाश में वापस जब तक यह 0 से अधिक है खिलाती है।

    O


 M~\
 K/W%

 \{\/
0'A Y

एक बार संख्या 0 तक पहुंचने के बाद इसके बजाय नीचे परिलक्षित होता है। यह एक और लूप शुरू करता है जो स्टैक से बिट्स को पुनर्प्राप्त करता है, उन्हें वर्ण कोड में जोड़ता है 0और उनके साथ प्रिंट करता है O। एक बार स्टैक खाली होने पर प्रोग्राम समाप्त हो जाता है, क्योंकि नियंत्रण परमाणु को स्टैक पर धकेल दिया जाएगा (और बाद में कोई और अधिक गतिमान परमाणु नहीं बचे हैं)।


टास्क 5, प्रस्तावना, 219 179 96 बाइट्स

पूर्वगामी के लिए Esolangs पृष्ठ।

प्रस्तावना के लिए स्टैक स्निपेट दुभाषिया।

29+129+716705-7607-05-4759+705-14129+05-18705-29+719+05-1507-19+39+449+767549+03-68(67+^+^+^++!)

यह तीन आवाज़ों के साथ एक मानक हाथ से तैयार की गई निश्चित-आउटपुट प्रील्यूड प्रोग्राम के रूप में शुरू हुआ। Sp3000 के साथ कुछ चैट के बाद मैंने एकल आवाज़ आज़माने का फैसला किया। यह पता चला कि यह काफी अच्छी तरह से काम करता है, क्योंकि पुराने अक्षरों का पुन: उपयोग करना बहुत आसान है। तब डेनिस ने मुझे कुछ संकेत दिए और मुझे वर्तमान संस्करण मिला: विचार पत्र से सभी ऑफसेट hको एक ही आवाज के ढेर पर रिवर्स ऑर्डर में धकेल रहा है , और फिर उन्हें एक बार में एक लूप में प्रिंट करें। hचुना जाता है क्योंकि hस्ट्रिंग में कोई भी नहीं है (जो महत्वपूर्ण है - अन्यथा 0ऑफसेट लूप समाप्त हो जाएगा) और क्योंकि यह दो अंकों और नकारात्मक ऑफसेट के संदर्भ में ऑफसेट के एन्कोडिंग को कम करता है।

इस CJam स्क्रिप्ट के साथ ऑफ़सेट एन्कोडिंग उत्पन्न की गई थी


टास्क 8, गणितज्ञ, 28 बाइट्स

LongestCommonSequence@##==#&

बिल्ट-इन के लिए याय। (मैथेमेटिका का नामकरण यहां थोड़ा अजीब है ... LongestCommonSubsequenceसबसे लंबे समय तक सामान्य क्रमिकता को LongestCommonSequenceढूँढता है जबकि सबसे लंबी बाद की सामान्यता को पाता है ।)


टास्क 9, जे, 1 बाइट

*

एपीएल और के के समान ही उत्तर देता है, लेकिन ऐसा लगता है कि किसी ने अभी तक जे को नहीं लिया है।


टास्क 10, रेटिना, 67 60 बाइट्स

रेटिना के लिए GitHub रिपॉजिटरी।

(.*).
 ______  $1<LF>|      | $1<LF> ()--() ~$1
+`(.{9})1
$1$1
~$
<empty>

प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है, और उसे <LF>एक नई पंक्ति के साथ प्रतिस्थापित किया <empty>जाना चाहिए और एक खाली फ़ाइल होनी चाहिए। आप यह सब एक फ़ाइल में भी डाल सकते हैं, और -sविकल्प का उपयोग कर सकते हैं , लेकिन यह <LF>अभी तक के स्थान पर नईलाइन वर्णों की एम्बेडिंग की अनुमति नहीं देता है। आप ऐसा कुछ करके अनुकरण कर सकते हैं

echo -n "111" | ./Retina -s train.ret | ./Retina -e "<LF>" -e "\n"

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


10

एह, मुझे लगता है मैं एक जोड़े के साथ शुरू करेंगे। पहली बार गोल्फ।

टास्क 1, पायथन, 38 21 बाइट्स

lambda n:(n*n-n)**2/4

X तक सभी क्यूब्स की एक सूची को जोड़ दें। एक्सनोर के लिए बदली हुई अभिव्यक्ति

टास्क 2, टीआई-बेसिक 89, 244 बाइट्स

Func
If iPart(log(x+1)/log(2))=log(x+1)/log(2) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc
Func
If isPrime(x)=false
 Return 0
If ipart(log(x+1)/log(2))=log(log(x+1)/log(2)) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc

इस एक पर 100% निश्चित नहीं है, जब मैं अपने कैलकुलेटर के लिए नई बैटरी ढूंढता हूं तो परीक्षण करेगा। isPrime एक बिल्टिन है, ipart पूर्णांक भाग (2.3 -> 2) है

टास्क 3, पर्ल, 45 34 बाइट्स

@n=sort{$a-$b}@ARGV;print$n[$#n/2]

perl फ़ाइल 1 2 3 4 -> 2. @ बाइट के लिए बाइट्स के एक जोड़े को बचाया। वेरिएबल को प्रिंट करने के बजाय प्रिंट करने के बजाय वेरिएबल को प्रिंट करना।

टास्क 4, रूबी, 43 40 बाइट्स

x=2863311530
p ((gets.to_i+x)^x).to_s(2)

कम से कम 1.9 में काम करता है, 1.8 के बारे में नहीं जानता। बाइनरी में, '10' * 16 (या 2863311530) प्लस एक संख्या, जो कि 10101010 के साथ xor है ... नेगेटिव है। उद्धरण (3 -> "111" के बजाय 3 -> 111) के साथ एक स्ट्रिंग प्रतिनिधित्व आउटपुट करता है। कम वर्णों में x लिखने के लिए गणित नहीं खोज सकते।

टास्क 5, मालबोल, 682 354 बाइट्स

D'``_]>n<|49ixTfR@sbq<(^J\ljY!DVf#/yb`vu)(xwpunsrk1Rngfkd*hgfe^]#a`BA]\[TxRQVOTSLpJOHlL.DhHA@d>C<`#?>7<54X8165.R2r0/(L,%k)"F&}${zy?`_uts9Zvo5slkji/glkdcb(fed]b[!B^WVUyYXQ9UNrLKPIHl/.JCBGFE>bBA@"!7[;{z276/.R2r0)(-&J$j('~D${"y?w_utyxq7Xtmlkji/gf,MLbgf_dc\"`BA]\UyYXWP8NMLpPIHGLEiIHGF(>C<A@9]7<;:3W7w5.-210/(L,%k#('~}C{"y?`_uts9wpXn4rkpoh.lNMiha'eGF\[`_^W{h

ऑनलाइन टेस्ट करें यह सोचें कि यह उतना ही छोटा होगा जितना कि यह जाएगा। जितना मैं कर सकता था उतना गोल्फ। 300 बाइट्स बचाए, तो मट्ठा?

टास्क 6, बैश, 62 50 40 बाइट्स

[ `date +%j`=1 ]&&echo 'Happy New Year!'

एक और पोस्ट से% j के बारे में पता चला।

टास्क 10, बेफ्यूज -98, 121 बाइट्स

>&:>1-:" ____"v
   |,k8: '"__"<
   >a,$:>1-v
      > |
>' 8k,^ #
^|':k4 '|':<
v ',*25$<
>,:1-: ")(--)("v
^," ~"_@#,k6" "<

बीफ्यूज -98 में बदल गया। ओल्ड बेफ़ुंज -93, 227 157 147 बाइट्स था। परीक्षण के लिए हास्केल में लिखी गई फंगी का इस्तेमाल किया। "कई बार के करें" का उपयोग किया और स्टैक के साथ एकल वर्णों को जोड़ दिया। ' मुझे लग रहा है कि यह 110 या उससे कम हो सकता है, लेकिन मैंने इस पर पहले से ही बहुत अधिक समय बिताया है ...


@ डेनिस चूंकि मैं मुख्य पोस्ट पर नहीं पूछ सकता, इसलिए मैं यहां पूछूंगा। क्या टास्क 3 के लिए स्पेस अलग इनपुट ठीक है? यह [] में नहीं होगा।
जैकब

जो भी आपकी आवश्यकताओं के अनुरूप हो।
डेनिस

1
आप सूत्र के साथ क्यूब्स के योग को छोटा कर सकते हैं जैसेlambda n:(n*n-n)**2/4
xnor

आप 0=fPart(expression) rather than अपने TI-89 BASIC उत्तर में iPart (अभिव्यक्ति) = अभिव्यक्ति` का उपयोग कर सकते हैं ।
lirtosiast

1
मुझे लगता है कि पाइथन 2/3 जैसी किसी चीज़ के बारे में बात करने पर तर्क अच्छी तरह से काम नहीं करता है। उदाहरण के लिए, `n` 2 में str (n) से बेहतर काम करता है, लेकिन 3. में काम नहीं करता है। मैं इस समय अन्य उदाहरणों के बारे में नहीं सोच सकता, मैं गोल्फ के साथ अधिक चिंतित हूं कि उत्तर का अधिक जवाब दें: p
जैकब

9

पहली बात: कार्य 6 तकनीकी रूप से नहीं गिना जाता है; मैं अपलोड यूएनसी एक घंटे पहले के तहत। हालांकि, मैंने आज सुबह इसे लगभग अपलोड कर दिया, लेकिन पहले एक टेस्ट सूट लिखने का फैसला किया। बेवकूफ।

तो, वैसे भी, यहाँ जाता है!

ध्यान दें कि ज्यादातर अनजानी चीजें जानबूझकर पीछे की ओर होती हैं, इसलिए &&वास्तव में इसका मतलब है ||और ऐसा है, यही वजह है कि कुछ ऑपरेशन अजीब लगते हैं (जैसे -कि क्यूब की गणना करने के लिए उपयोग करना)।

टास्क 1, हास्केल, 21 बाइट्स

f n=sum$map(^3)[0..n]

टास्क 2, Hy, 135 बाइट्स

(import math)(fn[n](and(if(and(not(% n 2))(> n 2))false(all(genexpr(% n i)[i(->> n(math.sqrt)int inc(range 3))])))(->> n dec(& n)not)))

टास्क 3, डार्ट, 37 बाइट्स

मेरा पहला डार्ट फ़ंक्शन!

f(l){l.sort();return l[l.length~/2];}

टास्क 5, इंटरकैल, 1047 बाइट्स

DO ,1 <- #46
DO ,1SUB#1 <- #242
DO ,1SUB#2 <- #152
DO ,1SUB#3 <- #208
PLEASE DO ,1SUB#4 <- #248
DO ,1SUB#5 <- #248
DO ,1SUB#6 <- #192
PLEASE DO ,1SUB#7 <- #128
DO ,1SUB#8 <- #128
DO ,1SUB#9 <- #72
PLEASE DO ,1SUB#10 <- #120
DO ,1SUB#11 <- #8
DO ,1SUB#12 <- #224
PLEASE DO ,1SUB#13 <- #200
DO ,1SUB#14 <- #208
DO ,1SUB#15 <- #32
PLEASE DO ,1SUB#16 <- #208
DO ,1SUB#17 <- #120
DO ,1SUB#18 <- #88
PLEASE DO ,1SUB#19 <- #40
DO ,1SUB#20 <- #8
DO ,1SUB#21 <- #208
PLEASE DO ,1SUB#22 <- #232
DO ,1SUB#23 <- #120
DO ,1SUB#24 <- #208
PLEASE DO ,1SUB#25 <- #248
DO ,1SUB#26 <- #56
DO ,1SUB#27 <- #96
PLEASE DO ,1SUB#28 <- #160
DO ,1SUB#29 <- #208
DO ,1SUB#30 <- #208
PLEASE DO ,1SUB#31 <- #136
DO ,1SUB#32 <- #120
DO ,1SUB#33 <- #192
PLEASE DO ,1SUB#34 <- #112
DO ,1SUB#35 <- #64
DO ,1SUB#36 <- #16
PLEASE DO ,1SUB#37 <- #128
DO ,1SUB#38 <- #48
DO ,1SUB#39 <- #208
PLEASE DO ,1SUB#40 <- #128
DO ,1SUB#41 <- #224
DO ,1SUB#42 <- #160
PLEASE DO ,1SUB#43 <- #40
DO ,1SUB#44 <- #56
DO ,1SUB#45 <- #200
PLEASE DO ,1SUB#46 <- #126
PLEASE DO READ OUT ,1
DO GIVE UP

टास्क 6, संयुक्त राष्ट्र, 157 बाइट्स

!include>=fgQVb%U<=
!include>=gVZR%U<=
false lRNe[]<<gVZR_g t:=gVZR[5]:volatile gZ m:=-YbPNYgVZR[&t]:for[#m%gZ_Zba||m%gZ_ZQNl!=6]chgf[L'uNccl ARj LRNe#']:>>

टास्क 8, आरएस, 42 बाइट्स

#
+#(.)(.*) .*?\1/\1#\2 
.*# .*$/1
[^1]+/0

लाइव डेमो।

टास्क 10, पायथ, 46 बाइट्स

jb(j*d2m+\ *\_6Qjdm"|      |"Qj\~m" ()--() "Q)

लाइव डेमो।


@ डेनिस उफ़! फिक्स्ड!
kirbyfan64sos

1
खैर, मुझे पता नहीं है, लेकिन मुझे पूरा यकीन है कि आपको किसी एक की ज़रूरत नहीं है !include। पूरी तरह से निश्चित नहीं है कि कौन सा हालांकि।
डेनिस

@ डेनिस पहले शामिल है stdio.h, दूसरा है time.h। मुझे दोनों की जरूरत है।
kirbyfan64sos

uncसी कोड को संकलित करने के लिए क्या उपयोग करता है ? जीसीसी बिना ठीक काम करेगा stdio.h। के बारे में निश्चित नहीं है time.h
डेनिस

@ डेनिस अनल में सेट कंपाइलर नहीं है। यह सिर्फ C कोड आउटपुट करता है; मुझे खुद इसे संकलित करना होगा। हालांकि, कि करता है मतलब; मैं बाद में इसकी जाँच करूँगा।
kirbyfan64sos

8

टास्क 1, एपीएल, 7 बाइट्स

+/3*⍨⍳⎕

आप इसे ngn / apl का उपयोग करके ऑनलाइन कोशिश कर सकते हैं , हालांकि यह किसी भी एपीएल कार्यान्वयन के साथ काम करेगा जो 0 इंडेक्स मूल के लिए चूक करता है।

यह प्रत्येक पूर्णांक को 0 से इनपुट ( ⍳⎕) -1 तक कम्यूटिंग ( ) पावर ऑपरेटर के तर्कों ( *) से करता है। परिणामी वेक्टर संक्षेप द्वारा कम हो जाता है ( +/) और एक स्केलर वापस आ जाता है।


टास्क 2, जूलिया, 42 बाइट्स

n->(isprime(n)&&int(log2(n+1))==log2(n+1))

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को इनपुट के रूप में स्वीकार करता है और एक बूलियन देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=n->...

पहले हम जूलिया के अंतर्निहित फ़ंक्शन का उपयोग isprimeयह देखने के लिए करते हैं कि क्या nप्रधान है। यदि यह है, तो हम जाँचते हैं कि log2(n+1)एक पूर्णांक है। यदि हां, तो कुछ के लिए nलिखा जा सकता है , और इस प्रकार एक मेर्सेन प्राइम है।2^k-1kn


टास्क 3, ईएलआई , 19 बाइट्स

{f:x[<x][~.0.5*#x]}

यह एक मोनाड बनाता है fजो इनपुट वेक्टर के माध्य को लौटाता है।

असंगठित + स्पष्टीकरण:

{f:         // Define a function f
 x[<x]      // Sort the input vector
 [          // Select the element at index...
 ~.0.5*#x   // ceiling of 0.5 * length(input)
]}

उदाहरण:

    f 1 2 3 4
2
    f ?.!20   // Apply f to 20 random integers in 1..20
4

टास्क 4, ऑक्टेव, 39 बाइट्स

@(n,x=2863311530)dec2bin(bitxor(n+x,x))

यह एक फ़ंक्शन हैंडल बनाता है जो पूर्णांक को इनपुट के रूप में स्वीकार करता है और संबंधित नकारात्मक स्ट्रिंग को वापस करता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=@..., और साथ चलाएं feval(f, <input>)

आप इसे ऑनलाइन आज़मा सकते हैं ।


टास्क 5, सीजेएम, 47 बाइट्स

"pneumonoultramicroscopicsilicovolcanoconiosis"

स्ट्रिंग को बस STDOUT में प्रिंट किया जाता है। यदि आप ऐसा महसूस करते हैं तो आप इसे ऑनलाइन आज़मा सकते हैं ।


टास्क 6, विंडोज बैच, 46 बाइट्स

if "%date:~4,5%"=="01/01" echo Happy New Year!

चर %date%में प्रपत्र में वर्तमान दिनांक शामिल है Thu 06/25/2015। हम पहले 4 वर्णों को छोड़ देने के बाद लंबाई 5 का विकल्प प्राप्त करके महीने और दिन का चयन कर सकते हैं %date:~4,5%:। वहां से हम सिर्फ यह जाँचते हैं कि क्या यह पहली जनवरी है और यदि हैप्पी न्यू ईयर है तो कहें।


टास्क 7, पायथ, 26 बाइट्स

=Gr13312 19895FNU64pC.(.SG

सबसे पहले हम G19894 समावेशी के माध्यम से 13312 की सीमा को सौंपते हैं। फिर हम 64 बार लूप करते हैं, और प्रत्येक पुनरावृत्ति पर हम फेरबदल करते हैं G( .SG), अंतिम तत्व ( .() को हटाते हैं , और इसके चरित्र प्रतिनिधित्व को प्रिंट करते हैं ( pC)।

आप इसे ऑनलाइन आज़मा सकते हैं ।


टास्क 8, रूबी, 36 बाइट्स

def f(a,b)!b.tr("^"+a,"")[a].nil?end

यह एक फ़ंक्शन को परिभाषित करता है fजो दो तारों को स्वीकार करता है aऔर b, जहां aस्ट्रिंग को खोजने के लिए है b

सब कुछ लेकिन वर्णों का उपयोग करने aसे हटा दिया जाता है और हम जांचते हैं कि क्या परिणाम बिल्कुल उपयोग में है । यह वापस आ जाएगी अगर स्ट्रिंग नहीं पाया जाता है, तो हम का उपयोग करके एक बूलियन मान प्राप्त कर सकते हैं के साथ ।b.tr()a[]nil!.nil?


टास्क 9, आर, 16 बाइट्स

function(x,n)n*x

यह एक अनाम फ़ंक्शन ऑब्जेक्ट बनाता है जो किसी भी प्रकार की सरणी या मैट्रिक्स xऔर एक पूर्णांक को स्वीकार करता है nऔर प्रत्येक तत्व को गुणा करता xहै n। यदि आप चाहें, तो आप इसे ऑनलाइन आज़मा सकते हैं ।


टास्क 10, पायथन 3, 92 बाइट्स

n=int(input())
l="\n"
w=" ()--() "
print(" ______  "*n+l+"|      | "*n+l+(w+"~")*(n-1)+w)

बहुत सीधा। आप इसे ऑनलाइन आज़मा सकते हैं ।


APL उत्तर काफी 7 बाइट्स नहीं है, क्योंकि उच्च रेंज में तीन यूनिकोड वर्ण हैं।
टॉम

6
@ टोम: हर उत्तर सबसे सुविधाजनक एन्कोडिंग चुन सकता है। में एपीएल कोड पेज , एक चरित्र एक बाइट है।
डेनिस

यदि आप ऐसा महसूस करते हैं तो आप इसे ऑनलाइन आज़मा सकते हैं :-D
लुइस मेंडो

7

टास्क 1,> <>, 10 + 3 = 13 बाइट्स

::*-:*4,n;

ध्वज का उपयोग करके आधिकारिक पायथन दुभाषिया का उपयोग करके इसे चलाएं -v(3 बाइट्स की लागत पर)। यह मात्रा (n - n*n)को विभाजित करता है और विभाजित करता है 4, जो निश्चित रूप से स्क्वेरिंग (n*n - n)और विभाजन के बराबर है 4

टास्क 2, जीएपी, 63 62 बाइट्स

b:=function(m)return[2]=AsSet(Factors(m+1))and IsPrime(m);end;

(समानता को दूसरे तरीके से चारों ओर लिखकर एक जगह बचाई।)

टास्क 3, आर, 43 39 बाइट्स

f=function(v)sort(v,d=T)[length(v)%/%2]

अच्छे सुधार के लिए प्लान्पस का धन्यवाद!

टास्क 4, पीट, 155 135 115 5 * 19 = 95 कोडल

यहाँ छवि विवरण दर्ज करें

इस ऑनलाइन इंटरप्रेटर का उपयोग करके टेस्ट करें , कोडेल साइज 13. या अपने पसंदीदा इंटरप्रेटर का उपयोग करें - मुझे बताएं कि क्या आपके पास कोई पसंद है!

0इनपुट के लिए खाली स्ट्रिंग के बजाय इसे आउटपुट करना 0असुविधाजनक था। मैंने इस मामले का ध्यान रखने के लिए शुरुआत के पास एक if-then का उपयोग किया; तब नॉनस्टेरो केस में अंकों की गणना करने के लिए एक लूप-लूप, और अंत में एक और लूप जबकि अंत में स्टैक से अंकों को आउटपुट करने के लिए।

कुछ बहुत ही उपयोगी टिप्पणियों के लिए Sp3000 के लिए बहुत धन्यवाद, जिसने मुझे कुछ कोडल्स को बचाने में मदद की!

टास्क 5, लुआ, 52 बाइट्स

print"pneumonoultramicroscopicsilicovolcanoconiosis"

आप इसे यहाँ आज़मा सकते हैं

टास्क 6, LaTeX, 157 139 136 127 128 बाइट्स

\documentclass{book}\begin{document}\count1=\day\multiply\count1 by\month
\ifcase\count1\or Happy New Year!\else~\fi\end{document}

यदि दिन और महीने का उत्पाद है 1, तो संदेश प्रिंट करें; अन्यथा, कुछ भी नहीं। (नए साल का दिन इस डिजाइन के लिए विशेष रूप से सुविधाजनक है: चूंकि हम जिस आउटपुट की तलाश कर रहे हैं 1, हमें केवल एक orकथन की आवश्यकता है। nवें orविवरण मूल्य के लिए व्यवहार को निर्दिष्ट करता है n।)

नोट: मेरा पिछला संस्करण लाइन रिटर्न याद कर रहा था, जो कि एक गलती थी। (मैंने इस फ़ंक्शन का परीक्षण करने की कोशिश की, लेकिन वास्तव में इसे ठीक से परीक्षण करने में थोड़ा समय लग सकता है ...)

मेरे मूल संस्करण ने calcपैकेज का उपयोग किया , जो मेरे वर्तमान संस्करण की तुलना में बहुत अधिक सुविधाजनक था। "वास्तविक जीवन" के लिए कुछ ध्यान में रखना!

टास्क 7, रूबी, 62 बाइट्स

for r in Array(13312..19893).sample(64)
puts [r].pack('U*')end

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

h=function(l,m){u=1+m.indexOf(l[0]);return(!l||u&&h(l.substr(1),m.substr(u)))}

पुनरावर्ती समाधान, परीक्षण है कि क्या lएक विकल्प है m। यदि lखाली है, तो !lपरिणाम trueऔर फ़ंक्शन समाप्त हो जाते हैं। (इस मामले में, l[0]अपरिभाषित है, लेकिन जावास्क्रिप्ट इसके साथ ठीक है।) अन्यथा, यह पहली बार में दिखता l[0]है m। यदि यह एक नहीं खोजता है, तो m.indexOf(l[0])परिणाम में -1और इसलिए और uपरिणाम 0समाप्त हो जाता है।

अन्यथा, यह lऔर के पहले uप्रविष्टियों को छीन लेता है mऔर जाँच जारी रखता है।

टास्क 9, पायथन, 72 60 बाइट्स

def i(a,n):
 try:return[i(c,n)for c in a]
 except:return n*a

"सबसे निचले स्तर" पर पहुंच जाता है, जहां aअब कोई सूची नहीं है, सिर्फ एक पूर्णांक है, फिर गुणन को पूरा करता है।

मुझे 12 बाइट्स बचाने के लिए डेनिस के लिए बहुत धन्यवाद!

टास्क 10, ग्रूवी, 81 बाइट्स

def j(n){(' ------  '*n+'\n'+'|      | '*n+'\n'+' ()--() ~'*n).substring(0,27*n)}

इसे यहाँ आज़माएँ । मैंने मूल रूप से .join()स्ट्रिंग्स के लिए पायथन की विधि की तरह कुछ लागू करने की कोशिश की , जो एक विशेष "लिंकिंग स्ट्रिंग" (ट्रेन कारों के बीच की कड़ी की तरह) के साथ तार जोड़ता है। लेकिन यह एक बहुत अधिक लागत की तुलना में इसे बचाया।

मुझे आशा है कि मैंने इन विभिन्न भाषाओं में स्वीकार्य उत्तरों के लिए किसी भी सम्मेलन को नहीं चलाया है, लेकिन कृपया मुझे बताएं कि क्या मेरे पास है।

शानदार चुनौती के लिए डेनिस को धन्यवाद!


except:return n*aकार्य 9 के लिए कुछ बाइट्स बचाता है। कार्य 1 के लिए, मैं -vध्वज को एक बाइट के रूप में गिनूंगा।
डेनिस

@ डेनिस इस मेटा पोस्ट को देखें । हालाँकि, इस मेटा पोस्ट के द्वारा , आप संभवतः -vझंडे को बदल सकते हैं i(हालाँकि मुझे लगता है कि यह अच्छा होगा यदि दोनों संस्करणों का उल्लेख किया गया था, आसान काम के लिए)।
Sp3000

@ डेनिस, आपके स्मार्ट सुधार के लिए बहुत बहुत धन्यवाद!
मैथमंडन

1
3 बाइट्स मेटा पोस्ट द्वारा ऊपर (स्पेस -, v) द्वारा सही है । मेरा सिर्फ यह मतलब था कि आपके पास iनिर्देश के माध्यम से कोड बिंदु के रूप में इनपुट लेने का विकल्प है ।
Sp3000

1
btw, # 4 के लिए, नकारात्मक मोडुलो अजीब नहीं है - यह बस भाषा से भाषा में भिन्न होता है (उदाहरण के लिए जावा मेमोरी से होता है)। पूरे स्टैक को आउटपुट करने का एक तरीका यह हो सकता है कि स्टैक के निचले भाग में कुछ रखा जाए, जिसे आप जानते हैं कि आउटपुट में नहीं होगा, और प्रिंट चार्ट रखें, जबकि यह विशेष चार्ट नहीं है। इसके अलावा, PietCreator है
Sp3000

6

टास्क 1, पायथ, 5 बाइट्स

s^R3Q

स्टड से नंबर लेता है। धन्यवाद @Jakube बेकार इंगित करने के लिए U

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

if(Date().slice(4,10)=="Jan 01")alert("Happy New Year!")

टास्क 7, सीजेएम, 16 बाइट्स

6581,mr64<'㐀f+

रेंज बनाता है, फेरबदल, पहले 64 उठाता है, और शुरू मूल्य के अलावा नक्शे और चरित्र में परिवर्तित। 14 चरस, 16 बाइट्स।

टास्क 8, ऑक्टेव, 23 बाइट्स

@(x,y)intersect(x,y)==x

अनाम फ़ंक्शन को परिभाषित करता है।

टास्क 5, पीएचपी, 45 बाइट्स

pneumonoultramicroscopicsilicovolcanoconiosis

कोई संपीड़न नहीं, सिर्फ प्रिंट।

टास्क 9, एपीएल 1 बाइट

 ×

K उत्तर के समान है।


@ डेनिस मैं इसे या तो नहीं जानता - मैं सिर्फ कूबड़ पर चलता हूं और इस जवाब को एक साथ परीक्षण किए बिना :)। मैं अब एक एमुलेटर पर परीक्षण करने की कोशिश करूँगा।
माल्टसेन

@ डेनिस ओह तुम सही कह रहे हो, यह बीच 2 का औसत है, जो नीचे ले जा रहा है।
माल्टसेन

1
आप उस जगह के साथ क्या कर रहे हैं .slice(4, 10)?
लीजनमोनमाल 978

@ डेनिस डेरप। माफ़ करना।
माल्टेन

1
केवल एक महीने का संक्षिप्त नाम है जो "ए" के साथ समाप्त होता है, इसलिए आप परीक्षण करते समय जे को छोड़ सकते हैं। (यह भी करने के लिए काफी छोटा होगा /an 01/.test(Date())।)
निंजाबियरमॉन्की

6

टास्क 1, आर, 21 19 बाइट्स

sum((1:scan()-1)^3)

काफी सरल। एसटीडीआईएन से इनपुट

टास्क 2, पर्ल, 40 66 बाइट्स

$a=log(<>+1)/log(2)+1;print$a==int($a)&&(1x$a)!~/^1?$|^(11+?)\1+$/

एक प्रमुख चेकर जोड़ा गया (अबीगल्स प्राइम नंबर चेकर regex)

टास्क 3, PARI / GP, 24 22 बाइट्स

m(v)=vecsort(v)[#v\2];

पहली बार मैंने इसे छुआ था। इसके बारे में थोड़ा और सीखना पड़ सकता है।

टास्क 4, टी-एसक्यूएल, 235 बाइट्स

CREATE FUNCTION D(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @/-2+(IIF(@%-2<0,1,0))D,CAST(ABS(@%-2) AS VARCHAR(MAX))M UNION ALL SELECT D/-2+(IIF(D%-2<0,1,0)),CAST(ABS(D%-2)AS VARCHAR(MAX))+M FROM R WHERE D<>0)SELECT M FROM R WHERE D=0

पुनरावर्ती CTE का उपयोग करके इनलाइन टेबल फ़ंक्शन। बहुत बड़ा है, लेकिन करने के लिए मजेदार है।

काम में लाना

SELECT * FROM D(18)
M
------
10110

टास्क 5, जीएपी, 48 बाइट्स

"pneumonoultramicroscopicsilicovolcanoconiosis";

टास्क 6, एक्सेल, 51 48 बाइट्स

=IF(TEXT(NOW(),"md")="11","Happy New Year!","")

3 बाइट्स के लिए @Bond के लिए धन्यवाद।

टास्क 7, पायथन 2.6, 98 93 85 बाइट्स

from random import*
l=range(13312,19893)
shuffle(l)
print ''.join(map(unichr,l[:64]))

यह पहली बार है जब मैंने पायथन में कुछ भी करने की कोशिश की है, इसलिए यह बहुत बेहतर हो सकता है। महान सुझावों के लिए @Dennis और @Jacob धन्यवाद

टास्क 8, बंधन, 57 बाइट्स

proc m {a b} {string match [regsub -all (.) $a *\\1]* $b}

शर्म की बात है कि व्हॉट्सएप को हटाने से यह मौत हो गई

टास्क 9, पाइक, 53 बाइट्स

mixed m(array(array(int))a,int n){return(a[*])[*]*n;}

एक फ़ंक्शन जो गुणा सरणी देता है

टास्क 10, पॉवर्सशेल, 88 बाइट्स

Function t($n){Foreach($s in "  ______ "," |      |","~ ()--() "){($s*$n).Substring(1)}}

एक पॉवर्सशेल फ़ंक्शन। मुझे लगता है कि मैं इसे थोड़ा छोटा कर सकता हूं, लेकिन यहां यह फिलहाल है।

और अंत में :)


आप कार्य 6 पर 4 बाइट्स बचा सकते हैं =IF(TEXT(NOW(),"md")="11","Happy New Year!",""):।
बंधन

@ इसके लिए धन्यवाद
मिकी टन

मैं या तो अजगर को नहीं जानता, लेकिन l[:63]काम करना चाहिए और (13312,19894)हेक्साडेसिमल स्थिरांक (और योग) से छोटा है।
डेनिस

@ डेनिस धन्यवाद इसे बदलने और बदलने की कोशिश करेगा
मिकी टन

@ डेनिस ने 19893 को उच्च मूल्य के रूप में उठाया क्योंकि range(19892,0x4DB5+1)मुझे दिया था[19892, 19893]
मिकट

4

टास्क 2, जे, 10 बाइट्स

1&p:*/@,#:

एक बूलियन 0 या 1 प्रीपेंड करता है यदि इनपुट इसके बाइनरी प्रतिनिधित्व के लिए प्रमुख है, तो उत्पाद लेता है। जे के वर्तमान संस्करण पर काम करता है।


टास्क 5, एचटीएमएल, 45 बाइट्स

pneumonoultramicroscopicsilicovolcanoconiosis

टास्क 6, मछली, 53 बाइट्स

test 0101 = (date '+%d%m');and echo 'Happy New Year!'

बैश जवाब के आधार पर।


टास्क 8, एपीएल, 12 बाइट्स

{(⍳⍴⍺)≡⍋⍵⍳⍺}

यह एक फ़ंक्शन अभिव्यक्ति है। यह वर्णों के क्रम की तुलना बड़े स्ट्रिंग में पाया जाता है, यदि उन्हें छाँटा जाता है तो क्या अपेक्षित होगा।


टास्क 9, के, 1 बाइट

*

किसी भी संस्करण में काम करना चाहिए। अंकगणित संचालन सरणियों पर वितरित करते हैं।


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

2
कार्य 8 के लिए आपका कोड काम नहीं करता है abc caxbxc
jimmy23013

4

टास्क 1, रूबी, 40 बाइट्स

def f n;(0..n-1).inject{|a,b|a+b**3};end

पहली बार कभी रूबी में कुछ भी लिखते हुए। रूबी 1.8.7 के साथ परीक्षण किया गया।


टास्क 2, आर, 50 बाइट्स

n=scan();p=log(n+1,2);!p%%1&sum(!n%%2:n,!p%%2:p)<3

गणना करें p, जांचें कि क्या यह पूर्णांक है, और यदि n और p primes हैं।


टास्क 5, PostgreSQL, 54 बाइट्स

SELECT'pneumonoultramicroscopicsilicovolcanoconiosis';

टास्क 6, लुआ, 55 बाइट्स

print(os.date("%j")=="001" and "Happy New Year!" or "")

टास्क 8, पायथन, 65 बाइट्स

import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))

उपयोग:

>>> import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))
>>> f('abc','axbxcx')
True
>>> f('bac','axbxcx')
False
>>> f('abc','axdxcx')
False
>>> f('abc','abc')
True

टास्क 10, जूलिया, 73 बाइट्स

f(n)=print(" ______  "^n*"\n"*"|      | "^n*"\n"*(" ()--() ~"^n)[1:9n-1])

@AlexA को धन्यवाद। इस कोड को छोटा करने में मदद करने के लिए! आउटपुट का उदाहरण:

julia> f(0)




julia> f(1)
 ______  
|      | 
 ()--() 

julia> f(2)
 ______   ______  
|      | |      | 
 ()--() ~ ()--() 

julia> f(3)
 ______   ______   ______  
|      | |      | |      | 
 ()--() ~ ()--() ~ ()--() 

टास्क 2 के लिए आप उपयोग कर सकते हैंlog2
मिकी टन

मैं आपके जूलिया कार्य के लिए वर्तमान में 86 बाइट्स की गिनती करता हूं। 10. लेकिन आप इसे लंबोदा फ़ंक्शन (यानी प्रतिस्थापित f(n)=करें n->) का उपयोग करके और 1:(9*n-1)बस बदलकर 81 कर सकते हैं 1:9n-1
एलेक्स ए।

ठीक है मुझे \nआदत से 1 बाइट्स के रूप में गिना जाता है।
प्लेनैपस

के बजाय (" "*"_"^6*" ")^n, आप का उपयोग कर सकते हैं " ______ "^n(इसी तरह | |भाग के लिए)। 70 बाइट्स: n->print(" ______ "^n*"\n"*"| | "^n*"\n"*(" ()--() ~"^n)[1:9n-1])। (सलाखों के बीच व्हॉट्सएप हालांकि यहाँ प्रदर्शित नहीं हो रहा है)
एलेक्स ए।

3

टास्क 1, हास्केल, 17 बाइट्स

f x=(x*(x-1)/2)^2

टास्क 2, गणितज्ञ, 30 बाइट्स

PrimeQ@#&&Mod[Log2[#+1],1]==0&

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

function(x){return x.sort()[0|(x.length-1)/2]}

टास्क 5, MATLAB, 47 बाइट्स

'pneumonoultramicroscopicsilicovolcanoconiosis'

टास्क 6, रूबी, 56 बाइट्स

print Time.now.to_s[5,5]=="01-01"?"Happy New Year!":""

टास्क 7, पायथन, 106 बाइट्स (साथ इंडेंट करना \t)

from random import*
s=''
while len(s)<64:
    c=unichr(randint(0x3400,0x4DB5))
    if c not in s:
        s+=c
print s

नोट की है कि सीधा उपयोग list(set(s))करता है नहीं यहाँ काम के रूप में इस की अंतरिक्ष में एक अ-समतल प्रायिकता वितरण का कारण होगा हर संभव तार फिर से आदेश देने के लिए सूची के सदस्यों की वजह से है।



@ डेनिस री टास्क 7: प्वाइंट 1 पर सहमत, जब भी मौका मिलेगा मैं ठीक करूंगा। REPL के संबंध में, क्या इसके खिलाफ कोई नियम है?
सरन

अब सब ठीक है।
सारण

1 के लिए, संभवतः आप कर सकते हैं (x*x-x)^2/4?
xnor

आमतौर पर, जावास्क्रिप्ट का डिफ़ॉल्ट सॉर्ट फ़ंक्शन तुलना करते समय संख्याओं को स्ट्रिंग में बदल देता है, इसलिए यह केवल हर नंबर के पहले अंक की तुलना करता है। इसलिए, यह [2,3,10] पर विफल रहता है।
निंजाबियरनॉन्की

1
7 में, आप वास्तव if c not in s:s+=cमें कुछ वर्णों को सहेजते हुए सभी को एक पंक्ति में रख सकते हैं । इसके 0x3400साथ प्रतिस्थापित किया जा सकता है 13312, जो एक वर्ण छोटा है (और इसी तरह 0x4db5 के लिए)। अंत में, यह वर्णों की संख्या नहीं बदलेगा, लेकिन यदि आपको टैब इंडेंटेशन पसंद नहीं है, तो आप इसके स्थान पर एकल स्थान के साथ इंडेंट कर सकते हैं।
मैथमैनंदन

3

टास्क 1, हास्केल, 15 बाइट्स

f n=(n*n-n)^2/4

टास्क 2, जूलिया, 28 बाइट्स

n->(isprime(n)&&ispow2(n+1))

टास्क 3, ऑक्टेव, 30 बाइट्स

@(x)sort(x)(ceil(length(x)/2))

टास्क 5, याक , 45 बाइट्स

pneumonoultramicroscopicsilicovolcanoconiosis

टास्क 6, गणितज्ञ, 46 बाइट्स

If[DateList[][[{2,3}]]=={1,1},Happy New Year!]

टास्क 9, PARI / GP, 10 बाइट्स

(n,a)->n*a

3

टास्क 3, क्लिप, 13 बाइट्स

gHk[tivt}l`sk

एक और संस्करण:

gHkci`v``l`sk

`बहुत ज्यादा खर्च लग रहा था।

टास्क 4, KSFTgolf, 16 बाइट्स

g:]2%:)-2/:;xgpc

दुभाषिया यहाँ है।मुझे यकीन नहीं है कि मैं क्या कर रहा हूं ... यह नकारात्मकता को मुद्रित करेगा और फिर दुर्घटनाग्रस्त हो जाएगा।

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

2*02-ba'Z=;x

मूल CJam संस्करण:

qi{_1&_@^-2/}h;]W%

मैंने पिप, शुतुरमुर्ग, क्लिप और बर्लेस्क की कोशिश की कि यह पता लगाया जा सके कि निर्मित में नकारात्मकता के साथ एक एसोलैंग है या नहीं। उनमें से किसी ने भी काम नहीं किया। KSFTgolf इस्तेमाल कियाnumpy , जो लग रहा था कि आधार नकारात्मक होने पर कुछ शानदार अजीब व्यवहार करता है। लेकिन इसे गैर-सकारात्मक संख्याओं के साथ काम करना आसान नहीं है।

टास्क 7, सीजेएम, 15 बाइट्स

'䶶,DAm<>mr64<

टास्क 8, एपीएल, 21 बाइट्स

∨/↑{⍺∧0,2∧/∨\⍵}/⌽⍞=↓⍞

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


लोल @ "मुझे यकीन नहीं है कि मैं क्या कर रहा हूं"
एलेक्स ए।

इस बारे में सवाल बहुत स्पष्ट नहीं था, लेकिन मेरा इरादा यह था कि टास्क 4 के लिए कोड को इनपुट 0. संभालना चाहिए। बिना बिल्ट-इन बेस रूपांतरण के संस्करण इसे ठीक-ठाक संभालने के लिए लगता है।
डेनिस

@ डेनिस निश्चित। लेकिन क्या होगा अगर मैंने यूनीरी का उपयोग करना चुना?
jimmy23013

कुछ निश्चित ऑफसेट या 2 के पूरक का उपयोग करने से काम हो सकता है। मैं भी एक संख्या के बाद एक संकेत स्वीकार करता हूँ।
डेनिस

3

टास्क 2, x86 मेस्म, 40 बाइट्स

C7 45 FC FF FF 07 00 B9 
00 00 00 00 B8 02 00 00 
00 D3 E0 3B 45 FC 7D 03 
41 EB F1 B8 02 00 00 00
D3 E0 48 3B 45 FC 75 13

(हेडर, मैसेजबॉक्स आदि को छोड़कर - केवल प्रासंगिक बाइट्स)

include     \masm32\include\user32.inc  
includelib  \masm32\lib\user32.lib

.data
    ClassName   db "Mersenne Prime Found",0
.data?

.code
start proc
    LOCAL IsMersenne: DWORD
    mov IsMersenne, 524287 ; put number to test in this input
    mov ecx, 0
l00p:
    mov eax, 2
    shl eax, cl
    cmp eax, IsMersenne
    jge br3ak
    inc ecx
    jmp l00p
br3ak:
    mov eax,2                                                                                     
    shl eax, cl 
    dec eax
    cmp eax, IsMersenne                                                           
    jnz n0pr1me                                                              
    invoke MessageBox, 0, addr ClassName, addr ClassName, 40h
n0pr1me:
    ret
start endp
end start

टास्क 3, सी, 136 बाइट्स

#include<stdio.h> 
int C(void*A,void*B){return(*(int*)A-*(int*)B);} 
main(){int S=4;int A[]={3,1,2,4};qsort(A,S,4,C);printf("%i",A[((S&1)?S:S-1)/2]);}

संकलन का उपयोग करें gcc -o Prime main.c


टास्क 10, सी ++, 478 बाइट्स

#include<stdio.h>
#include<string.h> 
#include<stdlib.h>
void D(int Z){int L=9,i,X=0;const char*A=" ______  ";const char*B="|      | ";const char* C = " ()--() ~ ";char*P=(char*)malloc(27*Z+5);for(i=0;i<Z-1;i++){if(!i){memcpy(P,A,L);X+=L;}memcpy(&P[X],A,L);X+=L;if(i==Z-2){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],B,L);X+=L;if(i==Z-1){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],C,L);X+=L;if(i==Z-1)P[X-1]='\0';}printf("%s\n",P);free(P);}
main(){D(15);}

संकलन का उपयोग करें g++ -o Trucks main.cpp

C & C ++ को छोटा किया जा सकता है लेकिन यह संकलक त्रुटि को जोड़ देगा। सटीक नियम नहीं जानते इसलिए मैंने कोड w / नो कंपाइलर त्रुटियों को छोड़ने का प्रयास किया।


3
PPCG में आपका स्वागत है! कंपाइलर चेतावनियों को सुरक्षित रूप से अनदेखा किया जा सकता है, जब तक कंपाइलर एक प्रयोग करने योग्य बाइनरी का उत्पादन करता है।
डेनिस

2
कोड गोल्फ में, एक सी कंपाइलर आपको चेतावनी देगा कि इसे चेतावनी देकर और आगे बढ़ाया जा सकता है ।
कॉमिनटेन

चेतावनियों को नजरअंदाज करें - और महसूस करें, एर करें, मुफ्त में जितनी चाहें उतनी मेमोरी लीक करें । :-)
टोबी स्पाइट

3

टास्क 1, पायथन, 35 बाइट्स

lambda x:sum(_**3for _ in range(x))

टास्क 3, सीजेएम, 9 बाइट्स

q~$_,(2/=

टास्क 4, जावास्क्रिप्ट, 55 53 बाइट्स

function(n){s=0xAAAAAAAA;return((n+s)^s).toString(2)}

टास्क 5, पायथ, 46 बाइट्स

"pneumonoultramicroscopicsilicovolcanoconiosis

टास्क 6, सी #, 65 बाइट्स

string c(){return DateTime.Now.DayOfYear<2?"Happy New Year!":"";}


2

टास्क 1, Cjam, 7 बाइट्स

q~,:+_*

संपादित करें: बस ध्यान दिया मार्टिन ने मेरे सामने यह पोस्ट किया। मैं कुछ और कोशिश करूँगा ...

टास्क 3, पायथन, 30 बाइट्स

lambda l:sorted(l)[~-len(l)/2]

अजगर २।

टास्क 5, ///, 45 बाइट्स

pneumonoultramicroscopicsilicovolcanoconiosis

/// बिना किसी /वर्ण के बस कुछ प्रतिध्वनित करेगा ।

टास्क 7, पायथ, 19 बाइट्स

s>64.SmC+13312d6582

कार्यक्रम। कृपया मुझे बताएं कि क्या मैंने गणित में गड़बड़ की है। इसे यहाँ आज़माएँ

टास्क 9, ऑक्टेव, 9 बाइट्स

@(a,n)a*n

अनाम फ़ंक्शन हैंडल। ऑक्टेव स्वचालित रूप से मैट्रिक्स * स्केलर के साथ ऐसा करता है।


टास्क 7 के लिए, यह अद्वितीय होना चाहिए।
माल्टसेन

हाँ, pyth में .Sफेरबदल है, और आप sइसके बजाय um का उपयोग कर सकते हैं jk
माल्टसेन

2

मुझे उन सभी का प्रयास करने का समय नहीं मिला है, लेकिन यहां एक शुरुआत है

टास्क 1, डीसी, 8 बाइट्स

d1+*d*4/

इनपुट और आउटपुट स्टैक के शीर्ष पर, प्रति के रूप में dcकन्वेंशन के ।

टास्क 5, एमएसीएस लिस्प, 46 बाइट्स

'pneumonoultramicroscopicsilicovolcanoconiosis

नियमों का दुरुपयोग:

grep 'pn.*v' /usr/*/*/brit*-large

सबसे अच्छा मैं संकुचित रूप से अनपैकिंग द्वारा प्रबंधित कर सकता था 55, पर्ल में:

unpack("H45",'uïFVóÙ¤¼g°0Æö<¥le°°')=~y/0-9bdf/i-v/r

(गैर-प्रिंट किए गए वर्ण ऊपर से SE से आकृष्ट हुए हैं, लेकिन जैसा कि यह वास्तव में मेरा उत्तर नहीं है, मैं इसे ठीक नहीं कर रहा हूं)

टास्क 6, एसक्यूएल, 54 बाइट्स

SELECT IF(now()LIKE'%-01-0_%','Happy New Year!','Hi');

मैं इस अभिवादन के लिए जनवरी के पहले दस दिनों को 'उपयुक्त' दिन मानता हूं, लेकिन आप स्वाद के लिए समायोजित कर सकते हैं। now() LIKEनिर्माण के साथ साल के दिन के अनुसार निकालने की तुलना में कम बाहर काम करता हैDATE_FORMAT(now(),'%j')

टास्क 10, sed, 58 बाइट्स

s/./ ()--() ~/g;s/.$//;h;y/()-~/___ /;p;g;y/ ()-~/|    /;G

अनार्य में इनपुट


strstrसबस्ट्रिंग के लिए पहुंचता है, परवर्ती नहीं। मुझे डर है कि काम 5 kolmogorov-complexity है, इसलिए किसी शब्दकोश से शब्द लाना चतुर हो सकता है, लेकिन इसकी अनुमति नहीं है।
डेनिस

धन्यवाद। मैं एक के बाद एक गलत समझा। मैं एक वैकल्पिक कार्य 5 करूंगा, लेकिन यह बहुत उबाऊ है।
टोबे स्पाइट

5 कार्य करने के लिए कुछ दिलचस्प समाधान हैं, लेकिन किसी ने भी अब तक एक छोटी पोस्ट नहीं की है ।
डेनिस

1

टास्क 5, मारियोगॉल्फ , 50 बाइट्स

यह एक ऐसी भाषा थी जिसे मैंने कुछ समय के लिए विकसित किया है।

वर्तमान संस्करण में इस चुनौती को चलाने के लिए पर्याप्त कार्यक्षमता है।

Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

आप इसे http://htmlpreview.github.io/?https://raw.githubusercontent.com/ismael-miguel/mariogolf/master/js/testpage.html#c।

वर्तमान में, विकास बंद है और कार्यान्वयन अपूर्ण है।

नवीनतम प्रतिबद्धता 13 मार्च 2015 को थी।

टास्क 6, पीएचपी, 37 बाइट्स

यह एक वास्तव में आसान है, और मजेदार है!

<?=date(jn)==11?'Happy New Year!':'';

टास्क 10, जावास्क्रिप्ट, 121 बाय

हाँ, इतना गोल्फ नहीं ...

लेकिन यह काम करता है!

console.log((' ______  '.repeat(i=prompt()))+'\n'+('|      | '.repeat(i))+'\n'+(' ()--() ~'.repeat(i).replace(/~$/,'')));

कोशिश करो:

"आउटपुट के साथ शुरू होने के कारण स्टैक स्निपेट में कोड अच्छी तरह से प्रदर्शित नहीं होगा । इसकी भरपाई के लिए एडिशनल स्पेस जोड़े गए।

क्रोम के कंसोल पर मूल कोड को बिना किसी समस्या के निष्पादित किया जा सकता है, और आउटपुट अपेक्षित होगा।


@ डेनिस धन्यवाद! मैंने कार्य को गलत किया है 5. मैं अभी भी देख रहा हूं कि मैं अन्य कार्यों को कैसे लागू करूंगा, लेकिन मैं एक बुरा समय बिता रहा हूं।
इस्माइल मिगुएल

1
क्या आप इसके बारे में निश्चित हैं date(dM)? यहाँ यह "25 जून" देता है। (लोकेल को en_US पर सेट करें) हो सकता है कि "j" और "n" बेहतर सेवा करते हैं, क्योंकि "d" और "m" मान 0 से चौड़ाई 2 तक
पहुँचते हैं

@manatwork आप सही हैं। यह मेरी गलती थी। कि तुम उस जगह के लिए।
इस्माइल मिगुएल


1

टास्क 1, ऑक्टेव, 15 बाइट्स

@(n)(n^2-n)^2/4

संपादित करें: मुझे लगा कि मैंने इसे जोड़ा है लेकिन ऐसा लगता है कि मैं बचाना भूल गया: यह इस तथ्य का उपयोग करता है कि sum(1^3+2^3+3^3+...+n^3) = sum(1+2+3+...+n)^2 = [n*(n+1)/2]^2

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

x=>x.sort()[x.length>>1]

1

ठीक है, चलो आसान सामान पहले करें:

टास्क 5, एएसपी, 45 बाइट्स

pneumonoultramicroscopicsilicovolcanoconiosis

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

/an 01/.test(Date())&&alert("Happy New Year!")

1

टास्क 1, वीबीए, 126 बाइट्स

Function f(n As Integer)
    Dim i As Integer
    For i = 0 To n - 1
        f = f + i ^ 3
        Next i
End Function

मुझे कोई सुराग नहीं मिला कि वीबीए में गोल्फ कैसे किया जाए। मैंने एक भी स्थान नहीं टाइप किया, VBA स्वचालित रूप से व्हॉट्सएप डालें। =f(5)एक्सेल में एक सेल में 100 प्रदर्शित करेगा।

टास्क 2, ऑक्टेव, 32 बाइट्स

@(n)isprime(n)&~mod(log2(n+1),1)

टास्क 5, गोल्फस्क्रिप्ट, 47 बाइट्स

"pneumonoultramicroscopicsilicovolcanoconiosis"

टास्क 9, MATLAB, 9 बाइट्स

@(A,n)A*n

खैर, यह एक शुरुआत है ...

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.