41

सभी वर्षों में से मैं यह चुनौती दे रहा हूं, 2017 पहला वर्ष है जो एक प्रमुख संख्या है। तो सवाल अभाज्य संख्याओं और उनकी संपत्तियों के बारे में होगा।

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

कुछ उदाहरण इनपुट और उनके आउटपुट:

1 (has no prime factors)
true

2 (= 2)
true

80 (= 2 x 2 x 2 x 2 x 5)
true

2017 (= 2017)
true

2019 (= 3 x 673)
true

2027 (= 2027)
false

11111 (= 41 x 271)
true

45183 (= 3 x 15061)
false

102349 (= 13 x 7873)
false

999999 (= 3 x 3 x 3 x 7 x 11 x 13 x 37)
true

1234567 (= 127 x 9721)
false

4068289 (= 2017 x 2017)
true

आपके कार्यक्रम का शाब्दिक आउटपुट नहीं है - trueऔर falseकोई भी सत्य या मिथ्या मूल्य, और वास्तव में कोई भी दो अलग-अलग आउटपुट जो कि सच्चे और झूठे मामलों में सुसंगत हैं, ठीक हैं।

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

वर्ण, या वर्णों के अनुक्रम, जो अभाज्य संख्याओं का प्रतिनिधित्व करते हैं।
- वर्ण 2, 3, 5, और 7भाषाओं जहां संख्या मान्य टोकन हैं में अवैध हैं।
- संख्या 141अवैध है क्योंकि इसमें शामिल हैं 41, भले ही 1और 4अन्यथा मान्य हैं।
- वर्ण Bऔर D(या bऔर d) इस तरह के CJam या Befunge जैसी भाषाओं जहां वे आम तौर पर 11 और 13 के रूप में उपयोग किया जाता है, में अवैध हैं।
जिन वर्णों में प्राइम-वैल्यू यूनिकोड मान है, या उनके एन्कोडिंग में प्राइम-वैल्यू बाइट्स हैं।
- %)+/5;=CGIOSYaegkmqASCII में वर्ण अवैध हैं, साथ ही गाड़ी वापसी चरित्र भी।
- óUTF-8 में यह चरित्र अवैध है क्योंकि इसमें एन्कोडिंग है 0xb3। हालाँकि, ISO-8859-1 में, इसकी एन्कोडिंग बस है 0xf3, जो कि समग्र है और इसलिए ठीक है।

किसी भी भाषा में उपरोक्त करने के लिए सबसे छोटा कोड जीतता है।

— जो जेड।
स्रोत

साइड नोट: "फ्राईबल" इस संदर्भ में पुरानी और अवांछनीय "चिकनी" पर अपनाया जाने वाला एक सुधार है।

— ग्रेग मार्टिन

1

क्या सत्य और मिथ्या मूल्यों को लगातार होना चाहिए? या क्या वे तब तक भिन्न हो सकते हैं जब तक कि वे सत्य या मिथ्या हैं?

— लुइस मेंडो

10

=अधिकांश मानक भाषाओं में नियमों की कमी ...

— नील

4

-1 एक्स फॉर ए वाई चैलेंज के बिना। यह वास्तव में काफी तुच्छ है जो चरित्र प्रतिबंधों के एक अनावश्यक अनावश्यक सेट के पीछे छिपा हुआ है

— डाउगोएट

1

मैं उनके बारे में मनमाने ढंग से बड़े होने के बारे में पसंद नहीं करता। यह बेहतर होगा यदि वे 2 ^ 31-1 तक गए।

— बिजन

37

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

44‘²!*ḍ@

इसे ऑनलाइन आज़माएं! ध्यान दें कि परीक्षण के मामले 11111 और इसके बाद के संस्करण TIO के लिए बहुत अधिक हैं।

सत्यापन

$ source="34,34,fc,82,21,2a,d5,40"
$ xxd -ps -r > 2017.jelly <<< $source
$ xxd -g 1 2017.jelly
0000000: 34 34 fc 82 21 2a d5 40                          44..!*.@
$ eval printf '"%d "' 0x{$source}; echo # Code points in decimal
52 52 252 130 33 42 213 64
$ test_cases="1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289"
$ for n in $test_cases; do printf "%11d: %d\n" $n $(jelly f 2017.jelly $n); done
      1: 1
      2: 1
     80: 1
   2017: 1
   2019: 1
   2027: 0
  11111: 1
  45183: 0
 102349: 0

टेस्ट केस 999999 13 घंटे से चल रहा है। मैं 2025 कंप्यूटिंग के बारे में निराशावादी हूँ ! ^4068289 ...

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

44‘²!*ḍ@  Main link. Argument: n

44        Yield 44.
  ‘       Increment to yield 45.
   ²      Square to yield 2025.
          Note that no integers in [2018, ..., 2025] are prime numbers.
    !     Take the factorial of 2025.
     *    Raise it to the n-th power.
          This repeats all prime factors in 2025! at least n times, so the result
          will be divisible by n if (and only if) all of its prime factors fall
          in the range [1, ..., 2025].
      ḍ@  Test the result for divisibility by n.

— डेनिस
स्रोत

22

आप संख्याओं के प्रति क्रूर हैं। :)

— ग्रेग मार्टिन

3

@GregMartin बाह। मैंने एक उत्तर (एक अलग भाषा में) देखा है जहां आकार 6 का एक इनपुट कई घंटों के लिए मेमोरी को हॉग करेगा, फिर क्रैश। मैं अभी कहूंगा (2^n)!:। यह छह-आकार के इनपुट के लिए भी तरसता है, लेकिन कम से कम इनपुट एक द्विआधारी के बजाय एक दशमलव वर्णमाला में हैं।

— जॉन ड्वोरक

क्या यह 13 बाइट्स नहीं है? डेनिस आपकी इतनी प्रतिष्ठा है कि मुझे यकीन है कि मैं यहां एक गलती कर रहा हूं Al

— अल्बर्ट

7

@AlbertRenshaw यह वास्तव में UTF-8 में 13 बाइट्स होगा, लेकिन जेली एक कस्टम कोड पेज का उपयोग करता है जो सभी वर्णों को एक ही बाइट के रूप में समझता है।

— डेनिस

3

@ डेनिस को पता था कि एक स्पष्टीकरण होगा; के बारे में जानने के लिए बहुत अच्छा है, धन्यवाद!

— अल्बर्ट रेनशॉ

11

जेली , 8 वर्ण, UTF-8 के 14 बाइट्स

Æf½ṀḤ<90

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

जेली सामान्य रूप से कार्यक्रमों के लिए अपने स्वयं के कोडपेज का उपयोग करती है। हालांकि, इसके अधिकांश प्रधान-संबंधित बिलों के साथ शुरू होता है Æ, जो कोडपॉइंट 13 है; बहुत मददगार नहीं। सौभाग्य से, दुभाषिया UTF-8 का भी समर्थन करता है, जिसमें एक मैत्रीपूर्ण एन्कोडिंग है।

सत्यापन

यह कार्यक्रम, UTF-8 में, हेक्सडंप इस प्रकार है:

00000000: c386 66c2 bde1 b980 e1b8 a43c 3930  ..f........<90

सत्यापन कि सभी बाइट्स समग्र हैं:

$ for x in c3 86 66 c2 bd e1 b9 80 e1 b8 a4 3c 39 30; do factor $((0x$x)); done
195: 3 5 13
134: 2 67
102: 2 3 17
194: 2 97
189: 3 3 3 7
225: 3 3 5 5
185: 5 37
128: 2 2 2 2 2 2 2
225: 3 3 5 5
184: 2 2 2 23
164: 2 2 41
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

सत्यापन कि सभी यूनिकोड कोडपॉइंट समग्र हैं:

$ perl -Mutf8 -E '$a = ord, print `factor $a` for split //, "Æf½ṀḤ<90"'
198: 2 3 3 11
102: 2 3 17
189: 3 3 3 7
7744: 2 2 2 2 2 2 11 11
7716: 2 2 3 643
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

एक नंबर के रूप में एकमात्र टोकन जारी किया गया है 90। में से कोई भी 9, 0और 90प्रधानमंत्री हैं।

व्याख्या

यहां मुख्य गणितीय अंतर्दृष्टि यह है कि 45² 2025 है, जो बड़े करीने से 2017 (वर्तमान वर्ष) और 2027 (अगले प्रमुख) के बीच आता है। इस प्रकार, हम संख्या के प्रत्येक प्रमुख कारक का वर्गमूल ले सकते हैं, और देख सकते हैं कि क्या कोई 45 से अधिक है। दुर्भाग्य से, हम 45शाब्दिक के कारण नहीं लिख सकते हैं 5, इसलिए हमें इसे दोगुना करना होगा और इसके बजाय 90 की तुलना में करना होगा।

Æf½ṀḤ<90
Æf        In the list of prime factors,
  ½       taking the square root of each element
   Ṁ      then taking the largest element
    Ḥ     and doubling it
     <90  produces a result less than 90.

2

UTF-8 का उपयोग करने के लिए क्या जेली को ध्वज (1 बाइट) की आवश्यकता नहीं है?

— लुइस मेंडो

@LuisMendo: कमांड-लाइन दुभाषिया करता है, लेकिन दुभाषिया यह ऑनलाइन प्रयास करें! अलग तरीके से कॉन्फ़िगर किया गया है और इसकी आवश्यकता नहीं है। तो यह केवल दुभाषिया को चुनने का एक मामला है जो आपके कार्यक्रम को आपके इच्छित तरीके की व्याख्या करता है। (किसी भी मामले में, प्रश्न में ध्वज u, समग्र है, इसलिए यह केवल स्कोर को बदलने की बात होगी क्योंकि कुछ इसे अमान्य करता है।)

10

मैथेमेटिका, 62 58 55 बाइट्स

बचाए गए अंतिम तीन बाइट पूरी तरह से मार्टिन एंडर के कारण हैं!

#4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]&

एक सकारात्मक पूर्णांक तर्क ले रहा है और लौट रहा है Trueया False।

पुनरावर्ती एल्गोरिथ्म, #4<4सत्य आधार मामला होने के साथ (हमें केवल इसे True1 अशुद्ध पर लौटने की आवश्यकता है , लेकिन अतिरिक्त आधार मामले ठीक हैं)। अन्यथा, हम इनपुट के दूसरे-सबसे छोटे भाजक (जो कि आवश्यक है) की गणना करते हैं Divisors[#][[6-4]]; यदि यह 2024 ( 44*46) से अधिक है, तो हम इसके साथ बाहर निकलते हैं False, अन्यथा हम इस छोटे से मुख्य कारक द्वारा विभाजित इनपुट पर फ़ंक्शन को पुनरावर्ती ( #6सेट का उपयोग करके #0) कहते हैं #(जिसे हमें #^-1इनपुट के समय के रूप में व्यक्त करना है #4, क्योंकि /यह अस्वीकृत है)।

संरचनात्मक रूप से, पहली छमाही #4<4||#<44*46&&#6[#^-1#4]&छह तर्कों की एक गुमनाम समारोह है, तर्क के साथ बुलाया जा रहा है Divisors[#][[6-4]], Null, Null, #, Null, और #0; इस पात्रों पर निषेध के आसपास पाने के लिए है 2, 3और 5।

पिछला संस्करण जो की जगह चार बाइट्स बचा लिया, 8018-6000साथ 44*46, से प्रेरित ais523 की जेली जवाब (मार्टिन Ender भी एक ais523 टिप्पणी से प्रेरित लग रहा था):

#<4||Divisors[#][[6-4]]<44*46&&#0[Divisors[#][[6-4]]^-1#]&

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

— ग्रेग मार्टिन
स्रोत

आप शायद एक चर के बजाय एक लंबो पैरामीटर निर्धारित कर सकते हैं। (उस ने कहा, #2यह भी अस्वीकृत हो जाएगा, इसलिए आपको सावधान रहना होगा कि आपके

@ Ais523 के सुझाव को लागू करने से तीन बाइट्स बचते हैं: #4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]&चेतावनी का एक गुच्छा फेंकता है क्योंकि अब यह Divisors[#][[2]]सुनिश्चित करने से पहले कोशिश करता है कि इनपुट 1 (या 3) से अधिक हो, लेकिन परिणाम अभी भी सही है।

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

अरे यार, वह चालाक चालाक है।

— ग्रेग मार्टिन

7

हास्केल, 48 47 बाइट्स

\n->[snd$[product[1..44*46]^n]!!0`divMod`n]<[1]

मूल रूप से डेनिस के जेली उत्तर का अनुवाद । xnor ने एक बाइट को बचाया।

उपयोग […]!!0कोष्ठकों के रूप में क्योंकि )प्रतिबंध लगा दिया है, और snd+ divModक्योंकि mमें modऔर remप्रतिबंध लगा दिया है।

— लिन
स्रोत

DivMod के साथ अच्छी चाल! मुझे लगता है कि आप के !!0<1साथ बदल सकते हैं <[1]। लेकिन यह यह यह उपयोग करने के लिए शॉर्ट है लग रहा है divके रूप में [\p n->p^n`div`n*n>p^n-1]!!0$product[1..44*46]।

— xnor

वहाँ भी है \n->[0|p<-[product[1..44*46]^n],0<-[p,p-n..0]], जो उपयोग करता है कि आउटपुट केवल सुसंगत होने की आवश्यकता है।

— xnor

@xnor अलग-अलग उत्तर (ओं) के रूप में उन लोगों को पोस्ट करने के लिए स्वतंत्र महसूस करें, मुझे लगता है कि वे मेरे से काफी अलग हैं ^ ^

— लिन

6

Pyke, 10 8 7 9 बाइट्स

P_Z|hwMX<

यहाँ कोशिश करो!

डेनिस के 2025 उत्पन्न करने के तरीके का उपयोग करके 1 बाइट को बचाया

P         -     factors(input)
 _        -    reversed(^)
  Z|      -   ^ or 0
    h     -  ^[0] or 1
        < - ^ < V
     wM   -  ⁴45 (ord("M")-32)
       X  -  ^**2

— नीला
स्रोत

5

ब्रेकीलॉग , 9 10 बाइट्स

*$ph$r*<90

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

मूल रूप से मेरे अन्य उत्तर के रूप में एक ही एल्गोरिथ्म का उपयोग करना। $phपहला ( h) अभाज्य गुणक ( $p) पाता है ; यह सबसे बड़ा प्रमुख कारक है, क्योंकि ब्रेकीगल के प्रमुख कारक सूची सबसे बड़े से सबसे छोटे तक जाती है। फिर मैं स्क्वायर रूट ( $r), डबल ( *), और यह देखने के लिए परीक्षण करता हूं कि क्या यह 90 से कम है ( <90)।

मुझे पहले इनपुट को दोगुना करना पड़ा क्योंकि 1 का कोई मुख्य कारक नहीं है (और इस प्रकार कोई पहला कारक नहीं है)। यह 2 का एक अतिरिक्त प्रमुख कारक जोड़ता है, जो यह प्रभावित नहीं कर सकता है कि कोई संख्या 2017-भिन्न है, लेकिन 1 को संभालने पर विफलता को रोकता है।

5

दरअसल , 9 बाइट्स

τyM:44u²≥

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

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

स्पष्टीकरण:

τyM:44u²≥
τyM        largest prime factor of 2*input (doubled to deal with edge case of n = 1)
   :44u²   2025 (2027 is the next prime after 2017, so any number in [2017, 2026] can be used here - 2025 is very convenient)
        ≥  is 2025 greater than or equal to largest prime factor?

— मेगो
स्रोत

5

गणितज्ञ, ६६ 66४ बाइट्स

डेनिस को यह इंगित करने के लिए धन्यवाद कि U+F4A1निषिद्ध है।

Fold[Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]],0<1,Divisors@#]&

स्पष्टीकरण:

Divisors@#: पहले तर्क के पूर्णांक विभाजकों की सूची #।

0<1: गोल्फ के लिए True(पत्र के उपयोग से भी बचता है e)।

Divisors@d^0: फॉर्म की सूची {1, 1, ..., 1}लंबाई के बराबर लंबाई के साथ d।

Tr: एक फ्लैट सूची के लिए, Trउस सूची का योग लौटाता है। इस प्रकार Tr[Divisors@d^0]के विभाजकों की संख्या लौटाता है d।

Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]]: दो तर्कों के साथ अनाम फ़ंक्शन xऔर d। विचार यह है कि dयह एक भाजक है #और हम यह देखने के लिए परीक्षण करते हैं कि यह या तो समग्र (कम 2017) के बराबर या उससे अधिक है । 2017-सहायता इस शर्त को पूरा करने वाले सभी दिव्यांगों के लिए समान है। जैसा कि a5523 ने खोजा है, एक अभाज्य से कम या बराबर होना 2017, एक से कम अभाज्य होने के बराबर है 2025। जैसा कि ग्रेग मार्टिन ने बताया, यह परीक्षण करने के लिए पर्याप्त है कि क्या यह इससे कम है 2024=44*46। तर्क इस xबात के लिए एक संचयक के रूप में कार्य करता है कि क्या सभी दिव्यांगों ने अब तक इस संपत्ति को संतुष्ट किया है। फिर हमने शुरुआती मूल्य वाले Foldसभी विभाजकों के माध्यम से इस फ़ंक्शन को छोड़ दिया#True, क्योंकि हमारे पास न तो पहुंच है और न Mapही /@।

— ngenisis
स्रोत

1

प्रतिबंध के माध्यम से लड़ने का रास्ता!

— ग्रेग मार्टिन

2

05AB1E , 10 बाइट्स

fθ46n99-›È

1 लौटाता है अगर सच है, 0 अन्यथा।

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

व्याख्या

f          # Push the list of prime factors (ordered)
 θ         # Get the last element
  46n99-   # Push 2017 (46² - 99)
        >  # Push 1 if the last prime factor is greater than 2017, 0 otherwise
         È # Is the resulting number even ? Transforms 1 to 0 and 0 to 1.
           # Implicit display

— Kaldo
स्रोत

PPCG में आपका स्वागत है!

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

1

MATL , 15 बाइट्स

t:\~ftZp*44QU<A

0नॉन-2017-फ्राईबल के लिए या 2017-फ्राईबल के लिए आउटपुट 1।

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

यह प्रोग्राम जाँचता है कि सभी बाइट्स समग्र हैं।

व्याख्या

t       % Implicit input n. Duplicate
:       % Range [1 2 ... n]
\       % Modulo. Gives 0 for divisors of n
~f      % Indices of zero values
t       % Duplicate
Zp      % Is-prime. Gives 1 for primes, 0 for composites
*       % Multiply
44QU    % 44, add 1, square: 2025
<       % Less than, element-wise
A       % True (1) if all entries are nonzero

— लुइस मेंडो
स्रोत

1

बैश, 144 बाइट्स

ASCII एन्कोडिंग:

{
printf '[ '
`tr D-Z _-z <<<KFH`tor $1|tr -d :|`tr B-Z _-z <<<JUH`p -o '[0-9]*$'
printf ' -lt $[24*86-46] ]'
}|tr \\n \ |`tr B-Z _-z <<<EDVK`

शेल के लिए हमेशा की तरह, निकास कोड सफलता (0) या विफलता (गैर-0) को इंगित करता है।

यह प्रभावी रूप से एक अलग वर्तनी है

[ factor $1|tr -d :|grep -o '[0-9]*$' -lt 2018 ]

हमें सबसे बड़ा कारक मिलता है factor $1|grep -o '[0-9]*$'; tr -d :इनपुट = के लिए विशेष-केस करने के लिए है 1।

अभिव्यक्ति $[6*6*69-466]2018 का मूल्यांकन करती है।

यह trकमांड नामों के लिए उपयोग करने के लिए मुश्किल था और अभी भी कमांड प्रतिस्थापन का उपयोग करता है - मैं नेस्टिंग फॉर्म का उपयोग नहीं कर सकता था $( ), इसलिए मैंने परिणाम का मूल्यांकन करने के लिए दूसरे बैश में पाइपिंग को समाप्त कर दिया।

परीक्षण के परिणाम:

$ for i in 1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289; do printf '%d %s\n' $i `./105241.sh $i  && echo true || echo false`; done
1 true
2 true
80 true
2017 true
2019 true
2027 false
11111 true
45183 false
102349 false
999999 true
1234567 false
4068289 true

चरित्र कोड की पुष्टि:

$ grep -v '^#' ./105241.sh | perl -n -Mutf8 -E '$a = ord, print `factor $a` for split //, $_' | grep -v ': .* ' | wc -l
0

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

0

अजगर, 11 बाइट्स

!s>R^h44h1P

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

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

— PurkkaKoodari
स्रोत

0

जूलिया 0.4 , 84 38 37 बाइट्स

n->1^n:44*46|>prod|>t->t^n-t^n÷n*n<1

एक BigInt तर्क के रूप में की अपेक्षा करता है।

इसे ऑनलाइन आज़माएं! या सत्यापित करें कि कोई बाइट प्रधान नहीं है ।

— डेनिस
स्रोत

0

जाप , 14 बाइट्स

k æ¨44*46 ?0:1

1 लौटाता है अगर सच है, तो 0 झूठे।

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

— ओलिवर
स्रोत

kएक प्रमुख मूल्य है

— अज्ञानता का अवतार

0

ब्रिंगोल्फ , 11 बाइट्स [बहुत ही गैर-प्रतिस्पर्धात्मक]

VRp#ߢ-?0:1

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

ߢसंख्याओं के साथ जो शिकंजा है, उसके कारण अपठनीय , हालांकि अभी भी दुभाषिया में काम करता है।

जब मैंने यह लिखा था तो मैंने चरित्र प्रतिबंधों पर ध्यान नहीं दिया था, लेकिन मुझे केवल 2017 से 2018 तक अजीब यूनिकोड चरित्र को बदलना था।

2018 एक प्रमुख नहीं है, कोई भी प्रधान <= 2018है<= 2017

व्याख्या

VRp#ߢ-?0:1  Implicit input from command-line args
VR            Create stack2, return to stack1
  p           Split last item into prime factors, push each one to stack in asc order
   #ߢ         Push 2018
     -      Subtract last 2 items (highest prime factor - 2017)
      ?     If last item > 0..
       0    ..push 1
        :   Else..
         1  ..Push 1
            Implicit output of last item on stack

— Skidsdev
स्रोत

निर्धारित करें कि क्या कोई संख्या आपके स्रोत कोड में primes के बिना 2017-भिन्न है

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

सत्यापन

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

जेली , 8 वर्ण, UTF-8 के 14 बाइट्स

सत्यापन

व्याख्या

मैथेमेटिका, 62 58 55 बाइट्स

हास्केल, 48 47 बाइट्स

Pyke, 10 8 7 9 बाइट्स

ब्रेकीलॉग , 9 10 बाइट्स

दरअसल , 9 बाइट्स

गणितज्ञ, ६६ 66४ बाइट्स

05AB1E , 10 बाइट्स

MATL , 15 बाइट्स

व्याख्या

बैश, 144 बाइट्स

अजगर, 11 बाइट्स

जूलिया 0.4 , 84 38 37 बाइट्स

जाप , 14 बाइट्स

ब्रिंगोल्फ , 11 बाइट्स [बहुत ही गैर-प्रतिस्पर्धात्मक]

व्याख्या