विभिन्न कार्य, एक ही वर्ण

Question

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

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

ध्यान दें कि यह वर्णों की सबसे छोटी संख्या है, न कि अद्वितीय वर्णों की सबसे छोटी संख्या ।

कार्य 1:

Nहर तीसरे कम्पोजिट नंबर की पहली संख्या को आउटपुट करें । नीचे दिया गया कोडब्लॉक पहली पंक्ति में पहले 19 मिश्रित संख्याओं को दिखाता है, और नीचे की पंक्ति में हर तीसरे मिश्रित नंबर को।

4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30
4,       9,         14,         18,         22,         26,         30

यदि N=5तब आउटपुट होना चाहिए 4, 9, 14, 18, 22। आपको समर्थन करना चाहिए 1<=N<=50।

समग्र संख्याएँ सकारात्मक संख्याएँ हैं जो अभाज्य संख्याएँ या 1 नहीं हैं।

के लिए परिणाम N=50है:

4, 9, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 57, 62, 65, 69, 74, 77, 81, 85, 88, 92, 95, 99, 104, 108, 112, 116, 119, 122, 125, 129, 133, 136, 141, 144, 147, 152, 155, 159, 162, 166, 170, 174, 177, 182, 185, 188, 192

कार्य 2:

आउटपुट एक N-by-Nगुणन तालिका। आपको समर्थन करना चाहिए1<=N<=20

उदाहरण:

N = 4
1   2   3   4
2   4   6   8
3   6   9  12
4   8  12  16

आउटपुट स्वरूप वैकल्पिक है, निम्न स्वीकार्य आउटपुट है [[1,2,3,4],[2,4,6,8],[3,6,9,12],[4,8,12,16]]।

कार्य 3:

निर्धारित करें कि क्या एक संख्या एक फाइबोनैचि संख्या है । आपको Nअपनी भाषा के डिफ़ॉल्ट पूर्णांक सीमा तक सकारात्मक समर्थन करना चाहिए । यदि 32-बिट पूर्णांक और 64-बिट पूर्णांक दोनों हैं, तो आप उस कोड का उपयोग करना चुन सकते हैं जिसके लिए सबसे छोटा कोड आवश्यक है। उदाहरण के लिए, यदि आपके पास विकल्प है, तो intइसके बजाय का उपयोग करें long int। आप 32-बिट से छोटे पूर्णांक नहीं चुन सकते हैं जब तक कि डिफ़ॉल्ट न हो (यदि आप 32-बिट डिफ़ॉल्ट है तो 8-बिट पूर्णांक का उपयोग नहीं कर सकते)।

true/false, false/true, 1/0, 1/-1, a/bसभी स्वीकार्य उत्पादन जब तक कि यह संगत के रूप में कर रहे हैं।

कार्य 4:

Nइनपुट के रूप में ले लो और परिणाम का उत्पादन 1^1+2^2+3^3+...N^N। आपको समर्थन करना चाहिए 1<=N<=10।

10 अलग-अलग परिणाम हैं:

1, 5, 32, 288, 3413, 50069, 873612, 17650828, 405071317, 10405071317

---

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम सबमिशन जीतता है!

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

function update() {
  var m = {};
  var a = [q1.value, q2.value, q3.value, q4.value];
  var o = [{}, {}, {}, {}]
  for (var i = 0; i < 4; i++) {
    for (var j = 0; j < a[i].length; j++) o[i][a[i][j]] = -~o[i][a[i][j]];
    for (var c in o[i]) if (!(o[i][c] < m[c])) m[c] = o[i][c];
  }
  var t = 0;
  for (var c in m) t += m[c];
  for (var i = 0; i < 4; i++) {
    t += "\n";
    for (var c in m) t += c.repeat(m[c] - ~~o[i][c]);
  }
  p.textContent = t;
}

<div oninput="update();">
  <textarea id="q1"></textarea>
  <textarea id="q2"></textarea>
  <textarea id="q3"></textarea>
  <textarea id="q4"></textarea>
</div>
<pre id="p"></pre>

Comments

बाइनरी: दो अक्षर

— coredump

@ कॉर्डम्प हाँ, दो अनोखे किरदार ...

— ग्रिफ़िन

Answer 1

पायथन, 88 87 बाइट्स

lambda n:[a for a in range(11*n)if any(a%b<1for b in range(2,a))][:3*n:3]#1,,,=====bd++
lambda n:[[a*b for b in range(1,n+1)]for a in range(1,n+1)]#,,::ybaaa(*i%n< =====2)d33f
f=lambda n,a=1,b=1:a<n and f(n,b,a+b)or n==a#2eerrrfo::((**iii11[[aannn+     ]]y))%33gg
f=lambda n,a=1:a<=n and a**a+f(n,a+1)#::ooeeiii]]      y))bbbgg,,rrrra((11[[nnnnf==2%33

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

Comments

विल range(11*n)हमेशा पर्याप्त कंपोजिट शामिल?

— FlipTack

@FlipTack हां, 5*nपर्याप्त है।

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

Answer 2

जेली , 19 18 17 वर्ण

कार्य 1

Ḟþe*S
×5µḊḟÆRm3ḣ³

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

टास्क २

5µḊḟÆRm3ḣ³Ḟe*S
×þ

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

टास्क 3

5µḊḟmḣþ*S
×3RÆḞ³e

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

टास्क 4

×5ḊḟÆm3ḣ³þe
Rµ*ḞS

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

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

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

कार्य 1

×5µḊḟÆRm3ḣ³  Main link. Argument: n

×5           Yield 5n.
  µ          Begin a new chain, with argument 5n.
   Ḋ         Dequeue; yield [2, ..., 5n].
     ÆR      Prime range; yield all primes in [1, ..., 5n].
    ḟ        Filter; remove the elements to the right from the ones to the left.
       m3    Pick every third element.
         ḣ³  Keep the first n results.

टास्क २

यह एक तुच्छ है: ×गुणन परमाणु है, और त्वरित þ(तालिका) ×बाईं ओर और सही तर्क में तत्वों के प्रत्येक संयोजन पर लागू होता है। यदि तर्क पूर्णांक हैं (जो वे यहां हैं), तो यह उन्हें पहले सीमा तक भी डाल देता है।

टास्क 3

×3RÆḞ³e  Main link. Argument: n

×3       Yield 3n.
  R      Range; yield [1, ..., 3n].
   ÆḞ    Fibonacci; yield [F(1), ... F(3n)].
     ³e  Test if n exists in the result.

टास्क 4

Rµ*ḞS  Main link. Argument: n

R      Range; yield [1, ..., n].
 µ     Begin a new chain with argument [1, ..., n].
   Ḟ   Floor; yield [1, ..., n].
  *    Yield [1**1, ..., n**n].
    S  Take the sum.

Comments

देखने के लिए खुशी ÆḞपहले से ही उपयोगी साबित हो रही है!

— लिन

Answer 3

गणितज्ञ, 60 वर्ण

कार्य 1: समग्र

#/AFF^abcinoruy{};Select[Range[2,9#],!PrimeQ@#&][[;;3#;;3]]&

कार्य 2: गुणन सारणी

!29;F@FPQRS[];a^b;c[c[e]];eeegiilmnnotu;Array[3##&,{#,#}]/3&

कार्य 3: फाइबोनैचि

##&;239;A/PS[]^e[];lmrtuy;{,};!FreeQ[Fibonacci@Range[3#],#]&

कार्य 4: शक्तियों का योग

!###&;23/39;A@F;F[P[Q[]]];Raabccegiilnnorrty;Sum[e^e,{e,#}]&

प्रत्येक प्रस्तुत अभिव्यक्ति का एक समूह है जिसे अनदेखा किया जाता है, इसके बाद एक अनाम फ़ंक्शन होता है जो दिए गए कार्य को कार्यान्वित करता है।

मैंने एक सरल सीजेएम स्क्रिप्ट लिखी थी जो "आशावादी" एक टिप्पणी को प्रस्तुत करके कच्चे समाधान को जोड़ती है। फिर मैंने प्रत्येक टिप्पणी से मैन्युअल रूप से छुटकारा पाने के लिए (जिसके लिए प्रत्येक मामले में वैध वाक्यविन्यास प्राप्त करने के लिए कुछ पुन: व्यवस्थित करने की आवश्यकता होती है) के ऊपर तीन बाइट्स की बचत को समाप्त कर दिया। स्क्रिप्ट ने समाधानों के सरल रूपांतरों को देखने के लिए यह देखना बहुत आसान बना दिया कि क्या वे समग्र स्कोर को नीचे लाएंगे। स्वयं स्क्रिप्ट का उपयोग करने के लिए स्वतंत्र महसूस करें।

Comments

मेरे पास एक टिप्पणी है, लेकिन यह आपके कोड के बारे में नहीं है: पी। (अच्छा जवाब, btw)। आपकी सीजेएम स्क्रिप्ट एक साधारण दोष को नजरअंदाज करती है: यदि मैं प्रवेश करता हूं abऔर baस्क्रिप्ट के रूप में, यह मुझे (**)abऔर (**)ba, के बजाय abऔर देगा ba।

— हाइपरनेत्रिनो

@AlexL। हां, यह इस तथ्य पर भी विचार नहीं करता है कि (**)यदि वे किसी अन्य प्रोग्राम में उपयोग किए गए थे, तो उन्हें कुछ वर्णों को कवर करने के लिए उपयोग किया जा सकता है।

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

Answer 4

MATL , 29 28 26 वर्ण

टास्क 1 (हर तीसरा कंपोजिट नंबर)

6*:tZp~)G:3*q)%G"$]vwm^sl+

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

टास्क 2 (गुणा तालिका)

:l$*%6*tZp~)G:3q)G"]vwm^s+

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

टास्क 3 (फाइबोनैचि डिटेक्टर)

l6Zp~G:"3q$t+]vGwm%):*)^s*

यह प्रदर्शित करता है 1/ 0फाइबोनैचि / गैर फाइबोनैचि के लिए क्रमशः।

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

टास्क 4 (शक्तियों का योग)

:t^s%6*Zp~)G:3*q)G"$]vwml+

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

चेक

यह कार्यक्रम चार तारों को इनपुट करता है और उन्हें छांटता है, नेत्रहीन यह जांचने के लिए कि वे एक ही वर्ण का उपयोग करते हैं।

स्पष्टीकरण

%टिप्पणी प्रतीक है। इसके अधिकार की हर बात को नजरअंदाज किया जाता है।

टास्क 1 (हर तीसरा कंपोजिट नंबर)

6*    % Input N. Multiply by 6
:     % Range [1 2 ... 6*N]. This is enough because every even number is composite,
      % so this contains at least 3*N composite numbers
t     % Duplicate
Zp    % Isprime
~     % Negate
)     % Use as index to select composite numbers, including 1, from [1 2 ... 6*N]
G:    % Push [1 2 ... N]
3*q   % Multiply by 3 and subtract 1: gives [2 5 ... 3*N-1]
)     % Pick those composite numbers. Implicitly display

टास्क 2 (गुणा तालिका)

:     % Input N. Range [1 2 ... N]
l     % Push 1
$     % Specify that next function will take 1 input
*     % Product of array. With 1 input it produces all pair-wise products
      % Implicitly display

टास्क 3 (फाइबोनैचि डिटेक्टर)

l     % Push 1
6     % Push 6
Zp    % Isprime. Gives false
~     % Negate. Gives true, or 1
G:    % Push [1 2 ... N], where N is the input
"     % For each
  3q  %   3, subtract 1
  $   %   Specify that next function will take 2 inputs
  t   %   Duplicate the top two elements of the stack
  +   %   Add
]     % End
v     % Vertically concatenate the entire stack. This produces a column vector
      % with a sufficient amount of Fibonacci numbers
G     % Push input N
w     % Swap
m     % Ismember. Gives true if input is in the vector of Fibonacci numbers
      % Implicitly display

टास्क 4 (शक्तियों का योग)

:     % Implicitly input N. Push [1 2 ... N]
t     % Duplicate
^     % Power, element-wise
s     % Sum of array. Implicitly display

Comments

जब मैंने पहली बार चुनौती को देखा, तो मुझे लगा कि Hey MATL would be perfect for this!आप मुझे हरा देंगे। +1

— DJMcMayhem

@DJMcMayhem क्षमा करें, मैं बहुत उत्तर देता हूं। अगली बार मुझे पिंग करें और मैं मना करूँगी अगर आप इस पर काम कर रहे हैं :-) वैसे भी, आगे क्यों नहीं? शायद आप इसे आउट कर सकते हैं

— लुइस

@DJMcMayhem, कृपया एक उत्तर भी पोस्ट करें, भले ही आप लुइस को पछाड़ न दें। मैं चाहता हूं कि पहले से उपयोग की जाने वाली भाषाओं में अधिक लोग उत्तर पोस्ट करें, भले ही वे पहले वाले को आउटगोल्फ का प्रबंधन न करें।

— स्टीवी ग्रिफ़िन 21

@stewiegriffin Haha, ठीक है पक्का। मेरे पास अभी तक एक वैध जवाब नहीं है, लेकिन अगर मुझे एक मिलता है (और यह पर्याप्त रूप से अलग है) तो मैं इसे पोस्ट करूंगा।

— DJMcMayhem

Answer 5

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

{(4..*).grep(!*.is-prime)[0,3...^*>=$_*3]}#$$&+1==>X[]__oot{}

{[X*](1..$_,!0..$_).rotor($_)}#&***+-..334===>>[]^eegiimpps{}

{(1,&[+]...*>=$_)[*-!0]==$_}#$()**....334>X^_eegiimoopprrst{}

{[+]((1..$_)>>.&{$_**$_})}#!**,-....0334===X[]^eegiimoopprrst

---

दूसरा ((1,2,3,4),(2,4,6,8),(3,6,9,12),(4,8,12,16))जब दिया जाता है तो वापस लौटता है4

पर्ल 6 में वास्तव में अधिकतम पूर्णांक नहीं है, लेकिन तीसरा एक इनपुट के साथ तुरंत काम करता है 15156039800290547036315704478931467953361427680642। केवल सीमित कारक स्मृति और समय होगा।

अन्यथा वे सभी आवश्यक रूप से अच्छी तरह से परे आदानों के लिए "तुरन्त" चलाएंगे।

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

Answer 6

जावास्क्रिप्ट (ईएस 6), 101 100 95 93 91 बाइट्स

(n,r=[],a=(y,m)=>n?y%m?a(y,++m):a(y+1,2,y==m||n--%3||r.push(y)):r)=>a(4,2,n*=3)//>....p*A&&
n=>[...Array(n)].map((r,y,m)=>m.map((s,n)=>y*++n,y+=1))//22334(,,,,===ayy)??%%::||||--uh*&&
r=(n,y=1,a=2)=>n==y||n>y&&r(n,a,y+a)//2334((((,,,,r=[]ayymmmm))))>??%%++::||--.....ppush**A
r=y=>y&&y**y+r(y-1)//22334(((((nnnn,,,,,,,,r=====[]aaaaymmmm)))))>>??%%++::||||-.....ppushA

संपादित करें: 0फाइबोनैचि संख्या के रूप में समर्थन नहीं करके 1 बाइट सहेजा गया । सहेजे गए 5 बाइट्स और साथ ही 2 और बाइट्स (1 धन्यवाद @Arnauld के लिए) वेरिएबल का नाम बदलकर। के बीच स्विच करके 2 बाइट्स सहेजे गए +1, ++और +=1।

Comments

cचर की सभी घटनाओं को बदलने के साथ Aएक बाइट बचाना चाहिए।

— अरनौलद

(मैं के बारे में सुझाव देने के लिए है कि आप भी जगह ले सकता था dके साथ yहै, लेकिन dवर्तमान संस्करण में अपरिभाषित है, तो आप शायद कि पहले ठीक करने के लिए चाहते हैं)

— Arnauld

@Arnauld कि बाहर इशारा करने के लिए धन्यवाद, लेकिन मैं चीजों को ठीक करने और नाम बदलने aसे एक और बाइट बचाने में कामयाब रहा m।

— नील

Answer 7

MATL , 30 अक्षर

मेरे साथ गया किरदार सेट है:

!%))*+001233::<=GGQZ\]^`pstvyy~

मैं दूसरे MATL जवाब को पछाड़ नहीं सकता था, लेकिन मुझे इस समाधान के साथ आने में मज़ा आया।

कार्य 1:

तीसरा समग्र संख्या।

4t^:QtZp~)G3*:3\1=)%!`yy+<]vGs

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

कार्य 2:

पहाड़ा। MATL काम करने के तरीके के कारण निश्चित रूप से सबसे आसान काम है

:t!*%4QZp~)G3:3\1=)`yy+<]vGs^t

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

कार्य 3:

फाइबोनैचि परीक्षक। सत्य इनपुट्स के लिए एक पॉजिटिव पूर्णांक (1 या 2) और फाल्सी इनपुट के लिए 0 प्रिंट करता है।

1t`yy+tG<]vG=s%4:QZp~)3*:3\)!^

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

कार्य 4:

शक्तियों का योग

:t^s%1`yy+tG<]vG=4QZp~)3*:3\)!

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

मैं बाद में और अधिक गहन स्पष्टीकरण पोस्ट करूंगा, लेकिन अभी के लिए, आपको ध्यान देना चाहिए कि %टिप्पणी चरित्र है, इसलिए कार्यक्रम वास्तव में हैं:

4t^:QtZp~)G3*:3\1=)
:t!*
1t`yy+tG<]vG=s
:t^s

Answer 8

पॉवरशेल , 95 94 बाइट्स

( टिम्मी सविन 'मेरा बेकन फिर भी)

कार्य 1:

(""..999|?{'1'*$_-match'^(?=(..+)\1+$)..'})[(0..("$args"-1)|%{$_*3})]#|$$$$===ss%``iiex!!nnnq;

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

---

कार्य 2:

($s=1.."$args")|%{"`$s|%{$_*`$_}"|iex}#0113999((((......??''''*$$$--match^===++))))\[]i!!nnnq;

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

---

कार्य 3:

!!(($i="$args")..($s=1)|?{($n=($s+=$n)-$n)-eq$i})#0113999......||?{''''**__match^+\}[""%%]``x;

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

---

कार्य 4:

"$args"..1|%{$s+="$_*"*$_+1|iex};$s#013999(((((......|??{''''$$$--match^===)))))\}[%]``i!!nnnq

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

Comments

ओह, "$args"इसके बजाय वह कठोर $args[0]है। मैं यहाँ से उसका उपयोग करने जा रहा हूँ।

— AdmBorkBork

@TimmyD हाँ, मैं एक ही पैरामीटर के साथ किसी भी चीज़ पर सिंगल बाइट बचत के लिए उपयोग कर रहा हूं।

— रिश्वतवादी

@TimmyD अच्छा बिंदु! मुझे उन सभी को फिर से लिखना होगा, हालांकि मुझे यकीन है कि मैं इसे फिर से लागू कर सकता हूं और इसे लागू कर सकता हूं। एक बार जब मैंने अनुकूलन के संदर्भ में सभी 4 प्रकार की पेटिंग समाप्त कर दी।

— briantist

खैर मेरा मतलब था कि मैं TIO लिंक को फिर से कर रहा हूं और इस तरह FINE @TimmyD मैं आलसी होना बंद कर दूंगा और आपके उदार सुझाव का उपयोग करूंगा जो उतना काम नहीं है जितना मैं इसे करने के लिए कर रहा हूं! (संपादित) :

— देशभक्त

आप एक और समग्र बाइट को बचाने के ;लिए गणना में हेरफेर करके टास्क 4 से समाप्त कर सकते हैं ("$args"..1|%{$s+="$_*"*$_+1|iex})-(-$s)।

— AdmBorkBork

Answer 9

हास्केल , 77 76 वर्ण

m n=[[x|x<-[1..],2/=sum[1|0<-mod x<$>[1..x]]]!!y|y<-[1,4..3*n]]--2 n===y();^
s n=[(*y)<$>[1..n]|y<-[1..n]]--0112234mmm  ====[[[xxxx||<<--..]]],,/uod!!y;^
n x|x<2=1|1<3=sum(n<$>[x-1,x-2]);d y=[0|m<-[1..y],y==n m]--4[[[....]]]/o!!*^
o n=sum[x^x|x<-[1..n]]--01112234mm  n====[[[[x||<<<--....]]]],,/d$>!!yyy*();

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

--एक लाइन टिप्पणी शुरू करता है, इसलिए सभी चार कार्यक्रम फॉर्म के हैं <program>--<unused chars>।

कार्य 1:

m n=[[x|x<-[1..],2/=sum[1|0<-mod x<$>[1..x]]]!!y|y<-[1,4..3*n]]

सबसे लंबा कार्यक्रम। [x|x<-[1..],2/=sum[1|0<-mod x<$>[1..x]]]संयुक्त संख्याओं की एक अनंत सूची के साथ-साथ एक शुरुआत भी देता है 1जो 0-इंडेक्सिंग को सही करता है। उपयोग:

Prelude> m 5
[4,9,14,18,22]

कार्य 2:

s n=[(*y)<$>[1..n]|y<-[1..n]]

उपयोग:

Prelude> s 5
[[1,2,3,4,5],[2,4,6,8,10],[3,6,9,12,15],[4,8,12,16,20],[5,10,15,20,25]]

कार्य 3:

n x|x<2=1|1<3=sum(n<$>[x-1,x-2]);d y=[0|m<-[1..y],y==n m]

[0]सच्चाई के लिए और झूठा के लिए रिटर्न []। उपयोग:

Prelude> d 5
[0]
Prelude> d 6
[]

कार्य 4:

o n=sum[x^x|x<-[1..n]]

उपयोग:

Prelude> o 5
3413

Answer 10

05AB1E , 21 बाइट्स

कार्य 1

3ÅFOL¦DâPÙï{3ôø¬¹£qåm

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

टास्क २

LDâP¹ôq3m¦Ùï{3ø¬£ÅFåO

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

टास्क 3

3mÅF¹åqL¦DâPÙï{3ôø¬£O

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

टास्क 4

LDmOq3¦âPÙï{3ôø¬¹£ÅFå

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

स्पष्टीकरण

सभी कार्यों के लिए, qप्रोग्राम को समाप्त करता है ताकि बाद में आने वाला कोड कभी निष्पादित न हो।

कार्य 1

यह सबसे बड़ा बाइट-हॉग है। यहां एक छोटा सा सुधार एक लंबा रास्ता तय कर सकता है।

3ÅFO                 # sum the first 4 fibonacci numbers
    L¦               # range [2 ... above]
      Dâ             # cartesian product with itself
        P            # product
         Ù           # remove duplicates
          ï{         # sort
            3ô       # split in pieces of size 3
              ø      # transpose
               ¬     # get the first lits
                ¹£   # get the first input-nr elements of the list

टास्क २

L       # range [1 ... input]
 D      # duplicate
  â     # cartesian product
   P    # product
    ¹ô  # split in pieces of input size

टास्क 3

3m      # input**3
  ÅF    # get a list of that many (+1) fibonacci numbers
    ¹å  # check if input is in that list

टास्क 4

L     # range [1 ... input]
 D    # duplicate
  m   # elementwise power of ranges
   O  # sum

Answer 11

रूबी, 83 82 80 78 वर्ण

->m{'*+-=';[*0..m-1].map{|b|(4..516).select{|p|(2...p).any?{|n|p%n==0}}[3*b]}}
->n{'()%**+--......00123456==?[[]]clmnsty{||}';(b=1..n).map{|e|b.map{|p|e*p}}}
->m{'%+-......001236bclnnpt[[]]{{||||}}';(1..e=m*m).any?{|p|(p*p-5*e).abs==4}}
->n{'%*.......023456=?[]abbceelnsty{{||||}}';((m=0)..n).map{|p|m+=p**p}[-1]-1}

ध्यान दें: विकिपीडिया पर वर्णित पूर्ण वर्ग विधि का उपयोग करते हुए फाइबोनैचि संख्या डिटेक्टर: https://en.wikipedia.org/wiki/Fibnote_number#Recognizing_Fibnote_numbers

Comments

यदि आपके पास जलने के पात्र हैं, तो एक स्ट्रिंग के बजाय अंत में एक टिप्पणी का उपयोग क्यों न करें? यह आपको प्रति पंक्ति 2 अक्षर '';बनाम बचाता है#

— एलेक्सिस एंडरसन

धन्यवाद, लेकिन मेरे लिए यह धोखा देने जैसा लगता है।

— जीबी