यह कैसे निर्धारित किया जाए कि कोई संख्या विषम है या बिना मॉड-बिट-बिट ऑपरेशंस के? [बन्द है]

19

यह कैसे निर्धारित किया जाए कि कोई संख्या विषम है या बिना मॉड-बिट-बिट ऑपरेशंस के?

यह चुनौती स्थूल रूप से अक्षम है, लेकिन रचनात्मक समाधान के लिए बॉक्स के बाहर सोचने की आपकी क्षमता को चुनौती देती है।

संपादित करें :

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

पृष्ठभूमि : यह प्रश्न मेरे शुरुआती प्रोग्रामिंग दिनों से उपजा है। हमारी कक्षा के पहले दिन का होमवर्क एक साधारण कार्यक्रम लिखना था जो 'विषम' या 'सम' छपा हो। मैं जिस बव्वा के रूप में था, मैंने उस पुस्तक को नहीं पढ़ा था जो हमारे पास उस वर्ग के लिए थी जहाँ उसने हमें दिखाया था कि यह कैसे%निर्धारित किया जाए। मैंने लगभग आधे घंटे तक अपने कमरे में आगे पीछे रहने की कोशिश की और ऐसा करने का तरीका सोचने की कोशिश की और व्याख्यान से याद आया कि नंबर खो सकते हैं और सटीक हासिल कर सकते हैं क्योंकि वे एक आदिम प्रकार से दूसरे में डाले जाते हैं। इसलिए, यदि आपने नंबर लिया है, तो इसे दो से विभाजित किया है और फिर इसे गुणा किया है मूल संख्या के बराबर नहीं है, तो आपको पता होगा कि संख्या विषम थी।

मैं अगले दिन स्तब्ध रह गया, जबकि हमारे प्रशिक्षक हमारे कार्यक्रमों का मूल्यांकन कर रहे थे, कि उन्होंने सोचा कि यह सबसे मूल, अगर अक्षम, समस्या को हल करने का तरीका है।

code-challenge 
— वेन हार्टमैन
स्रोत
3
क्या हमें कोई फंक्शन या प्रोग्राम बनाना चाहिए? अगर हमें कोई कार्यक्रम करना है तो IO कैसे होना चाहिए? कृपया, आगे विस्तार से बताएं।
— जुआन
2
स्वीकार किए गए उत्तर को किस उद्देश्य की कसौटी पर निर्धारित करेंगे? कोड का आकार? कुछ और?
— PleaseStand
क्या यह निश्चित रूप से एक संख्या है? यह एक स्ट्रिंग के लिए झूठी सकारात्मक देना चाहिए?
— विलियम
यह काफी लंबे समय से है, लेकिन इसमें किसी भी तरह की जीत की स्थिति नहीं है, जो मेरे दिमाग का मतलब है कि यहां कोई खेल नहीं है।
— dmckee

जवाबों:

40

अधिकांश प्रोग्रामिंग भाषाओं में विभाजन पूर्णांकों के लिए भागफल देता है। तो आप बस इसे चेक कर सकते हैं

(i/2)*2==i
— fR0DDY
स्रोत
6
जरूरी नहीं कि मैं सबसे कहूं। कई, शायद।
— जोई
1
सुनिश्चित करने के लिए यह ठीक से चलाता है, आप सुनिश्चित करने की आवश्यकता है कि आप एक में सब कुछ डाली int/ longप्रकार
— वॉरेन
@warren प्रोग्रामिंग भाषा / संकलक अनुकूलन / आदि पर निर्भर करता है। इसके अतिरिक्त, आप उपयोग कर सकते हैं floor()। यह C और C ++ में पूरी तरह से काम करता है।
— मतीन उल्हाक
1
0 एक सम संख्या है?
— उपयोगकर्ता अज्ञात
4
@userunknown: हाँ, शून्य भी है।
— कीथ थॉम्पसन
71

अजगर

print('even' if (-1)**n==1 else 'odd')
— dan04
स्रोत
10
गणित की सरल सुंदरता / सुंदर सादगी ... बहुत अच्छा!
— jscs
मुझे ये वाला काफ़ी पसंद है।
— रॉब
धीमी लेकिन रचनात्मक।
— मतीन उल्हाक
21

ब्रेनफ़ *** (179)

यह सशर्त तर्क से अधिक दिलचस्प समस्याओं में से एक है जो मैंने बीएफ में किया है।

+[>,]<--------------------------------------->>+++++[>+++++++
++++++>+++++++++++++++<<-]>++++>++++<<+<+<-[>-<-[>+<-[>-<-[>+<-[>-<-[>
+<-[>-<-[>+<-[>-<[-]]]]]]]]]]>[>>>.<<-<-]>[>.<-]

यह एक नंबर के साथ एक टेक्स्ट इनपुट लेता है। यदि संख्या समान है, तो यह आउटपुट करता है E, और यदि यह विषम है, तो यह आउटपुट करता है O।

मुझे इस पर गर्व है कि मैं एक और मानव पठनीय रूप दिखाऊंगा:

+[>,]                                                   steps through input until it reaches eof.
<---------------------------------------                gets the numerical value of the last digit
>>+++++[>+++++++++++++>+++++++++++++++<<-]>++++>++++    store E and O
<<+<+<                                                  store a bit indicating parity, and a temporary bit
-[>-<                                                   !1
  -[>+<                                                 && !2
    -[>-<                                               && !3
      -[>+<                                             && !4
        -[>-<                                           && !5
          -[>+<                                         && !6
            -[>-<                                       && !7
              -[>+<                                     && !8
                -[>-<[-]]                               && !9
              ]
            ]
          ]
        ]
      ]
    ]
  ]
]
>[>>>.<<-<-]>[>.<-]                                     Display E or O based on the value of the parity bit.
— पीटर ओल्सन
स्रोत
21

मेथेमेटिका

SawtoothWave[x / 2] == 0
Exp[I Pi x] - 1 == 0
Sin[5 x / Pi] == 0
— मिंग-तांग
स्रोत
2
क्या आप इन दो समाधानों को अलग-अलग उत्तरों में विभाजित कर सकते हैं?
— फूजएक्सएक्सएल
क्या वे चार उपाय नहीं हैं?
— जॉय
दरअसल, मैथेमेटिका में सभी बिल्ट-इन नामों को कैपिटल में रखा गया है, इसलिए यह जितना मज़ेदार दिखता है, आपको उपयोग करना चाहिए Iऔर Piइसके बजाय iऔर pi।
— डेविड जांग
15

सी

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

#include "stdio.h"
long long input=123;
int main(){
    int a;
    for(a=6;a;a--){
        input*=input;
    }
    if(input){
        printf("Odd");
    }
    else{
        printf("Even");
    }
    return 0;
}

संपादित करें: एक साधारण कार्य के रूप में:

int isOdd(long long input){
    int a;
    for(a=6;a;a--){
        input*=input;
    }
    return !!input;
}
— aaaaaaaaaaaa
स्रोत
अहस्ताक्षरित पूर्णांक का उपयोग करना सुनिश्चित करें। हस्ताक्षरित पूर्णांक का अतिप्रवाह C में अपरिभाषित व्यवहार है, इसलिए यदि वह चाहता तो अनुकूलन कुछ अजीब कर सकता था।
— जॉय एडम्स
13

अजगर (धीरे)

n=1234
while n > 1: n -= 2 #slow way of modulus.
print "eovdedn"[n::2]
— st0le
स्रोत
1
सकारात्मक के लिए काम करता है ... मुझे लगता है मैं abs()शुरुआत में एक कॉल जोड़ सकता है ।
— st0le
@ जोश: यह ट्रिक अब तक कुछ समय पहले ही सामने आई थी :)
— जॉय
क्रेडिट को gnibblr :)
— st0le
@ जॉय: मुझे यह समझ में नहीं आया कि यह नया था, लेकिन शैली का मूल होना जरूरी नहीं है। :)
— jscs
12

जावास्क्रिप्ट

/[02468]$/.test(i)

trueएक सम संख्या के लिए पैदावार । यह केवल यथोचित आकार पूर्णांक के साथ काम करता है (उदाहरण के लिए जब स्ट्रिंग में परिवर्तित नहीं किया जाता है और आंशिक भाग नहीं होता है तो वैज्ञानिक संकेतन नहीं होता है)।

— कृपया उठो
स्रोत
2
"फ़ंक्शन" आवश्यकता को पूरा करने के लिए आप इसे बस बदल सकते हैं /[02468]$/.test।
— Ry-
यह बिल्कुल प्रश्न में स्पष्ट नहीं किया गया था लेकिन यह है कि इनपुट सब पर कोई अंक नहीं है यह संभव हो सकता है, /[02468]$/.test('I am a fake even number 0')। उस मामले में आप कर सकते हैं/^[0-9].[02468]$/.test(i)
— विलियम 23
/-?^\d*[02468]$/अपने regex की तुलना में थोड़ा सख्त होगा। वैज्ञानिक संकेतन का उपयोग करते हुए संख्याओं के लिए ठीक से काम करने के लिए आपको इसके लिए अधिक काम करने की आवश्यकता होगी।
— थॉमस एडिंग
12

अजगर

चूंकि मुझे वास्तव में यकीन नहीं है कि स्कोरिंग मानदंड क्या हैं, इसलिए यहां समाधान का एक समूह है जो मैं मनोरंजन के लिए आया हूं। उनमें से ज्यादातर abs(n)नकारात्मक संख्याओं का समर्थन करने के लिए उपयोग करते हैं। अधिकांश, यदि सभी नहीं, तो उनमें से कभी भी वास्तविक गणना के लिए उपयोग नहीं किया जाना चाहिए।

यह एक तरह का उबाऊ है:

from __future__ import division
def parity(n):
    """An even number is divisible by 2 without remainder."""
    return "Even" if n/2 == int(n/2) else "Odd"

def parity(n):
    """In base-10, an odd number's last digit is one of 1, 3, 5, 7, 9."""
    return "Odd" if str(n)[-1] in ('1', '3', '5', '7', '9') else "Even"

def parity(n):
    """An even number can be expressed as the sum of an integer with itself.

    Grossly, even absurdly inefficient.

    """
    n = abs(n)
    for i in range(n):
        if i + i == n:
            return "Even"
    return "Odd"

def parity(n):
    """An even number can be split into two equal groups."
    g1 = []
    g2 = []
    for i in range(abs(n)):
        g1.append(None) if len(g1) == len(g2) else g2.append(None)
    return "Even" if len(g1) == len(g2) else "Odd"

import ent # Download from: http://wstein.org/ent/ent_py
def parity(n):
    """An even number has 2 as a factor."""
    # This also uses modulo indirectly
    return "Even" if ent.factor(n)[0][0] == 2 else "Odd"

और यह मेरा पसंदीदा है, हालांकि यह दुर्भाग्य से काम नहीं करता है (जैसा कि नीचे मार्च हो द्वारा बताया गया है: सिर्फ इसलिए कि सभी संख्याएं दो primes का योग हैं, इसका मतलब यह नहीं है कि सभी विषम संख्याएं नहीं हैं)।

import itertools
import ent    # Download from: http://wstein.org/ent/ent_py
def parity(n)
    """Assume Goldbach's Conjecture: all even numbers greater than 2 can
    be expressed as the sum of two primes.

    Not guaranteed to be efficient, or even succeed, for large n.

    """
    # A few quick checks
    if n in (-2, 0, 2): return "Even"
    elif n in (-1, 1): return "Odd"
    if n < 0: n = -n    # a bit faster than abs(n)
    # The primes generator uses the Sieve of Eratosthenes
    # and thus modulo, so this is a little bit cheating
    primes_to_n = ent.primes(n)
    # Still one more easy way out
    if primes_to_n[-1] == n: return "Odd"
    # Brutish!
    elif n in (p1+p2 for (p1, p2) in itertools.product(primes_to_n, primes_to_n)):
        return "Even"
    else:
        return "Odd"
— jscs
स्रोत
प्यारा समाधान :-)
— जॉय
2
वास्तव में एक पुराना नेक्रो, लेकिन क्या आपका गोल्डबैच का अनुमान उत्तर प्रिंट 9 के लिए भी नहीं है? परिणामी गिरावट
— मार्च हो
हाँ, आप बिल्कुल सही हैं, एक सौ प्रतिशत सही, @ मार्कोहो। मेरे चेहरे पर अंडा।
— jscs
10

हास्केल

यह, निश्चित रूप से, रचनात्मक, सोच-समझ के बाहर का कोई समाधान नहीं है जिसकी आप तलाश कर रहे हैं, लेकिन मैं कितनी बार गोल्फकॉप की तुलना में हास्केल उत्तर पोस्ट करने जा रहा हूं, वास्तव में? यह वास्तव में शर्म की बात है कि यह एक कोड गोल्फ नहीं है।

odd

लेकिन अधिक गंभीरता से:

data Parity = Even | Odd
            deriving (Show)

parity = p evens odds
  where p (x:xs) (y:ys) i | i == x = Even
                          | i == y = Odd
                          | otherwise = p xs ys i
        evens = interleave [0,2..] [-2,-4..]
        odds = interleave [1,3..] [-1,-3..]
        interleave (x:xs) ys = x : interleave ys xs
गोल्फस्क्रिप्ट की तुलना में लंबे समय तक मुझे जवाब मिलता है
— वॉरेन
2
मैं पहले ब्लॉक ( odd) का जिक्र कर रहा था, जो एक बिल्टिन फ़ंक्शन है जो संख्या के विषम होने पर ट्रू रिटर्न करता है। यह अपने आप में एक पूर्ण उत्तर है और वर्तमान गोल्फस्क्रिप्ट उत्तर की तुलना में छोटा है (जो लिखने के समय यह 10 वर्ण है, लेकिन मुझे उम्मीद है कि नीचे जाना होगा)। यह सवाल थोड़ा अशिक्षित भी है, यही कारण है कि मैं oddपर्याप्त है। वह भी बदल सकता है।
1
आपके उत्तर में पहला उत्तर छूट गया :)
— वॉरेन
1
बहुत कम से कम parityएल्गोरिदम सभी Numउदाहरणों पर काम करता है जो पूर्णांक हैं। वह गर्म है! हालांकि मैंने शायद किया होता evens = [0,2..] >>= \n -> [-n, n]। बाधाओं के लिए भी ऐसा ही है।
— थॉमस एडिंग
7

प्रश्न का जानबूझकर विकृत पढ़ने का उपयोग करते हुए, "यह निर्धारित करने के लिए कि कोई संख्या विषम या सम्‍मिलित है", यहां C कार्यान्वयन (मान लिया गया है boolऔर trueउचित रूप से परिभाषित किया गया है):

bool is_odd_or_even(int n)
{
    return true;
}
— कीथ थॉम्पसन
स्रोत
प्रश्न संख्या का उल्लेख करता है, पूर्णांक नहीं। 0.5रिटर्न की तरह संख्या trueजब यह नहीं होना चाहिए।
— कोनराड बोरोस्की
6

क्या, कोई यादृच्छिक एल्गोरिदम अभी तक ??

सी

#include<stdio.h>
#include<stdlib.h>

void prt_parity_of(int n){
  int i,j=2;
  char o[]="eovdedn"
     , f[n=abs(n)]; for(i=n;i-->0;f[i]=1);

  while(j>1){
    while((i=rand()%n)
       == (j=rand()%n)
       || (f[i]&f[j]>0)
       && (f[i]=f[j]=0)
    );for(i=j=0; ++i<n; j+=f[i])
  ;}for(;j<7;j+=2)putchar(o[j]);
}

रैंडमली जोड़ियों की संख्या 0 0 में होती है। n -1 जब तक 2 से कम नहीं रह जाती। यह काफी आश्चर्यजनक अक्षम है: हे ( एन 3 )।

पूरी तरह से अलग:

हास्केल

import Data.Complex

ft f = (\ω -> sum[ f(t) * exp(0:+2*pi*ω*t) | t<-[-1,-0.9..1] ] )

data Parity = Even | Odd deriving (Show)

parity n
  | all (\(re:+im) -> abs re > abs im) [ft ((:+0).(^^n)) ω | ω<-[0..20]]  = Even
  | otherwise                                                             = Odd

इस तथ्य का उपयोग करता है कि समरूप फ़ंक्शन (जैसे \x->x^^4) का फूरियर रूपांतरण वास्तविक है, जबकि एक विषम फ़ंक्शन का फूरियर रूपांतरण काल्पनिक है।

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत
5

विंडोज पॉवरशेल

function OddOrEven([long]$n) {
  if (0,2,4,6,8 -contains "$n"[-1]-48) {
    "Even"
  } else {
    "Odd"
  }
}
  1. स्ट्रिंग में परिवर्तित करें
  2. अंतिम अक्षर (अंक) (मूल रूप से एक मॉड 10) चुनें।
  3. जांचें कि क्या यह 0, 2, 4, 6 या 8 है।

अनुरोध के अनुसार कोई बिटवाइज़ ऑपरेटर नहीं, कोई मापांक नहीं।

— एक छोटा सा सिक्का
स्रोत
5

Coq, 103

Fixpoint even n:=match n with O=>true|S n=>odd n end with odd n:=match n with O=>false|S n=>even n end.

जहां तक ​​मैं बता सकता हूं कि यह कोडगॉल्फ पर पहली कॉक एंट्री है।

छोटा भी (59):

Fixpoint even n:=match n with O=>true|S n=>negb(even n)end.
— ReyCharles
स्रोत
4

Unlambda

दुनिया को और अधिक अनलम्बा की जरूरत है।

अनलम्बाडा का यहाँ एक हत्यारा लाभ है: इसका डिफ़ॉल्ट ( संख्याओं के लिए अहम ) प्रतिनिधित्व चर्च के अंक हैं, इसलिए यह आवश्यक है कि उन्हें द्विआधारी कार्य करने के लिए लागू किया जाए-सच काम करने के लिए नहीं। आसान!

पुनश्च: मार्कडाउन और अनलैम्बडा निश्चित रूप से एक दूसरे के लिए नहीं बने हैं।

true  = i
false = `ki
not   = ``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki
even? = ``s``si`k``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki`ki

पहले कुछ पूर्णांकों के लिए सत्यापन:

```s``si`k``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki`ki`ki                   => i
```s``si`k``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki`kii                     => `ki
```s``si`k``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki`ki``s``s`kski           => i
```s``si`k``s``s``s`k``s``si`k`kk`k`kii`k`ki`ki`ki``s``s`ksk``s``s`kski =>`ki
— जेबी
स्रोत
3

अजगर

print (["even"] + (["odd", "even"] * abs(n)))[abs(n)]

पिछले संस्करण के समान प्रदर्शन। अब 0 के लिए काम करता है।

गलत पहले वाला संस्करण:

print ((["odd", "even"] * abs(n))[:abs(n)])[-1]

विशेष रूप से कुशल नहीं; समय और स्मृति दोनों स्पष्ट रूप से हे (एन): 1,000,000 के लिए 32 मिसे; 2.3 मिसे 100000 के लिए; 100 के लिए 3.2 usec। ऋणात्मक संख्याओं के साथ काम करता है। 0 के लिए एक त्रुटि फेंकता है, क्योंकि 0 न तो सम और न ही विषम है।

— jscs
स्रोत
3
शून्य निश्चित रूप से भी है। इसे भी देखें: en.wikipedia.org/wiki/Parity_of_zero
@ जॉय: ए जी, बकवास। मुझे लगा कि यह "एक सुविधा है, बग नहीं"। अधिक संशोधन ...
— jscs
3

Fractran

[65/42,7/13,1/21,17/7,57/85,17/19,7/17,1/3]

पर लागू किया गया

63*2^abs(n)

पैदावार या 5तो nविषम है या 1यदि nहै भी।

अपडेट : बहुत छोटा लेकिन इतना दिलचस्प नहीं:

[1/4](2^abs(n))

है 2अजीब के लिए nऔर 1भी के लिए n।

— हावर्ड
स्रोत
3

MMIX (4 बाइट्स)

यह एक तरह का धोखा है। मैं न तो मॉड का उपयोग करता हूं और न ही बिट फिडलिंग ऑपरेशंस का। ऐसा नहीं है कि विषम / सम संख्याओं के लिए परीक्षण अंतर्निहित है। यह मानते हुए कि $3परीक्षण करने के लिए संख्या है और परिणाम में जाता है $2:

ZSEV $2,$3,1

सेट $2करने के लिए 1करता है, तो $3भी है और करने के लिए 0नहीं तो। महामारी का ZSEVअर्थ है शून्य-सेट और यहां तक कि निम्नलिखित शब्दार्थ भी हैं:

ZSEV a,b,c: if (even b) a = c; else a = 0;

उपरोक्त पंक्ति के लिए, mmixalविधानसभा के इन चार बाइट्स को उत्पन्न करता है:

7F 02 03 01
— FUZxxl
स्रोत
3

योजना

यह सबसे अयोग्य उपाय है जिसके बारे में मुझे पता है।

(letrec ([even? (lambda (n)
                 (if (zero? n) "even"
                     (odd? (- n 2))))]
         [odd? (lambda (n)
                 (if (= n 1) "odd"
                     (even? (- n 2))))])
  (even? (read)))
— सैमुअल ड्यूक्सोस
स्रोत
3

पर्ल

व्हाट अबाउट

use Math::Trig;
print(cos(pi*@ARGV[0])>0?"even":"odd")
— ShaiDeshe
स्रोत
2

जावास्क्रिप्ट, 36

function(i){while(i>0)i-=2;return!i}

लौटता है trueतो भी, falseनहीं तो।

— Ry-
स्रोत
2

अजगर

zip((False, True)*(i*i), range(i*i))[-1][0]

i के वर्ग का परीक्षण, इसलिए यह नकारात्मक संख्याओं के लिए भी काम करता है

— gnibbler
स्रोत
2

एफ #

जीत के लिए पारस्परिक पुनरावृत्ति।

एक संख्या n तब भी है जब वह शून्य या (n-1) विषम हो।

एक संख्या n विषम है यदि यह शून्य के लिए असमान है और (n-1) सम है।

(यदि किसी को ऋणात्मक संख्याओं की समता में रुचि है तो एब्स जोड़ा गया)

let rec even n = n = 0 || odd (abs n - 1) 
    and odd n = n <> 0 && even (abs n - 1)
— cfern
स्रोत
2

बिटवाइज़ ऑपरेशन के रूप में क्या योग्यता है? हुड के तहत, पूर्णांक विभाजन को 2-बिट के रूप में कार्यान्वित करने की संभावना है।

बिटशूट्स को मानने से बाहर नहीं हैं:

C / C ++

(unsigned char)((unsigned char)(n > 0 ? n : -n) << 7) > 0 ? "odd" : "even"

संपादित कुछ कोष्ठकों छूटी, और अंत में यह कम कर बनाने के लिए एक बदलाव को दूर करने के लिए बदल दिया। आप इसे निम्नलिखित (* निक्स में) के साथ देख सकते हैं:

echo 'main(){ std::cout<< (unsigned char)((unsigned char)(n > 0 ? n : -n) << 7) > 0 \
        ? "odd\n" : "even\n";}' \
  | gcc --include iostream -x c++ -o blah -
./blah

... हालांकि लिनक्स / tsh में, मुझे \nसिंगल-कोट्स में होते हुए भी बैकस्लैश से बचना पड़ा । मैंने छोटे और बड़े-एंडियन में परीक्षण किया, यह दोनों में सही ढंग से काम करता है। इसके अलावा, मैंने इसे कॉपी किया; मैं जिस कंप्यूटर के साथ पोस्ट कर रहा हूं उसमें कंपाइलर नहीं है, इसलिए इसमें गलतियां हो सकती हैं।

x86 अस्म

            mov eax, n          # Get the value
            cmp eax,0           # Is it zero?
            jge pos_label       # If >= 0, skip the next part
            neg eax
pos_label:

।

            imul al, 128

या

            shl  al, 7

या

            lea  eax, [eax*8]    # Multiply by 2^3 (left-shift by 3 bits)
            lea  eax, [eax*8]    # ... now it's n*2^6
            lea  eax, [eax*2]    # ... 2^7, or left-shift by 7 bits

... के बाद:

            cmp al,  0          # Check whether the low byte in the low word is zero or not
            jz  even_label      # If it's zero, then it was an even number
            odd_label           # ... otherwise it wasn't

वैकल्पिक रूप से, शिफ्ट और तुलना सामान इस तरह से किया जा सकता है:

            sar al,1            # signed integer division by 2 on least-significant byte
            jc  odd_label       # jump if carry flag is set
— ब्रायन वैंडेनबर्ग
स्रोत
BTW, shlऔर दोस्तों को अस्वीकृत कर दिया जाता है ...
— FUZxxl
2

68000 प्रोसेसर पर आप मान से परिभाषित शब्द को परीक्षण के लिए परिभाषित कर सकते हैं:

 move.l <number to test>,a0
 move.w (a0),d0
 ; it's even if the next instruction is executed

और पता त्रुटि के लिए हार्डवेयर ट्रैप को मान की विषम / सम प्रकृति निर्धारित करें - यदि अपवाद उठाया गया है, तो मान विषम था, यदि नहीं, तो मान भी था:

 <set up address error trap handler>
 move.l <pointer to even string>,d1
 move.l <number to test>,a0
 move.w (a0),d0
 <reset address error trap handler>
 <print string at d1>
 <end>

 address_error_trap_handler:
 move.l <pointer to odd string>,d1
 rte

इंटेल x86 सीपीयू पर काम नहीं करता क्योंकि वे डेटा एक्सेस के बारे में अधिक लचीले हैं।

— Skizz
स्रोत
2

अजगर

मैंने सबसे बदसूरत, सबसे भ्रामक समाधान के लिए प्रयास करने का फैसला किया, जिसके बारे में मैं सोच सकता था:

n=input();r=range(n+1)
print [j for i in zip(map(lambda x:str(bool(x))[4],[8&7for i in r]),
map(lambda x:str(x)[1],[[].sort()for x in r])) for j in i][n]

प्रिंट ई और अगर ओ भी अजीब है।

— scleaver
स्रोत
2

क्यू

एक्स <2 तक घटाना 2 रखें फिर बूल में परिवर्तित करें

{1b$-[;2]/[2<=;abs x]}
— skeevey
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.