วิธีการตรวจสอบว่าจำนวนคี่หรือแม้กระทั่งไม่มีการดำเนินงาน mod- บิต? [ปิด]


19

วิธีการตรวจสอบว่าจำนวนคี่หรือแม้กระทั่งไม่มีการดำเนินงาน mod- บิต?

ความท้าทายนี้ไม่มีประสิทธิภาพอย่างมาก แต่ท้าทายความสามารถของคุณในการคิดนอกกรอบเพื่อหาทางออกที่สร้างสรรค์

แก้ไข :

กรุณาสร้างฟังก์ชั่น นอกจากนี้ในขณะที่ regex เป็นการตอบสนองที่สนุกสนานฟังก์ชั่นควรยอมรับหมายเลขที่ถูกต้องใด ๆ

ความเป็นมา : คำถามนี้เกิดขึ้นตั้งแต่วันแรกของการเขียนโปรแกรม การบ้านในวันแรกของการเรียนคือการเขียนโปรแกรมง่าย ๆ ที่พิมพ์ 'คี่' หรือ 'คู่' การเป็นเด็กเหลือขอฉันไม่ได้อ่านหนังสือที่เรามีให้กับชั้นเรียนซึ่งมันแสดงให้เราเห็นว่าจะใช้%เพื่อตัดสินได้อย่างไร ฉันใช้เวลาประมาณครึ่งชั่วโมงเดินไปมาในห้องของฉันพยายามคิดหาวิธีที่จะทำสิ่งนี้และจำได้จากการบรรยายว่าตัวเลขอาจสูญเสียและได้รับความแม่นยำเมื่อพวกมันถูกโยนจากแบบดั้งเดิมไปอีกประเภทหนึ่ง ดังนั้นถ้าคุณเอาจำนวนนั้นหารด้วยสองแล้วคูณมันกลับไม่เท่ากับเลขดั้งเดิมคุณก็จะรู้ว่าเลขนั้นเป็นเลขคี่

ฉันตกใจมากในวันถัดไปในขณะที่ผู้สอนของเราประเมินโปรแกรมของเราเขาคิดว่ามันเป็นแบบดั้งเดิมที่สุดหากไม่มีประสิทธิภาพวิธีแก้ปัญหา


3
เราควรสร้างฟังก์ชั่นหรือโปรแกรมหรือไม่? IO ควรเกิดขึ้นได้อย่างไรถ้าเราต้องทำโปรแกรม? กรุณาอธิบายเพิ่มเติม
Juan

2
เกณฑ์วัตถุประสงค์อะไรจะเป็นตัวกำหนดคำตอบที่ยอมรับได้? ขนาดรหัส? อื่น ๆ อีก?
กรุณายืน

มันเป็นตัวเลขหรือไม่? มันควรให้ผลบวกเท็จสำหรับสตริงหรือไม่?
วิลเลียม

นี่เป็นเวลานานแล้ว แต่ดูเหมือนจะไม่มีเงื่อนไขชนะใด ๆ ซึ่งในใจของฉันหมายความว่าไม่มีเกมอยู่ที่นี่
dmckee

คำตอบ:


40

ในการเขียนโปรแกรมภาษาส่วนใหญ่หารผลหารสำหรับจำนวนเต็ม ดังนั้นคุณสามารถตรวจสอบเรื่องนี้ได้

(i/2)*2==i

6
ไม่จำเป็นต้องพูดมากที่สุด หลายคนอาจจะ
Joey

1
เพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้องคุณต้องแน่ใจว่าคุณได้โยนทุกอย่างลงในแบบint/ longประเภท
วอร์เรน

@warren ขึ้นอยู่กับภาษาการเขียนโปรแกรม / การปรับแต่งคอมไพเลอร์ / etc floor()นอกจากนี้คุณยังสามารถใช้ มันทำงานได้อย่างสมบูรณ์ใน C และ C ++
Mateen Ulhaq

1
0 เป็นเลขคู่หรือไม่
ไม่ทราบผู้ใช้

4
@userunknown: ใช่ศูนย์ยังเท่ากัน
Keith Thompson

71

หลาม

print('even' if (-1)**n==1 else 'odd')

10
ความงามที่เรียบง่าย / ความเรียบง่ายที่สวยงามของคณิตศาสตร์ ... ดีมาก!
jscs

ฉันชอบอันนี้มาก
Rob

ช้า แต่สร้างสรรค์
Mateen Ulhaq

21

สมอง (***)

นี่เป็นอีกหนึ่งปัญหาที่น่าสนใจเกี่ยวกับตรรกะตามเงื่อนไขที่ฉันได้ทำใน BF

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

ใช้การป้อนข้อความด้วยตัวเลข หากตัวเลขเป็นเลขคู่จะเป็นเอาต์พุต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
คุณสามารถแบ่งการแก้ปัญหาทั้งสองนี้ออกเป็นคำตอบที่ต่างกันได้หรือไม่?
FUZxxl

นั่นไม่ใช่คำตอบทั้งสี่เหรอ?
Joey

ที่จริงทุกตัวในชื่อในMathematicaเป็นตัวพิมพ์ใหญ่เพื่อให้เป็นตลกเป็นลักษณะที่คุณควรใช้IและPiแทนและipi
David Zhang

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;
}

ต้องแน่ใจว่าใช้จำนวนเต็มที่ไม่ได้ลงนาม การล้นจำนวนเต็มที่ลงนามนั้นเป็นพฤติกรรมที่ไม่ได้กำหนดใน C ดังนั้นการปรับให้เหมาะสมอาจทำอะไรแปลก ๆ ถ้าต้องการ
Joey Adams

13

Python (ช้า)

n=1234
while n > 1: n -= 2 #slow way of modulus.
print "eovdedn"[n::2]

1
ใช้งานได้ในเชิงบวก ... ฉันคิดว่าฉันสามารถเพิ่มabs()สายได้ในตอนแรก
st0le

@ Josh: เคล็ดลับที่ปรากฏที่นี่ไม่กี่ครั้งแล้วโดยขณะนี้ :)
โจอี้

เครดิตไปที่ gnibblr :)
st0le

@ โจอี้: ฉันไม่ได้คิดว่ามันเป็นของใหม่ แต่สไตล์ไม่จำเป็นต้องเป็นต้นฉบับ :)
jscs

12

JavaScript

/[02468]$/.test(i)

ให้ผลtrueเป็นเลขคู่ ใช้งานได้กับจำนวนเต็มขนาดพอสมควรเท่านั้น (เช่นไม่ใช่สัญลักษณ์ทางวิทยาศาสตร์เมื่อแปลงเป็นสตริงและไม่มีส่วนที่เป็นเศษส่วน)


2
เพื่อตอบสนองความ "ฟังก์ชั่น" /[02468]$/.testความต้องการของคุณอาจจะเปลี่ยนไปเพียงแค่
Ry-

มันยังไม่ชัดเจนในคำถาม แต่เป็นไปได้ที่ข้อมูลจะไม่เป็นตัวเลขเลย, /[02468]$/.test('I am a fake even number 0'). ในกรณีนี้คุณสามารถทำได้/^[0-9].[02468]$/.test(i)
วิลเลียม

/-?^\d*[02468]$/จะเข้มงวดน้อยกว่า regex ของคุณ คุณจะต้องทำงานมากขึ้นเพื่อให้สามารถทำงานได้อย่างถูกต้องสำหรับหมายเลขที่มีการบันทึกโดยใช้สัญลักษณ์ทางวิทยาศาสตร์
Thomas Eding

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"

และนี่คือสิ่งที่ฉันชอบแม้ว่ามันจะไม่ได้ผล (ตามที่ระบุไว้ในเดือนมีนาคม Ho ด้านล่าง: เพียงเพราะตัวเลขทั้งหมดเป็นผลรวมของสองช่วงเวลาไม่ได้หมายความว่าเลขคี่ทั้งหมดจะไม่ได้)

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"

โซลูชั่นน่ารัก :-)
Joey

2
จริง ๆ แล้วเป็น necro เก่า ๆ แต่คำตอบที่คาดเดาจาก Goldbach ของคุณไม่พิมพ์แม้แต่กับ 9 ใช่ไหม ดูเหมือนว่ากรณีของการยืนยันความผิดพลาดที่เกิดขึ้น
March Ho

ใช่แล้วคุณก็ถูกต้องร้อยเปอร์เซ็นต์ @MarchHo ไข่บนใบหน้าของฉัน
jscs

10

Haskell

แน่นอนว่านี่ไม่ใช่วิธีที่สร้างสรรค์และใช้ความคิดนอกกรอบที่คุณกำลังมองหา แต่ฉันจะโพสต์คำตอบของ Haskell สั้นกว่า GolfScript กี่ครั้ง? มันเป็นความอัปยศที่ไม่ใช่รหัสกอล์ฟ

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

ลักษณะยาวกว่าGolfScriptคำตอบของฉัน
วอร์เรน

2
ฉันหมายถึงบล็อกแรก ( odd) ซึ่งเป็นฟังก์ชั่น builtin ที่ส่งกลับค่า True ถ้าจำนวนเป็นคี่ นั่นเป็นคำตอบที่สมบูรณ์ในตัวของมันเองและสั้นกว่าคำตอบของ GolfScript ปัจจุบัน (ซึ่งในขณะที่เขียนนี่คือ 10 ตัวอักษร แต่ฉันคาดว่ามันจะลงไป) คำถามก็ยังไม่ได้ระบุเล็กน้อยซึ่งเป็นเหตุผลที่ฉันยืนยันว่าoddเพียงพอ ที่อาจเปลี่ยนแปลงได้เช่นกัน

1
พลาดตอบแรกในคำตอบของคุณ :)
วอร์เรน

1
อย่างน้อยที่สุดparityอัลกอริทึมใช้งานได้กับทุกNumอินสแตนซ์ที่เป็นจำนวนเต็ม มันร้อน! evens = [0,2..] >>= \n -> [-n, n]แม้ว่าฉันอาจจะได้ทำ คล้ายกับอัตราต่อรอง
Thomas Eding

7

ใช้คำถามที่มีการอ่านอย่างวิปริตโดยเจตนา "จะกำหนดได้อย่างไรว่าตัวเลขนั้นเป็นเลขคี่หรือคู่" นี่เป็นการใช้งาน C (สมมติboolและtrueมีการกำหนดอย่างเหมาะสม):

bool is_odd_or_even(int n)
{
    return true;
}

คำถามระบุหมายเลขไม่ใช่จำนวนเต็ม จำนวนที่ต้องการ0.5คืนค่าtrueเมื่อไม่ควร
Konrad Borowski

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 .. n -1 จนกระทั่งเหลือน้อยกว่า 2 มันค่อนข้างจะไม่มีประสิทธิภาพที่น่าอัศจรรย์ใจ: O ( n 3 )


แตกต่างอย่างสิ้นเชิง:

Haskell

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

Windows PowerShell

function OddOrEven([long]$n) {
  if (0,2,4,6,8 -contains "$n"[-1]-48) {
    "Even"
  } else {
    "Odd"
  }
}
  1. แปลงเป็นสตริง
  2. เลือกตัวอักษรตัวสุดท้าย (ตัวเลข) (หลักคือ mod 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.

เท่าที่ฉันสามารถบอกได้ว่านี่เป็นรายการ coq แรกของ codegolf

ยิ่งสั้น (59):

Fixpoint even n:=match n with O=>true|S n=>negb(even n)end.

4

ทับทิม

n.odd?

หากคุณต้องการพิมพ์ผลลัพธ์:

f[n] = ->(n){puts n.odd?? 'odd' : 'even'}

ฉันค่อนข้างใช้ ruby ​​ใช้ mod ใน.odd?คำจำกัดความ
MrZander

4

Unlambda

โลกต้องการ Unlambda มากขึ้น

Unlambda มีข้อได้เปรียบนักฆ่าที่นี่: ค่าเริ่มต้น ( ahem ) สำหรับตัวเลขคือตัวเลขของคริสตจักรดังนั้นสิ่งที่จำเป็นต้องมีก็คือการใช้พวกมันกับฟังก์ชั่นไบนารี่ ง่าย!

PS: Markdown และ 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]

ไม่มีประสิทธิภาพโดยเฉพาะอย่างยิ่ง เวลาและหน่วยความจำทั้งคู่เห็นได้ชัด O (n): 32 msec สำหรับ 1,000,000; 2.3 msec สำหรับ 100000; 3.2 usec สำหรับ 100 ทำงานร่วมกับตัวเลขลบ โยนข้อผิดพลาดเป็น 0 เพราะ 0 ไม่ได้เป็นเลขคี่หรือคู่


3
ซีโร่ยังคงแน่นอน ดูเพิ่มเติมที่: en.wikipedia.org/wiki/Parity_of_zero

@jloy: แย่จัง ฉันคิดว่านั่นเป็น "คุณสมบัติไม่ใช่ข้อผิดพลาด" การแก้ไขเพิ่มเติม ...
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และแม้แต่1n


3

MMIX (4 ไบต์)

นี่คือการโกง ฉันไม่ใช้การดำเนินการ mod หรือบิตเล่นซอ มันค่อนข้างที่การทดสอบสำหรับเลขคี่ / คู่นั้นถูกสร้างขึ้น สมมติว่า$3มีจำนวนที่จะทดสอบและผลจะเข้าสู่$2:

ZSEV $2,$3,1

ตั้งค่า$2เป็น1ถ้า$3เป็นเลขคู่และ0หากไม่ใช่ mnemnoric ZSEVหมายถึงzero-set แม้และมีความหมายต่อไปนี้:

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

สำหรับบรรทัดด้านบนให้mmixalสร้างชุดประกอบสี่ไบต์เหล่านี้:

7F 02 03 01

3

โครงการ

นี่เป็นวิธีที่ไม่มีประสิทธิภาพที่สุดที่ฉันรู้

(letrec ([even? (lambda (n)
                 (if (zero? n) "even"
                     (odd? (- n 2))))]
         [odd? (lambda (n)
                 (if (= n 1) "odd"
                     (even? (- n 2))))])
  (even? (read)))




2

หลาม

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

ทดสอบกำลังสองของ i ดังนั้นมันจึงใช้ได้กับจำนวนลบเช่นกัน


2

F #

เรียกรวมกันเพื่อชนะ

ตัวเลข n คือแม้ว่าจะเป็นศูนย์หรือ (n-1) เป็นเลขคี่

ตัวเลข n เป็นเลขคี่ถ้ามันไม่เท่ากับศูนย์และ (n-1) คือเลขคู่

(เพิ่ม abs ในกรณีที่ทุกคนสนใจในความเท่าเทียมกันของตัวเลขติดลบ)

let rec even n = n = 0 || odd (abs n - 1) 
    and odd n = n <> 0 && even (abs n - 1)


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

... แม้ว่าใน Linux / tcsh ฉันต้องหลีกเลี่ยงแบ็กสแลช \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

ไม่ทำงานบน Intel x86 CPUs เนื่องจากยืดหยุ่นในการเข้าถึงข้อมูล


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]

พิมพ์ e ถ้าเป็นเช่นนั้น, o ถ้าเป็นเลขคี่


โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.