क्या मैं एक अशिष्ट संख्या हूँ?

72

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

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक इनपुट प्राप्त करता है और एक सत्य / गलत मान के आधार पर आउटपुट करता है कि इनपुट एक अशिष्ट संख्या है।

इनपुट:

0 और 10 9 (समावेशी) के बीच एक पूर्णांक ।

आउटपुट:

एक सत्य / मिथ्या मूल्य जो इंगित करता है कि इनपुट एक अशिष्ट संख्या है।

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

Input:    Output:
0   --->  falsy
3   --->  falsy
4   --->  truthy
25  --->  falsy
36  --->  truthy
127 --->  falsy
131 --->  truthy

स्कोरिंग:

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर जीतता है।

code-golf  number  decision-problem 
— Gryphon
स्रोत
43
assume we continue with a third hand, जब यह अशिष्ट होने की बात आती है, तो टीमवर्क सपने को काम करता है।
— विस्कह
5
@ वीसा ने कहा कि प्रश्न की सीमा के लिए, आपको किसी भी दिए गए नंबर को बनाने के लिए केवल 3 लोगों की आवश्यकता है। यकीन है कि उंगलियों पर पुरानी तरह की गिनती धड़कता है।
— ग्रीफॉन
12
यदि आप ब्रिटिश हैं तो यह और भी बुरा है - 6 भी अशिष्ट है!
— मैथ्यू
1
क्या 10 से अलग आधार में इनपुट लेना ठीक है?
— wastl
2
5 काफी अशिष्ट भी लगता है। यकीन नहीं होगा कि कोई भी यह कहेगा कि "ओह, उसने अपना अंगूठा बाहर कर दिया है, यह पूरी तरह से विनम्र है"
— ale10ander

जवाबों:

17

रेगेक्स (ECMAScript), 37 बाइट्स

इनपुट असमान में है, क्योंकि स्ट्रिंग की लंबाई xएस है।

^((?=(x+)(\2{31}x*))\3)*(x{32})*x{4}$

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

^
(
    (?=(x+)(\2{31}x*))    # \2 = floor(tail / 32); \3 = tool to make tail = \2
    \3                    # tail = \2
)*                        # Loop the above as many times as necessary to make
                          # the below match
(x{32})*x{4}$             # Assert that tail % 32 == 4
— Deadcode
स्रोत
13
मुझे लगा कि मैं रेगेक्स जानता हूं, लेकिन स्पष्ट रूप से नहीं।
— सीटी हॉल
14

जावास्क्रिप्ट (स्पाइडरमोनी) , 23 बाइट्स

f=x=>x&&x%32==4|f(x>>5)

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

यह एक तुच्छ समाधान है, आप बस आधार 32 में बदलना चाहते हैं और जांच सकते हैं कि इसमें 4 है या नहीं।

जावास्क्रिप्ट (स्पाइडरमोनी) , 26 बाइट्स

x=>x.toString(32).match(4)

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

यह दिलचस्प है कि /4/.test(...)एक से अधिक बाइट की लागत ....match(4)।

— TSH
स्रोत
8

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

->n{n.to_s(32)[?4]}

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

@ बाइट विधि के साथ 17 बाइट्स सहेजे गए ।

— Doorknob
स्रोत
यह 2207 के लिए सही है, जिसका बाइनरी प्रतिनिधित्व है100010011111
— अवतार
@EmbodimentofIgnorance यह सही परिणाम है, है ना? दूसरा हाथ है 00100।
— दरवाज़े
मैं रूबी नहीं बोलता। पर क्यों नहीं ->n{n.to_s(32)=~/4/}?
— tsh
1
@tsh क्योंकि मैं आप के रूप में :) के रूप में चतुर नहीं कर रहा हूँ
— दरवाज़े
मुझे माफ कर दो अगर मैं सवाल नहीं समझ रहा हूँ, लेकिन 2207 का पहला हाथ नहीं है 10001, दूसरा 00111और तीसरा 11? उनमें से कोई भी अपनी मध्य उंगली केवल ऊपर नहीं है
— अज्ञानता का अवतार
8

एपीएल + विन, 10 बाइट्स

पूर्णांक के इनपुट के लिए संकेत

4∊(6⍴32)⊤⎕

10 ^ 9 का प्रतिनिधित्व करने के लिए छह हाथों की आवश्यकता होती है आधार 32 के 6 तत्वों के वेक्टर में अभिसरण 32 प्रतिनिधित्व और जाँच करता है यदि 4 किसी भी तत्व में मौजूद है।

— ग्राहम
स्रोत
6

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

{.base(32)~~/4/}

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

जांच करें कि क्या वहाँ एक 4संख्या का आधार 32 प्रतिनिधित्व में। निल को असत्य के रूप में लौटाता है या मैच युक्त होता है 4।

आप इसे इस तथ्य से साबित कर सकते हैं कि इसलिए प्रत्येक अंक प्रत्येक हाथ की स्थिति है।25=32

— मजाक कर रहा है
स्रोत
6

पायथन 2 , 34 32 बाइट्स

f=lambda a:a%32==4or a>0<f(a/32)

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

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

— चास ब्राउन
स्रोत
1
: | आप पदों को संपादित कर सकते हैं, आप जानते हैं कि सही
— ASCII- केवल
हाँ; मुझे पता है। वह एक हादसा था! एक दुर्घटना, मैं तुम्हें बताता हूँ!
— चास ब्राउन
@tsh ओह अच्छा, भूल गया कि shortcircuits
— ASCII-केवल
6

x86 मशीन कोड, 17 ​​बाइट्स

6A 20 59 85 C0 74 09 99 F7 F9 83 FA 04 75 F4 91 C3

ऊपर बाइट्स एक समारोह है कि में इनपुट के रूप में नंबर लेता है परिभाषित EAXरजिस्टर, और में एक बूलियन मान के रूप में परिणाम देता है EAXरजिस्टर ( EAX== 0 यदि इनपुट है नहीं एक अशिष्ट संख्या; EAX! = 0 इनपुट अगर है एक असभ्य संख्या )।

मानव पठनीय असेंबली mnemonics में:

; Determines whether the specified number is a "rude" number.
; Input:    The number to check, in EAX
; Output:   The Boolean result, in EAX (non-zero if rude; zero otherwise)
; Clobbers: ECX, EDX
IsRudeNumber:
    push    32           ; \ standard golfing way to enregister a constant value
    pop     ecx          ; /  (in this case: ECX <= 32)
CheckNext:
    test    eax, eax     ; \ if EAX == 0, jump to the end and return EAX (== 0)
    jz      TheEnd       ; /  otherwise, fall through and keep executing
    cdq                  ; zero-out EDX because EAX is unsigned (shorter than XOR)
    idiv    ecx          ; EAX <= (EAX / 32)
                         ; EDX <= (EAX % 32)
    cmp     edx, 4       ; \ if EDX != 4, jump back to the start of the loop
    jne     CheckNext    ; /  otherwise, fall through and keep executing
    xchg    eax, ecx     ; store ECX (== 32, a non-zero value) in EAX
TheEnd:
    ret                  ; return, with result in EAX

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

— कोडी ग्रे
स्रोत
1
दिलचस्प विचार का उपयोग करने के लिए idiv, यद्यपि। मुझे इसमें कोई वृद्धिशील सुधार नहीं दिख रहा है। लेकिन मेरा जवाब देखें : एक बदलाव पाश के लिए 14 बाइट्स जो असभ्यता के लिए कम 5 बिट्स की जांच करने के लिए MOV / AND / SUB / JZ का उपयोग करता है।
— पीटर कॉर्ड्स
4

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

f(n)=n%32==4||n>0<f(n>>5)

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

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

वैकल्पिक जो कि 1 वर्ण छोटा होता है, लेकिन 1 बाइट अधिक लंबा होता है, ∈जो यूनिकोड में 3 बाइट्स लेता है। 

n->'4'∈string(n,base=32)

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

— किरिल एल।
स्रोत
क्या आप n->n%32...2 बाइट्स के लिए अपने पहले उत्तर के लिए उपयोग कर सकते हैं ?
— ग्यूसेप
@Giuseppe, दुर्भाग्य से नहीं, वह कार्य पुनरावर्ती है।
— किरिल एल।
4

05AB1E , 5 बाइट्स

32B4å

पोर्ट ऑफ @ अडाम का एपीएल (डीज़िमा / एपीएल) उत्तर ।

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

स्पष्टीकरण:

32B    # Convert the (implicit) input to Base-32
   4å  # And check if it contains a 4
       # (output the result implicitly)
— केविन क्रूज़सेन
स्रोत
1
बहुत बुरा ₆36 है, 32 नहीं।
— मैजिक ऑक्टोपस Urn
4

कैथोलिक , 4 बाइट्स

ǔ?QǑ

बेस-256 स्ट्रिंग के रूप में एक संख्या लेता है।

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

परीक्षण सूट

— Okx
स्रोत
2
एचएम, अगर यह अनुमति है, तो क्या इसके बजाय आधार 32 में संख्या स्वीकार करने की अनुमति है?
— पुनरावर्ती
@recursive आप में संख्या घेर कर सकते हैं <<और >>और के रूप में टेस्ट स्वीट में दिखाया गया है यह, उन में 255 से अधिक से अधिक संख्या के लिए अनुमति देता है।
— ओकेक्स
1
यह चुनौती के बारे में एक सवाल के रूप में था लेकिन यह बहुत स्पष्ट नहीं था।
— पुनरावर्ती
4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 31 बाइट्स

n=>{for(;n>0;n/=n%32==4?0:32);}

एक अपवाद फेंकने से आउटपुट। जिस तरह से आप एक संख्या को दशमलव से दूसरे आधार में परिवर्तित करते हैं, उस आधार से दशमलव संख्या को बार-बार विभाजित करते हैं और शेष को एक अंक के रूप में लेते हैं। यही हम करते हैं, और हम जांचते हैं कि क्या अंकों में से किसी का आधार -32 में 4 का मान है;

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

— अज्ञान का अवतार
स्रोत
27? एक बोनस के रूप में यह एक अजीब तरीके से आउटपुट नहीं करता है
— एएससीआईआई-केवल
1
यह भी कि tplig क्या है
— केवल
@ n>31n>0
— ASCII-
— केविन क्रूज़सेन
1
प्रोग्राम हाॅल्ट की अनुमति है या नहीं, इसकी अनुमति आउटपुट विधि नहीं है । अपवाद के माध्यम से आउटपुट की अनुमति है।
— 22
3

आर , 50 48 बाइट्स

any(2^(0:4)%*%matrix(scan()%/%2^(0:34)%%2,5)==4)

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

अब एक साफ मैट्रिक्स-आधारित दृष्टिकोण का उपयोग करता है (@Giueseppe के सौजन्य से)। यह 5x7 मैट्रिक्स का बिट उत्पन्न करता है, इसे बेस 32 पूर्णांक की श्रृंखला में परिवर्तित करता है, और किसी भी 4s के लिए जाँच करता है।

— निक केनेडी
स्रोत
@Giuseppe ओह, पूरी तरह से याद किया। अब काम करना चाहिए, हालांकि निराशाजनक 19 बाइट्स लंबे समय तक। मुझे नहीं लगता कि बेस आर में हेक्साडेसिमल और ऑक्टल के अलावा स्ट्रैटो के अलावा एक उलटा कार्य है
— निक कैनेडी
कुछ मैट्रिक्स जादू के साथ 48 बाइट्स । मेरा मानना ​​है कि बिट रूपांतरण से अधिक लंबा है, intToBitsलेकिन तब हम intsइसके साथ काम कर सकते हैं जिसके बजाय rawएक बाइट की बचत होती है - उदाहरण के लिए इसेintToBits
— Giuseppe
@Giuseppe यह मेरे लिए एक पूरी तरह से अलग (और साफ) समाधान है - क्या आप चाहते हैं कि मैं मेरा अपडेट करूं या आप अपनी खुद की पोस्ट करें?
— निक कैनेडी
आप इसे लेने के लिए स्वतंत्र हैं। :-)
— Giuseppe
1
बेशक, 4आधार -32 संख्या में अंक की उपस्थिति के लिए परीक्षण करने वाले कई उत्तरों में से एक को पोर्ट करना, ओह, 29 बाइट्स है ।
— ग्यूसेप
2

सी (जीसीसी) , 34 बाइट्स

f(i){return i?i&31^4?f(i/32):1:0;}

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

— celtschk
स्रोत
32 बाइट्स की अभिव्यक्ति को पुनर्व्यवस्थित करके।
— Arnauld
3
या 25 बाइट्स जिस तरह से जीसीसी का दुरुपयोग कर रहा है वह इसे संकलित कर रहा है।
— Arnauld
2

चारकोल , 6 बाइट्स

№⍘Ｎ³²4

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। -संख्या कितनी कठोर है, इसके अनुसार आउटपुट । स्पष्टीकरण:

  Ｎ     Input as a number
 ⍘      Convert to base as a string
   ³²   Literal 32
№       Count occurrences of
     4  Literal string `4`

मैं 32और के लिए संख्यात्मक शाब्दिक अलग करने से बचने के लिए स्ट्रिंग आधार रूपांतरण का उपयोग करता हूं 4।

— नील
स्रोत
2

क्यूबिक्स , 26 बाइट्स

u!@-W14;OIS%/\;;,p;?wO@u/s

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

इस प्रकार के रूप में बढ़त लंबाई 3 के साथ एक घन पर लपेटता है

      u ! @
      - W 1
      4 ; O
I S % / \ ; ; , p ; ? w
O @ u / s . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

देखो इसे चलाते हैं

एक बिल्कुल बुनियादी कार्यान्वयन, सभी पुनर्निर्देशों के बिना यह करता है:

  • IS कार्यक्रम को आरंभ करता है इनपुट और 32 को स्टैक पर धकेलने से
  • %4-! शेष हो जाता है और जाँचता है कि क्या यह घटाव से 4 है
  • 1O@ आउटपुट 1 अगर यह 4 और रुका हुआ था
  • ;;, स्टैक को साफ करें और पूर्णांक विभाजित करें
  • p;? 0 के लिए स्टैक और चेक डि परिणाम के नीचे साफ करें
  • O@ यदि div परिणाम शून्य आउटपुट और रुका हुआ है
  • s स्टैक के शीर्ष को स्वैप करें और ऊपर चरण 2 पर वापस शुरू करें
— MickyT
स्रोत
2

MATL , 8 बाइट्स

32YA52=a

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

— Sanchises
स्रोत
@ उपर मैं निश्चित रूप से ड्रॉप कर सकता हूं G(यह सुनिश्चित नहीं है कि मैंने इसे पहली जगह में क्यों शामिल किया है), लेकिन यह केवल एक बाइट है (उस जगह को खोलने के लिए धन्यवाद!)। बदलने 32YA52के लिए 32_YA4है बाइट्स की एक ही नंबर है ना?
— Sanchises
आह, हाँ, मैं गिनती नहीं कर सकता
— लुइस मेंडो
2
@ लिस्ट काउंट? जब आप कर सकते हैं, तो गिनने की जरूरत है'32_YA4'n'32YA52'n-
— Sanchises
2

बैच, 77 45 बाइट्स

@cmd/cset/a"m=34636833,n=%1^m*4,(n-m)&~n&m*16

इन बिट twiddling हैक के आधार पर । स्पष्टीकरण: केवल 6 हाथों को सीमित सीमा (30 बिट) इनपुट के कारण जांचने की आवश्यकता होती है जो कि समर्थित होना आवश्यक है। मैजिक नंबर बेस 32 के mबराबर है 111111, ताकि पहला ऑपरेशन इनपुट नंबर में अशिष्ट बिट्स को जन्म दे। तब यह पता चलता है कि 6 में से कौन सा हाथ अब शून्य है।

— नील
स्रोत
2

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

(एक ही मशीन कोड 16-बिट, 32-बिट और 64-बिट में काम करता है। 16-बिट मोड में, यह 32 और 64-बिट मोड में EAX और EDI के बजाय AX और DI का उपयोग करता है।)

एल्गोरिथ्म: कम 5 बिट्स की जाँच करें x & 31 == 4, फिर 5 बिट्स द्वारा राइट-शिफ्ट करें, और अगर शिफ्ट रिजल्ट नॉन-जीरो है, तो दोहराएं।

X86-64 char isrude(unsigned n);सिस्टम V कॉलिंग कन्वेंशन के अनुसार C से कॉल करने योग्य। 0 सत्य है, गैर-0 मिथ्या है (यह asm है, C 1 नहीं )।

 line   addr    code bytes
  num
     1                             ; input:  number in EDI
     2                             ; output: integer result in AL: 0 -> rude, non-zero non-rude
     3                             ; clobbers: RDI
     4                         isrude:
     5                         .check_low_bitgroup:
     6 00000000 89F8               mov    eax, edi
     7 00000002 241F               and    al, 31          ; isolate low 5 bits
     8 00000004 2C04               sub    al, 4           ; like cmp but leaves AL 0 or non-zero
     9 00000006 7405               jz    .rude            ; if (al & 31 == 4) return 0;
    10                         
    11 00000008 C1EF05             shr    edi, 5
    12 0000000B 75F3               jnz   .check_low_bitgroup
    13                             ;; fall through to here is only possible if AL is non-zero
    14                         .rude:
    15 0000000D C3                 ret


    16          0E             size:  db $ - isrude

यह op al, imm8AND और SUB के लिए शॉर्ट-फॉर्म एन्कोडिंग का लाभ उठाता है । मैं XOR al,4समानता पर 0 का उत्पादन कर सकता था , लेकिन एसयूबी तेजी से है क्योंकि यह सैंडज़ब्रिज-परिवार पर एक ही उप-और-शाखा शाखा में जेजेड के साथ मैक्रो-फ़्यूज़ हो सकता है।

मजेदार तथ्य: 1 से अधिक की शिफ्ट के ध्वज-परिणाम का उपयोग पी 6-परिवार (शिफ्ट रिटायर होने तक फ्रंट-एंड स्टॉल) पर धीमा होगा, लेकिन यह ठीक है।

फुटनोट 1: यह एक असेंबली लैंग्वेज फंक्शन है और x86 asm में दोनों हैं jzऔर jnzइसलिए मेटा के अनुसार मैं किसी भी तरह से चुन सकता हूं। मैं सी सत्य / मिथ्या से मेल करने के लिए यह इरादा नहीं कर रहा हूँ।

यह EFLAGS के बजाय AL में लौटने के लिए सुविधाजनक था, इसलिए हम एक आवरण के बिना सी कंपाइलर को फ़ंक्शन का वर्णन कर सकते हैं, लेकिन मेरी सत्यता / मिथ्या का परीक्षण करने के लिए C कॉलर का उपयोग करके विवश नहीं है।

— पीटर कॉर्डेस
स्रोत
2

ईएस 6, 31 30 26 बाइट्स

b=>b.toString(32).match`4`

यह कैसे आगे कम करने पर विचार कहने के लिए स्वतंत्र महसूस करें, यदि कोई हो।

— elipszilon
स्रोत
PPCG में आपका स्वागत है!
— लकोनी
आपको अपने फ़ंक्शन का नाम गिनाने की आवश्यकता नहीं है, और यद्यपि मुझे लगता है कि आप एक बाइट का उपयोग करके testबचा सकते हैं, आप वास्तव में दो बाइट्स 4को एक संख्या के रूप में मिलान करके बचा सकते हैं और matchइसे एक स्ट्रिंग में परिवर्तित कर सकते हैं और फिर आपके लिए एक RegExp बन सकता है। ।
— नील
1

रेटिना 0.8.2 , 31 बाइट्स

.+
$*
+`(1+)\1{31}
$1;
\b1111\b

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। जब तक संख्या अशिष्ट न हो, तब तक आउटपुट शून्य होता है। इनपुट को यूनीरी में परिवर्तित करके और फिर यूनिरी-एनकोडेड बेस 32 पर काम करता है और 4परिणाम में s की संख्या गिनता है ।

— नील
स्रोत
1

जावा 8, 40 33 बाइट्स

n->n.toString(n,32).contains("4")

पोर्ट ऑफ @ अडाम का एपीएल (डीज़िमा / एपीएल) उत्तर ।

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

स्पष्टीकरण:

n->                 // Method with Integer parameter and boolean return-type
  n.toString(n,32)  //  Convert the input to a base-32 String
   .contains("4")   //  And check if it contains a "4"
— केविन क्रूज़सेन
स्रोत
1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 37 बाइट्स 36 बाइट्स 29 बाइट्स

जोनाथन फ्रेच द्वारा -2 बाइट्स

#~IntegerDigits~32~MemberQ~4&

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

31-बाइट समाधान:

MemberQ[IntegerDigits[#,32],4]&

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

— रेनर ग्लूज
स्रोत
नमस्कार और पीपीसीजी में आपका स्वागत है। जैसा कि यह खड़ा है, आपकी अभिव्यक्ति एकल बूलियन मान है। कृपया या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन होने के लिए अपना उत्तर ठीक करें ( ...#...&इसका उपयोग अक्सर गणित में किया जाता है)।
— जोनाथन फ्रीच
नमस्ते। क्या तुम्हारे कहने का मतलब यही था?
— रेनर ग्लूज
pls डब्ल्यू के बजाय tio.run/#mathematica का उपयोग करें। यह सुनिश्चित करने के लिए कि यह वैध गणित कोड है: P और आपको [n]अंत में, बस जरूरत नहीं है &। इसके अलावा, चूंकि पोस्ट्स ने इतिहास संपादित किया है, इसलिए पिछली प्रविष्टियों को छोड़ना ठीक है, और पुराने स्कोर के लिए कन्वेंशन है<s>40</s> <s>36</s>
— ASCII- केवल
हाँ। यही मेरा मतलब है। 29 बाइट्स ।
— जोनाथन फ्रेच
मुझे लगता है कि मुझे कार्यात्मक प्रोग्रामिंग शैली के लिए उपयोग करना होगा।
— रेनर ग्लूज
1

जावा 8, 28 22 21 बाइट्स

n->n%32==4|n>>5%32==4

@ केविन- cruijssen जवाब से प्रेरित है । केवल 2 हाथों के लिए काम करता है।

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

स्पष्टीकरण:

n->                 // Method with int parameter and boolean return-type
  n%32              // Only consider right 5 bytes (fingers)
  ==4               // Middle finger
  | ... n>>5       // Repeat with shifted bits for other hand
— डैनियल Widdis
स्रोत
मुझे पूरा यकीन है कि दोनों हाथों से जवाब देना होगा
— इग्नोरेंस का अवतार
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.