숫자 또는 비트 단위 연산없이 숫자가 홀수인지 또는 짝수인지 확인하는 방법은 무엇입니까?

이 과제는 매우 비효율적이지만 창의적인 솔루션을 위해 상자 밖에서 생각할 수있는 능력에 도전합니다.

편집 :

함수를 작성하십시오. 또한 정규 표현식은 재미있는 응답이지만 함수는 유효한 숫자를 받아 들여야 합니다 .

배경 :이 질문은 가장 초기의 프로그래밍 시절에 기인합니다. 수업 첫날 숙제는 '홀수'또는 '짝수'로 인쇄 된 간단한 프로그램을 작성하는 것이 었습니다. 내가 가진 말괄량이이기 때문에 나는 그것을%결정하는 데 사용하는 방법을 단순히 보여 주었던 수업에 대한 책을 읽지 않았다. 나는 반 시간을 내 방에서 앞뒤로 돌리면서 이것을하는 방법을 생각하려고 노력했으며 강의에서 숫자가 하나의 기본 유형에서 다른 유형으로 캐스팅 될 때 정밀도를 잃고 정확하게 얻을 수 있다는 것을 기억했습니다. 따라서 숫자를 취해서 2로 나눈 다음 다시 원래 숫자와 같지 않으면 숫자가 홀수임을 알 수 있습니다.

다음 날, 강사가 우리 프로그램을 평가하는 동안, 나는 그것이 비효율적이지만 문제를 해결하는 가장 독창적이라고 생각했다.

대부분의 프로그래밍 언어에서 나누기는 정수에 대한 몫을 반환합니다. 간단히 확인할 수 있습니다

(i/2)*2==i

파이썬

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

Brainf *** (179)

이것은 내가 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.

매스 매 티카

SawtoothWave[x / 2] == 0
Exp[I Pi x] - 1 == 0
Sin[5 x / Pi] == 0

씨

유한 한 크기의 정수가 주어지면 짝수에 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;
}

파이썬 (느리게)

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

자바 스크립트

/[02468]$/.test(i)

true짝수를 산출 합니다. 이것은 합리적인 크기의 정수에서만 작동합니다 (예 : 문자열로 변환되고 소수 부분이없는 경우 과학적 표기법이 아님).

파이썬

점수 기준이 무엇인지 잘 모르겠 기 때문에 여기에 오락을 위해 마련한 여러 가지 솔루션이 있습니다. 대부분은 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"

불행히도 작동하지 않지만 이것은 내가 가장 좋아하는 것입니다 (아래의 March 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"

하스켈

물론 이것은 당신이 찾고있는 창의적이고 독창적 인 솔루션입니다.하지만 실제로 몇 번이나 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

"숫자가 홀수인지 짝수인지 결정하는 방법"이라는 질문을 고의적으로 왜곡하여 사용하는 C 구현 은 다음 bool과 true같습니다 (가정 하고 적절하게 정의 됨).

bool is_odd_or_even(int n)
{
    return true;
}

무작위 알고리즘은 아직 없나요?

씨

#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 ³ ).

완전히 다른 :

하스켈

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:)의 푸리에 변환은 실제이고 홀수 함수의 푸리에 변환은 가상 이라는 사실을 사용합니다 .

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인지 확인하십시오.

요청에 따라 비트 단위 연산자, 모듈러스 없음.

코크, 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.

내가 알 수있는 한 이것은 codegolf의 첫 번째 coq 항목입니다.

더 짧음 (59) :

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

루비

n.odd?

결과를 인쇄하려면 다음을 수행하십시오.

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

언 람다

세상에는 더 많은 Unlambda가 필요합니다.

Unlambda는 여기서 가장 큰 장점을 가지고 있습니다. 숫자에 대한 기본 ( ahem ) 표현은 교회 숫자이므로, 필요한 것은 바이너리가 아닌 함수 2 진수에 적용하면됩니다. 쉬운!

추신 : 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

골프 스크립트

~,2/),1=\;

파이썬

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

이전 버전과 비슷한 성능. 지금은 0으로 작동합니다.

잘못된 이전 버전 :

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

특별히 효율적이지 않습니다. 시간과 기억 둘 다 분명히 O (n) : 1,000,000의 경우 32msec; 100000 동안 2.3 msec; 3.2 usec for 100. 음수와 함께 작동합니다. 0은 짝수도 홀수도 아니므로 0에 대한 오류를 발생시킵니다.

프랙 트란

[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))

인 2ODD에 대한 n그리고 1심지어 위해 n.

MMIX (4 바이트)

이것은 일종의 부정 행위입니다. 나는 mod와 bit fiddling 연산을 사용하지 않습니다. 오히려 홀수 / 짝수에 대한 테스트가 내장되어 있습니다. $3테스트 할 숫자 가 포함되어 있고 결과는 다음과 $2같습니다.

ZSEV $2,$3,1

짝수 이면 짝수로 설정 $2합니다 . 니 모노 릭 은 제로 세트를 의미하며 다음과 같은 의미를 갖습니다.1$30ZSEV

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

위의 행에 mmixal대해 다음 4 바이트의 어셈블리를 생성합니다.

7F 02 03 01

계획

이것이 내가 아는 가장 비효율적 인 솔루션입니다.

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

펄

는 어때

use Math::Trig;
print(cos(pi*@ARGV[0])>0?"even":"odd")

자바 스크립트, 36

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

true짝수 인 false경우 반환 합니다 .

펄

$n x '0' =~ /^(00)*$/

파이썬

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

i의 제곱을 테스트하므로 음수에도 적용됩니다.

에프#

승리를위한 상호 재귀.

숫자 n은 0이거나 (n-1)이 홀수 일지라도 짝수입니다.

숫자 n이 0이 아니고 (n-1)이 짝수이면 홀수입니다.

(음수의 패리티에 관심이있는 사람을 위해 추가 된 복근)

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

클로저

  (defmacro even?[n]
  `(= 1 ~(concat (list *) (repeat n -1))))

비트 단위 연산의 자격은 무엇입니까? 후드 아래에서 2 로의 정수 나누기는 비트 시프트로 구현 될 가능성이 높습니다.

비트 시프트가 없다고 가정 :

C / C ++

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

편집 일부 괄호를 놓치면 궁극적으로 덜 쉬워 지도록 이동을 제거하도록 변경되었습니다. 다음을 사용하여 이것을 테스트 할 수 있습니다 (* nix).

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

... 리눅스 / tcsh에서는 \n작은 따옴표로도 역 슬래시를 피해야했습니다 . 리틀 앤 빅 엔디안에서 테스트했는데 둘 다 올바르게 작동합니다. 또한 나는 이것을 손으로 복사했다. 내가 게시하는 컴퓨터에는 컴파일러가 없으므로 실수가있을 수 있습니다.

x86 asm

            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

또는 shift & compare 작업도 다음과 같이 수행 할 수 있습니다.

            sar al,1            # signed integer division by 2 on least-significant byte
            jc  odd_label       # jump if carry flag is set

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 CPU는 데이터 액세스에 대해 더 유연하기 때문에 작동하지 않습니다.

파이썬

나는 내가 생각할 수있는 가장 추악하고 가장 혼란스러운 솔루션을 시도하기로 결정했습니다.

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를 인쇄합니다.

큐

x <2까지 2를 계속 뺀 다음 bool로 변환

{1b$-[;2]/[2<=;abs x]}