42

एक गैर नकारात्मक पूर्णांक इनपुट को देखते हुए एक प्रोग्राम लिखने कि धर्मान्तरित षोडश आधारी और रिटर्न एक truthy मूल्य अगर संख्या का हेक्साडेसिमल प्रपत्र केवल वर्ण हैं करने के लिए संख्या Aके माध्यम से Fऔर नहीं तो एक falsey मूल्य।

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

10
==> True (A in hexadecimal)

100
==> False (64 in hexadecimal)

161
==> False (A1 in hexadecimal)

11259375
==> True (ABCDEF in hexadecimal)

0
==> False (0 in hexadecimal)

बोनस: -40 बाइट्स यदि आपका प्रोग्राम Only lettersऊपर वर्णित चुनौती के लिए प्रिंट करता है, Only numbersयदि संख्या के हेक्साडेसिमल संस्करण में केवल अंक होते हैं 0-9और Mixयदि हेक्साडेसिमल संख्या में कम से कम एक संख्या और कम से कम एक अक्षर होता है।

यह कोड गोल्फ है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है। या तो कार्यों या पूर्ण कार्यक्रमों की अनुमति है।

— आर्कटुरस
स्रोत

2

वर्तमान में गोल्फर में एक उत्तर का प्रारूपण।

— SuperJedi224

मेरा वर्तमान विचार: आधार को 16 स्ट्रिंग तक NaN

— पहुंचाना

@Cyoce आपकी भाषा के चुनाव के आधार पर काम कर सकता है

— SuperJedi224

3

अवास्तविक बोनस (एक बार फिर): सिर्फ स्ट्रिंग MixOnlynumbersletters21 वर्ण है

— edc65

3

आप कहते हैं "सकारात्मक पूर्णांक इनपुट", लेकिन 0 एक परीक्षण मामला है।

— 22

22

पायथ, 43 - 40 = 3 बाइट्स

?&K@J.HQG-JG"Mix"%"Only %sers"?K"lett""numb

परीक्षण सूट

यह बोनस प्राप्त करता है। Only numbersऔर Only lettersसौभाग्य से केवल 4 अक्षरों से अलग है। प्रिंटफ-स्टाइल फॉर्मेटिंग का उपयोग किया जाता है %।

चयन प्रणाली दोनों को हेक्स के चौराहे के साथ ले जाने G, वर्णमाला और घटाना द्वारा किया जाता है G। यदि न तो झूठा समाप्त होता है, तो यह एक मिश्रण होता है, जबकि अगर चौराहा झूठा है, तो यह संख्या है, और यदि घटाव झूठा है, तो यह अक्षर है।

— isaacg
स्रोत

1

लानत है यह अजगर अजीब है। यदि आप एक नकारात्मक अंक प्राप्त कर सकते हैं, तो बहुत अच्छा होगा।

— केआरजेड

15

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

!-.HQG

  .HQ   # Converts the input to hexadecimal
 -   G  # Deletes all letters
!       # If empty, output True, else False

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

— अदनान
स्रोत

12

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

b16>9P

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

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

b16>9P  Input: z

b16     Convert the input to base 16.
   >9   Compare each resulting digit with 9; return 1 iff greater.
     P  Take the product of the resulting Booleans.

— डेनिस
स्रोत

वहाँ एक में निर्मित नहीं है 16 या यह एक बात नहीं है?

— कैलक्यूलेटरफैनलाइन

1

वहां है अभी। यह पहला जेली उत्तर में से एक था ...

— डेनिस

11

TeaScript , 11 बाइट्स 13 15 16

xT(16)O(Sz)

बहुत साधारण। यह TeaScript 2.0 का उपयोग करता है। आप इस संस्करण को जीथब से प्राप्त कर सकते हैं

व्याख्या

        // Implicit: x = input, Sz = alphabet
xT(16)  // input -> hex
O(Sz)   // Only letters?

इसे ऑनलाइन आज़माएं (थोड़ा संशोधित संस्करण जो वेब पर काम करता है)

— Downgoat
स्रोत

3

क्या यह डाउन-वोट है क्योंकि यह लंबा है? क्या इस जवाब में कुछ और गलत है जिसकी मुझे जानकारी नहीं है? या किसी को व्यक्तिगत रूप से यह जवाब पसंद नहीं है?

— डाउनगेट

2

मैं यह नहीं कहूंगा कि 16 या 13 बाइट्स लंबी होती हैं!

— लुइस मेंडो

23

आपको यह स्वीकार करना होगा कि आपके पोस्ट को डाउन-गोइंग करना काफी लुभावना है।

— डेनिस

10

पायथन, 24 बाइट्स

lambda n:min('%x'%n)>'9'

इनपुट को हेक्स स्ट्रिंग (बिना 0xउपसर्ग के) के साथ परिवर्तित करता है '%x'%n। अगर इसके ऊपर है, '9'तो यह देखकर कि इसके सभी वर्ण (जो अक्षर हैं) से बड़े हैं ।min'9'

— XNOR
स्रोत

मुझे नहीं पता कि पायथन पात्रों / संख्याओं को कैसे संभालता है, लेकिन एएससीआईआई का कोड '9'54 है। इसलिए यदि आप लिख सकते हैं तो आप ...>54एक बाइट बचा सकते हैं।

— 10

@CompuChip पायथन नंबर के रूप में वर्ण या तार का इलाज नहीं करता है। वास्तव में, पायथन 2 उन्हें सभी संख्याओं से अधिक मानता है।

— xnor

8

MATL , 10

i16YA1Y2mA

उदाहरण

>> matl i16YA1Y2mA
> 240
0
>> matl i16YA1Y2mA
> 255
1

व्याख्या

i       % input                         
16YA    % convert to string representation in base 16
1Y2     % predefined literal: 'A':'Z'
m       % true for set member             
A       % all

बोनस चुनौती: 53−40 = 13

i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]

उदाहरण

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 255
Only letters

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 100
Only numbers

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 > 
> 240
Mix

व्याख्या

i                       % input                                                 
16YA                    % convert integer to string representation in base 16
1Y2                     % predefined literal: 'A':'Z'
m                       % true for set member       
XK                      % copy to clipboard K                 
A                       % all                                   
?                       % if (top of the stack)                 
  'Only letters'        % string literal                                        
}                       % else                 
  K                     % paste from clipboard K      
  a                     % any                
  ?                     % if (top of the stack)      
    'Mix'               % string literal    
  }                     % else                                                  
    'Only numbers'      % string literal           
  ]                     % end             
]                       % end

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

2

हममम वह क्या है? लगता है जैसे मतलबी को अब कुछ नट शक्ति मिल गई!

— अब्राहम

@ अगरवाहा हाहा। सॉर्ट

— लुइस मेंडो

8

LabVIEW, 52-40 = 12 LabVIEW आदिम

बिल्ट-इन की प्रशंसा!

— Eumel
स्रोत

8

सी, 46 43 37 बाइट्स

अब और अधिक पुनरावृत्ति के साथ! (धन्यवाद डेनिस):

F(x){return(x%16>9)*(x<16?:F(x/16));}

बोनस: और भी कम (33 बाइट्स), लेकिन इसके लिए असफल x = 0:

F(x){return!x?:(x%16>9)*F(x/16);}

b;F(x){for(b=x;x;x/=16)b*=x%16>9;return b;}

F()एक ( intरिटर्न 0) या (शून्य) या गैर-शून्य (सच्चा) लेता है ।

मैंने बोनस प्राप्त करने की कोशिश भी नहीं की, "MixOnly lettersnumbers"अकेले 23 बाइट्स लेता है, नई स्थिति पर नज़र रखने के लिए 9 अतिरिक्त बाइट्स की आवश्यकता होती है, printf()8 बाइट्स हैं, जो 40 को जोड़ता है, प्रयास को शून्य करता है।

टेस्ट मुख्य:

#include <stdio.h>

int main() {
  int testdata[] = {10, 100, 161, 11259375, 0};
  for (int i = 0; i < 5; ++i) {
    int d = testdata[i];
    printf("%d (0x%x) -> %s\n", d, d, F(d)?"yep":"nope");
  }
}

— स्टेफानो सैनफिलिपो
स्रोत

क्या है ?:? मुझे ||इसे संकलित करने के लिए इसे बदलना पड़ा । इसके अलावा, क्या आप बाईं ओर के एस से बचने के *साथ एक बाइट को बचा सकते हैं (हालांकि आपको फिर एक स्थान जोड़ना होगा)? &()

— नील

@Neil a?:bएक जीएनयू विस्तार है जो करने के लिए मूल्यांकन करता है a, तो aएक truthy मूल्य है, अन्यथा करने के लिए b। अशक्त बिंदुओं को संभालने के लिए काम आता है send(message ?: "(no message)");। मुझे पता है कि यह पोर्टेबल नहीं है, लेकिन कोड पोर्टेबिलिटी कोड गोल्फ में एक चिंता का विषय नहीं है :)

— स्टेफानो सैनफिलिपो

@StefanoSanfilippo आप 33ऐसा करके नीचे बाइट्स प्राप्त कर सकते हैं : F(x){x=(x%16>9)*(x<16?:F(x/16));}यह ए (जीसीसी) बग का दुरुपयोग करता है जहां यदि किसी फ़ंक्शन में कोई रिटर्न चर नहीं है और मुख्य तर्क सेट किया गया था, तो यह कुछ मामलों में मुख्य-तर्क को स्वतः वापस कर देगा ( तर्क के आधार पर), और यह उन मामलों में से एक होने के लिए होता है! इसे ऑनलाइन आज़माएँ: bit.ly/2pR52UH

— Albert Renshaw

8

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

1 बाइट छीनने के लिए धन्यवाद sysreq और पायथन 3।

lambda n:hex(n)[2:].isalpha()

सरल lambdaऔर टुकड़ा करने की क्रिया।

— LeeNeverGup
स्रोत

7

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

{.base(16)!~~/\d/} # 18 bytes

उपयोग:

# give it a name
my &code = {.base(16)!~~/\d/}

for 10, 100, 161, 11259375, 0 {
  printf "%8s %6s %s\n", $_, .base(16), .&code
}

      10      A True
     100     64 False
     161     A1 False
11259375 ABCDEF True
       0      0 False

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

7

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

Tr@DigitCount[#,16,0~Range~9]<1&

स्पष्टीकरण:

                               &   A function returning whether
Tr@                                 the sum of elements of
   DigitCount[ ,  ,         ]        the numbers of
                   0~Range~9          zeros, ones, ..., nines in
                16                    the hexadecimal expansion of
              #                       the first argument
                             <1     is less than one.

— LegionMammal978
स्रोत

7

जावास्क्रिप्ट, ईएस 6, कोई रेगेक्सपी, 28 बाइट्स

F=n=>n%16>9&&(n<16||F(n>>4))

यह 27-बाइट संस्करण भी है, लेकिन यह उलटा मान लौटाता है।

F=n=>n%16<10||n>15&&F(n>>4)

— zocky
स्रोत

अच्छा! आप इसे 23 बाइट्स के लिए भी पुनर्व्यवस्थित कर सकते हैं:F=n=>!n||n%16>9&F(n>>4)

— user81655

@ user81655 - दुर्भाग्य से, यह संस्करण 0 के लिए सही है, इसलिए यह गलत है।

— zocky

ओह ठीक है, मुझे लगता है कि सबसे छोटा होगा F=n=>n%16>9&&n<16|F(n>>4)।

— user81655

@ user81655 मुझे पूरा यकीन है कि आपको शॉर्ट-सर्किट करने की आवश्यकता है ||, लेकिन मुझे लगता है कि आप उस मामले में उपयोग &करने के साथ दूर हो सकते हैं &&।

— नील

@ नील क्यों है? क्या आपने इसका परीक्षण किया?

— user81655

7

जूलिया, 18 बाइट्स

n->isalpha(hex(n))

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

इनपुट का उपयोग करके हेक्साडेसिमल स्ट्रिंग में परिवर्तित किया जाता है hex, फिर हम जांचते हैं कि क्या इसका पूरी तरह से वर्णमाला वर्णों का उपयोग है isalpha।

— एलेक्स ए।
स्रोत

6

जावास्क्रिप्ट ईएस 6, 29

कोई बोनस नहीं

n=>!/\d/.test(n.toString(16))

-40 के नए मूल्य के साथ बोनस अब निकट है ... लेकिन पर्याप्त नहीं है। बोनस अंक 70 71 - 40 => 30 31

n=>/\d/.test(n=n.toString(16))?1/n?'Only numbers':'Mix':'Only letters'

टेस्ट स्निपेट (इनपुट बॉक्स के अंदर एक नंबर टाइप करें)

#I { width:50%}

<input id=I oninput="test()"/><br>
Hex <span id=H></span><br>
Result <span id=R></span>

स्निपेट का विस्तार करें

— edc65
स्रोत

-n-1= ~n, सही है?

— कैलक्यूलेटरफेलीन

@CatsAreFluffy अगर n 'A' की तरह संख्यात्मक नहीं है (इस चुनौती में पूरा बिंदु), ~n == -1जबकि-n-1 == NaN

— edc65

4

जीएस 2 , 6 बाइट्स

V↔i/◙s

स्रोत कोड CP437 एन्कोडिंग का उपयोग करता है। इसे ऑनलाइन आज़माएं!

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

V       Evaluate the input.
 ↔      Push 16.
  i     Perform base conversion.
   /    Sort.
    ◙   Push [10].
     s  Perform greater-or-equal comparison.

— डेनिस
स्रोत

4

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

@(n)all(dec2hex(n)>64)

— alephalpha
स्रोत

4

जावा, 46 44 38 बाइट्स

i->i.toHexString(i).matches("[a-f]+");

बहुत सरल एक-लाइनर जो पूर्णांक को एक हेक्साडेसिमल स्ट्रिंग में परिवर्तित करता है और यह निर्धारित करने के लिए कि क्या सभी वर्ण हैं अक्षर का उपयोग करता है।

-2 बाइट्स @ Eng.Fouad की बदौलत।

— टीएनटी
स्रोत

"[a-f]+"2 बाइट्स बचाएगा।

— Eng.Fouad

516 के लिए विफल रहता है

— कैलक्यूलेटरफलाइन

@CatsAreFluffy नहीं यह नहीं है।

— टीएनटी

खैर अब यह निर्धारित करता है कि क्या स्ट्रिंग में एक हेक्स पत्र है, इसलिए +बाइट की बर्बादी को दूर करें।

— कैलक्यूलेटरफलाइन

@CatsAreFluffy नंबर matches सही है अगर पूरा स्ट्रिंग दिए गए regex द्वारा मिलान किया जा सकता है। [a-f]प्लस चिह्न के बिना गलत है क्योंकि यह दिए गए पूरे स्ट्रिंग से मेल नहीं खाता है, जिसमें इसमें एक से अधिक वर्ण हैं; यह और अगर केवल एक वैध चरित्र मौजूद है।

— टीएनटी

3

सीजाम ( ९ tes बाइट्स)

{GbA,&!}

ऑनलाइन डेमो

— पीटर टेलर
स्रोत

2

समान रूप से छोटा:{Gb$N<!}

— डेनिस

3

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

->n{!('%x'%n)[/\d/]}

Ungolfed:

-> n {
  !('%x'%n)[/\d/]
}

उपयोग:

f=->n{!('%x'%n)[/\d/]} # Assigning it to a variable
f[0]
=> false
f[10]
=> true
f[100]
=> false
f[161]
=> false
f[11259375]
=> true

बोनस के साथ, 70 - 40 = 30 बाइट्स

->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}

उपयोग:

f=->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}
f[10]
=> Only letters
f[100]
=> Only numbers
f[161]
=> Mix

— वासु अडारी
स्रोत

देर से, लेकिन '%x'%n!~/\d/समाधान एक के लिए एक छोटी जांच है, और समाधान दो में 70 की कच्ची बाइट गिनती है, 75 नहीं है।

— मूल्य इंक

3

पर्ल, 69 - 40 = 29 बाइट्स

$_=sprintf"%X",<>;print s/\d//?$_?"Mix":"Only numbers":"Only letters"

— ChicagoRedSox
स्रोत

2

सीलोन, 55 बाइट्स

Boolean l(Integer n)=>!any(formatInteger(n,16)*.digit);

सीधा ... हम nएक हेक्साडेसिमल संख्या (जो एक स्ट्रिंग पैदा करता है) के रूप में प्रारूपित करते हैं, उस स्ट्रिंग के प्रत्येक चरित्र पर कॉल करें .digit(जो कि अगर यह एक अंक है तो यह सच है), तो जांचें कि क्या उनमें से कोई भी सत्य है, तो इसे नकारें।

बोनस वाले संस्करण में 119 - 25 = 94 का उच्च स्कोर है :

String c(Integer n)=>let(s=formatInteger(n),d=s*.digit)(every(d)then"Only numbers"else(any(d)then"Mix"else"Only letters"));

_{मुझे यकीन नहीं है कि कैसे कोई भी बोनस संस्करण को बिना बोनस संस्करण से बेहतर बनाने के लिए पर्याप्त कर सकता है, यहां तक कि अकेले उन तारों की लंबाई एक साथ 28 है। हो सकता है कि एक ऐसी भाषा जो सत्य / असत्य मूल्य उत्पन्न करने के लिए वास्तव में कठिन बना दे।}

यहाँ एक स्वरूपित संस्करण है:

String c(Integer n) =>
        let (d = formatInteger(n,16)*.digit)
    (every(d) then "Only numbers"
                else (any(d) then "Mix"
                    else "Only letters"));

— पाओलो एबरमन
स्रोत

2

जंग, 70 बाइट्स

fn f(n:i32)->bool{format!("{:x}",n).chars().all(|c|c.is_alphabetic())}

क्योंकि, फिर पता है, ~~जावा~~ जंग।

यह वास्तव में बहुत सुंदर है, हालांकि:

format!("{:x}", n)         // format n as hex (:x)
  .chars()                 // get an Iter over the characters
  .all(                    // do all Iter elements satisfy the closure?
    |c| c.is_alphabetic()  // self-explanatory
  )

लेकिन यह शर्म की बात है कि फंक्शन की परिभाषा बॉयलरप्लेट इतनी लंबी है ...: पी

— Doorknob
स्रोत

मेरे पास विचार है। अधिक बंद!

— कैलक्यूलेटरफेलीन

2

CJam, 44 बाइट्स - 40 बोनस = 4 बाइट्स

2,riGbAf/&:-"Only numbersOnly lettersMix"C/=

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

— लिन
स्रोत

2

गंभीरता से, 12 बाइट्स

4ª,¡OkúOkd-Y

हेक्स डंप:

34a62cad4f6b
a34f6b642d59

यह ऑनलाइन की कोशिश करो

यह अन्य स्टैक भाषा के उत्तर के समान है। यह केवल 7 बाइट्स होगा अगर गंभीर रूप से समर्थित स्ट्रिंग घटाव अभी तक।

संपादित करें: गंभीरता से अब स्ट्रिंग घटाव का समर्थन करता है और निम्नलिखित 7 बाइट समाधान अब काम करता है:

ú4╙,¡-Y

हेक्स डंप:

a334d32cad2d59

यह ऑनलाइन की कोशिश करो

— quintopia
स्रोत

1

11: 4╙,¡#S;ú∩S=(या 4ªया 8τ, बहुत से तरीके हैं वर्तनी :16:दो बाइट्स में: पी)

— Mego

मैं एसआई को नहीं जानता था।

— क्विंटोपिया

2

05AB1E , 2 बाइट्स (गैर-प्रतिस्पर्धात्मक)

कोड:

ha

हा! यह दो बाइट्स है! दुख की बात है कि गैर-प्रतिस्पर्धा क्योंकि यह भाषा चुनौती देती है :(

स्पष्टीकरण:

h   # Convert input to hexadecimal
 a  # is_alpha, checks if the value only contains letters

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

— अदनान
स्रोत

1

— मैजिक ऑक्टोपस Urn

2

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

lambda x:min(hex(x)[1:])>'@'

— 0WJYxW9FMN
स्रोत

2

आम लिस्प, 40 बाइट्स

(every'alpha-char-p(format()"~x"(read)))

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

— रेंज़ो
स्रोत

2

स्माइलबासिक 3.2.1, 78 बाइट्स

INPUT V FOR I=0 TO 9
IF INSTR(HEX$(V),STR$(I))>-1 THEN ?"FALSE"END
NEXT?"TRUE"

— snail_
स्रोत

मुझे यहाँ कोई भी गैर-ASCII वर्ण नहीं दिखता (जब तक कि कुछ न हो); यह काउंटर निश्चित निर्णायक है और यह कहता है 81।

— बिल्ली

1

यह मायने नहीं रखता कि कार्यान्वयन आंतरिक रूप से UTF-16 का उपयोग करता है; बाकी दुनिया में वे रेंज में UTF-8 वर्ण हो सकते हैं 0-127, इस प्रकार आपकी बाइट गिनती है 81।

— बिल्ली

प्रतिक्रिया के लिए धन्यवाद, निश्चित नहीं था अगर "बाइट्स" का मतलब है कि मुझे प्रति चार्ट 2 गिनना चाहिए। 81 है।

— घोंघा_

दरअसल, वर्तमान + 10 / -0 सर्वसम्मति (जो, वैसे, मैं अब असहमत हूं) यह है कि हमें हमेशा एन्कोडिंग का उपयोग करना चाहिए जो एक दुभाषिया उपयोग करता है। यदि आप असहमत हैं, तो कृपया उस प्रश्न पर एक असहमतिपूर्ण राय पोस्ट करें।

— lirtosiast

@ThomasKwa pfft, ठीक है, उफ़, अब मैं बेहतर जानता हूं। मुझे इस बात का अंदाजा नहीं था कि इस बारे में सर्वसम्मति है, और मैं मेटा पर थोड़ा समय बिताता हूं।

— बिल्ली

1

जाप, 12 बाइट्स

!UsG r"[a-f]

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

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

!UsG r"[a-f] // Implicit: U = input integer, G = 16
 UsG         // Convert U to a base-16 string.
     r"[a-f] // Replace all lowercase letters with an empty string.
!            // Take the logical NOT of the result.
             // This returns true for an empty string; false for anything else.

— ETHproductions
स्रोत

मुझे लगता है !!UsG r"\\dकि काम कर सकता है और एक बाइट बचा सकता है

— डाउनगैट

@Downgoat अच्छा अवलोकन, लेकिन यह किसी भी संख्या के लिए सही है, जिसमें एक पत्र शामिल है।

— ETHproductions

1

गामा, ४१ अक्षर

*=@c{@radix{10;16;*}}
c:<D>=f@end;?=;\Z=t

गीमा में कोई बूलियन नहीं है, इसलिए यह बस "टी" या "एफ" आउटपुट करता है।

नमूना रन:

bash-4.3$ echo -n '11259375' | gema '*=@c{@radix{10;16;*}};c:<D>=f@end;?=;\Z=t'
t

— आदमी काम पर है
स्रोत

संख्याएँ जो वास्तव में अक्षर हैं

पायथ, 43 - 40 = 3 बाइट्स

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

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

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

TeaScript , 11 बाइट्स 13 15 16

व्याख्या

पायथन, 24 बाइट्स

MATL , 10

उदाहरण

व्याख्या

बोनस चुनौती: 53−40 = 13

उदाहरण

व्याख्या

LabVIEW, 52-40 = 12 LabVIEW आदिम

सी, 46 43 37 बाइट्स

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

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

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

जावास्क्रिप्ट, ईएस 6, कोई रेगेक्सपी, 28 बाइट्स

जूलिया, 18 बाइट्स

जावास्क्रिप्ट ईएस 6, 29

जीएस 2 , 6 बाइट्स

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

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

जावा, 46 44 38 बाइट्स

सीजाम ( ९ tes बाइट्स)

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

पर्ल, 69 - 40 = 29 बाइट्स

सीलोन, 55 बाइट्स

जंग, 70 बाइट्स

CJam, 44 बाइट्स - 40 बोनस = 4 बाइट्स

गंभीरता से, 12 बाइट्स

05AB1E , 2 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

आम लिस्प, 40 बाइट्स

स्माइलबासिक 3.2.1, 78 बाइट्स

जाप, 12 बाइट्स

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

गामा, ४१ अक्षर