X와 Y의 차이가 2 이상인 3보다 큰 X

C ++을 골프 다운하려고합니다. 이 조건을 더 짧게 만들 수 있습니까?

X > 3 & X - Y > 1

(물론 공백을 제거하는 것을 제외하고)

그래서, X적어도입니다 4만 X >= Y + 2.

X그리고 Y에서 [0,5] 구간에서의 정수이다.

비트 단위 수식을 찾으려고했지만 실패했습니다.

code-golf number tips c++ code-golf popularity-contest obfuscation code-golf c code-golf board-game hexagonal-grid code-golf game grid code-golf number permutations popularity-contest math graphical-output number-theory king-of-the-hill code-challenge compression code-challenge fastest-code code-golf math ascii-art animation code-golf popularity-contest generation counting fastest-code fastest-code popularity-contest image-processing king-of-the-hill code-golf conversion binary-tree code-golf math number rational-numbers division code-golf restricted-source hashing atomic-code-golf logic-gates code-golf function code-challenge puzzle-solver ai-player test-battery popularity-contest music compression code-golf number stack atomic-code-golf logic-gates ascii-art popularity-contest code-golf date grid code-challenge game code-golf parsing code-golf math geometry sequence popularity-contest code-trolling code-golf string restricted-source code-golf quine king-of-the-hill code-golf math code-golf simulation code-golf ascii-art code-challenge sorting optimization

— 크리스티
소스

@JoeZ. CodeGolf의 경우? 왜? 그것이 작동하는 한 ...

— Cristy

@Cristy는 그렇습니다. 그러나 골프 조언에 관해 묻는 (지금까지) 질문은 매우 드물지만 조언을 요청하는 대부분의 질문은 실제로 일반적인 프로그래밍 질문입니다. 따라서 나는 사람들의 첫 반응이 왜 골프 조언에 관한 것인지 생각조차하지 않고 "아, 이것이 실제로 SO에 속하는 또 다른 질문"인 이유를 이해할 수있다. 나는 미래에 더 많은 이들의 볼 것 사실처럼, 어쩌면 그들에게 어떤 일 정도 태그있을거야, 그리고 있음을 바로 알 수있는 당신은 이 사이트를 사용하는 방법을 알고있다. ;)

— Martin Ender 2014 년

그것들이 0..5 사이의 정수라면, 당신도 같은 일을 할 수 있습니다 x*x-y*y>9. 같은 양의 문자이지만 해당 접근 방식에 대한 바로 가기 / 대체를 찾을 수 있습니다. 그것을 보는 또 다른 방법.

— Geobits

파이썬 사용 :3<x>y+1

— avall

예를 들어 Python의 연산자 우선 순위에 대한 많은 솔루션을 찾았 y+3<2^x지만 C의 연산자 우선 순위는 다릅니다. 나는 7 문자 솔루션이 있다고

— 확신합니다.

답변:

9 자 미만의 모든 유용한 기호 조합을 강제로 사용한 후 나는보다 작은 해결책이 없다는 것을 알았습니다 x>3&x-y>1.

재미를 위해 무차별 대변인이 발견 한 몇 가지 펑키 9 캐릭터 솔루션이 있습니다.

-x<~y>4>x
~y+x>2>>y
x*x-y*y>9
~y>x/~3*x
-3>>y>y-x
~y+x<<y>2

C의 규칙에 따라 자식보다 부모보다 우선 순위가 낮은 연산자를 가질 수없는 하향식 구문 트리를 작성하여 무차별 강제 실행이 Python에서 수행되었습니다. 가능성을 줄이기 위해 한 자리 리터럴 만 허용했으며 바이너리 연산자에는 두 개의 상수 자식이 없을 수 있습니다. 두 자리 리터럴을 가진 솔루션이나 이진 연산자를 사용하여 상수를 만드는 솔루션을 생각할 수 없었습니다. 그런 다음 [0, 5]에 대해 각 표현식을 평가 한 후 일치하면 인쇄됩니다.

— 오르프
소스

정말 좋아 x*x-y*y>9합니다. 아마도 여러 자리 상수를 시도해야합니까? (또한 괄호)

— John Dvorak

@JanDvorak도. "x와 y 사이의 거리"의 논리를 잘 표현합니다. 차트에 이것을 작성하면 더 분명해질 것입니다.

— sehe

@ JanDvorak 괄호가 더 작은 솔루션 일 수 있다고 생각하지 않습니다. 더 작은 솔루션은 최대 8 자일 수 있으며 그 중 2는이어야 xy하고 2는 괄호 여야하며 논리는 4 자만 남습니다. 나는 2 자리 상수로 무차별 대치를 실행하려고 시도하지만 실제로 결과를 줄 것이라고는 생각하지 않습니다.

— orlp

x, y, 상수, 괄호 쌍과 두 연산자는 어떻습니까?

— John Dvorak

@JanDvorak 자신을 기절 (a#b)$c형식입니다. 가운데 abc두이어야 x하고 y3 개 개의 가능한 위치두고 [0-9xy], 그리고 오직 하나의 플립 xy. 흥미로운 연산자 만 +-*/&|^<>가능하므로 9 가지 가능성이 있습니다. 따라서 총 가능성은 3 * 12 * 2 * 9 * 9 <5832 미만입니다.

— orlp

에 의해 (굉장한) 골프에 대한 답변 orlp:

정확성이 먼저 나와야합니다

이들 중 대부분은 일부 정수 유형에 대해 분류됩니다. 여기에는 OP의 버전이 포함됩니다
흥미롭게도 그들은 수행 을 위해 일을 int16_t- 그래서 가정이있다. 아마도 비트 시프트는 32 비트 int에 대해 +16이어야합니다 (요즘 거의 모든 곳에서). 이것은 그들을 더 큰 캐릭터로 만듭니다 ...

그것을 작성하는 유일한 "올바른"방법 인 IMO는 (9 문자) (x>3) && (x > y+1)까지 내려갈 수 있습니다 x>3&x>y+1.

(특히 C ++ 표현식에서 서명되지 않은 것이 전염성이 있기 때문에 서명되지 않은 (더 큰) 서명되지 않은 유형의 가능성을 고려해야합니다. 적절한 static_cast<>s를 사용하면 목적이 다소 어길 것이라고 "고정"이라고 가정합니다. )

최신 정보

다음 테스트를 통해 실제로 어떤 표현식 이 안정적으로 작동 하는지 확인할 수있었습니다 .

Live On Coliru

#define REPORT(caption, expr) do {\
    do_report(caption, [](T x, T y) -> bool { return (expr); }, #expr); } while (false)

template <typename T> struct driver {
    static void run() {
        std::cout << "\n" << __PRETTY_FUNCTION__ << "\n";

        // the only two correct implementations:
        REPORT("MASTER"  , (x>3) && (x>y+1));
        REPORT("GOLF"    , x>3&x>y+1);
        REPORT("lookup"  , "000000000000000000000000111000111100"[x*6+y]-'0');

        // failing sometimes:
        REPORT("question", (x>3)&(x-y>1));
        REPORT("orlp0"   , x>3&x-y>1);
        REPORT("orlp2"   , ~y+x>2>>y);
        REPORT("orlp3"   , x*x-y*y>9);
        REPORT("orlp4"   , ~y>x/~3*x);
        REPORT("orlp5"   , -3>>y>y-x);
        REPORT("orlp6"   , ~y+x<<y>2);

        // failing always
        REPORT("orlp1"   , -x<~y>4>x);
    }
private:
    static void do_report(std::string const& caption, bool (*f)(T,T), char const* expression) {
        std::string r;
        for (T x = 0; x < 6; ++x) for (T y = 0; y < 6; ++y) r += f(x, y)?'1':'0';
        bool const correct = "000000000000000000000000111000111100" == r;
        std::cout << (correct?"OK\t":"ERR\t") << r << "\t" << caption << "\t" << expression << "\n";
    }
};

int main() {
    driver<int8_t>::run();
    driver<int16_t>::run();
    driver<int32_t>::run();
    driver<int64_t>::run();

    driver<uint8_t>::run();
    driver<uint16_t>::run();
    driver<uint32_t>::run();
    driver<uint64_t>::run();
}

콜리 루에 대한 출력

static void driver<T>::run() [with T = signed char]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = short int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = long int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = unsigned char]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = short unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
ERR 000000000000000000000000111001111100    question    (x>3)&(x-y>1)
ERR 000000000000000000000000111001111100    orlp0   x>3&x-y>1
ERR 111111011111001111000111111011111101    orlp2   ~y+x>2>>y
ERR 011111001111000111000011111001111100    orlp3   x*x-y*y>9
ERR 111111111111111111111111111111111111    orlp4   ~y>x/~3*x
ERR 111111011111001111000111111011111101    orlp5   -3>>y>y-x
ERR 111111011111001111000111111011111101    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = long unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
ERR 000000000000000000000000111001111100    question    (x>3)&(x-y>1)
ERR 000000000000000000000000111001111100    orlp0   x>3&x-y>1
ERR 111111011111001111000111111011111101    orlp2   ~y+x>2>>y
ERR 011111001111000111000011111001111100    orlp3   x*x-y*y>9
ERR 111111111111111111111111111111111111    orlp4   ~y>x/~3*x
ERR 111111011111001111000111111011111101    orlp5   -3>>y>y-x
ERR 111111011111001111000111111011111101    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

요약

반복되는 소스 코드 요소의 "비용"에 대해서는 룩업 테이블을 사용할 수 있습니다. 찾아보기 테이블을 "숨길"수 있습니다.

 LUT[x][y]

또는

 LUT[x*6+y]

물론 당신은 pedantic하고 둔감하고 LUT의 이름을 바꿀 수 있습니다

 L[x][y]

내 "버전"은 ... 7 자 입니다. (또는 기능이 있고 L(x,y)더 짧으면 만드십시오 ).

또는 더 중요한 것은 정확하고 테스트 가능하며 유지 관리가 가능하다는 것입니다.

— sehe
소스

"진정한"골프를 추가했습니다. 9 자 이상은 아니지만 첫 번째 문자는 정확합니다!

— sehe