X lebih besar dari 3 dengan setidaknya 2 perbedaan antara X dan Y

11

Saya mencoba untuk menurunkan C ++. Apakah mungkin membuat kondisi ini lebih pendek?

X > 3 & X - Y > 1

(Selain menghapus spasi putih, tentu saja.)

Jadi, Xsetidaknya 4tapi X >= Y + 2.

Xdan Ybilangan bulat dalam interval [0,5].

Saya telah mencoba menemukan beberapa formula bitwise tetapi gagal.

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 Cristy
sumber
1
@ Joz. Untuk CodeGolf? Mengapa? Selama ini berhasil ...
Cristy
4
@ Christy ya benar, tapi (sejauh ini) pertanyaan yang menanyakan tentang saran golf sangat jarang, sedangkan sebagian besar pertanyaan yang meminta nasihat memang hanya pertanyaan pemrograman umum - yang di luar topik. Oleh karena itu, saya bisa mengerti mengapa reaksi pertama orang mungkin, "oh itu pertanyaan lain yang sebenarnya milik SO", bahkan tanpa berpikir itu bisa mengenai saran golf. Saya sebenarnya ingin melihat lebih banyak dari ini di masa depan, dan mungkin akan ada tag untuk mereka suatu hari nanti, dan akan segera jelas bahwa Anda tahu cara menggunakan situs ini. ;)
Martin Ender
4
Jika mereka bilangan bulat antara 0..5 inklusif, Anda dapat melakukan hal yang sama dengannya x*x-y*y>9. Itu jumlah karakter yang sama, tetapi Anda mungkin dapat menemukan jalan pintas / alternatif untuk pendekatan itu. Hanya cara lain untuk melihatnya.
Geobit
5
Gunakan Python:3<x>y+1
avall
2
Saya menemukan banyak solusi dengan prioritas operator Python, misalnya y+3<2^x, tetapi prioritas operator C berbeda. Saya yakin ada solusi 7-char, hanya perlu memodifikasi skrip saya untuk berurusan dengan prioritas operator C
Claudiu

Jawaban:

11

Setelah dengan kasar memaksa setiap kombinasi simbol di bawah 9 karakter, saya menemukan tidak ada solusi yang lebih kecil dari itu x>3&x-y>1.

Untuk bersenang-senang, inilah beberapa solusi 9 karakter funky yang ditemukan oleh brute forcer:

-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

Pemaksaan brutal dilakukan dengan Python, membangun pohon sintaksis top-down di mana tidak ada anak yang memiliki operator dengan prioritas lebih rendah dari induknya menurut aturan C. Untuk mengurangi kemungkinan saya hanya mengizinkan satu digit literal, dan tidak ada operator biner yang dapat memiliki dua anak tetap. Saya tidak mungkin memikirkan solusi apa pun yang akan memiliki dua digit literal, atau yang membangun konstanta menggunakan operator biner. Kemudian setiap ekspresi dievaluasi untuk [0, 5] dan jika cocok maka akan dicetak.

orlp
sumber
Saya sangat suka x*x-y*y>9. Mungkin Anda harus mencoba konstanta multi-digit juga? (juga, tanda kurung)
John Dvorak
@ JanDvorak saya juga. Ini mengekspresikan dengan baik logika "jarak antara x dan y". Saya pikir jika Anda merencanakan ini dalam grafik, itu akan menjadi lebih jelas.
sehe
@ JanDvorak Saya tidak berpikir kurung bisa menjadi solusi yang lebih kecil. Solusi yang lebih kecil dapat berupa maksimal 8 karakter, yang 2 harus xy, dan 2 harus menjadi kurung, hanya menyisakan 4 karakter logika. Saya akan mencoba menjalankan forcer kasar dengan konstanta 2 digit, tapi saya benar-benar tidak berpikir itu akan memberikan hasil.
orlp
Bagaimana dengan, x, y, sebuah konstanta, sepasang tanda kurung dan dua operator?
John Dvorak
@JanDvorak Knock out, (a#b)$cadalah formatnya. Dari abcdua harus xdan y, meninggalkan 3 lokasi yang mungkin untuk [0-9xy], dan hanya satu flip xy. Hanya operator yang menarik +-*/&|^<>, jadi ada 9 kemungkinan. Dengan demikian total kemungkinan kurang dari 3 * 12 * 2 * 9 * 9 <5832.
orlp
0

Menanggapi golf (luar biasa) oleh orlp:

Kebenaran harus didahulukan

  • Sebagian besar rusak untuk beberapa tipe integer. Ini termasuk versi dari OP
  • Menariknya mereka lakukan bekerja untuk int16_t- sehingga ada asumsi. Mungkin pergeseran bit perlu +16 untuk 32 bit int (itu cukup banyak di mana-mana hari ini). Ini membuat mereka menjadi karakter yang lebih besar ...

Satu-satunya cara "benar" untuk menulisnya, IMO adalah (x>3) && (x > y+1), yang dapat di-golf hingga x>3&x>y+1(9 karakter).

(Anda benar-benar perlu mempertimbangkan kemungkinan (lebih besar) tipe unsigned menjadi pertimbangan, terutama karena unsigned-ness adalah "menular" dalam ekspresi C ++. Saya kira "memperbaiki" bahwa dengan static_cast<>s yang sesuai agak akan mengalahkan tujuan ...)

MEMPERBARUI

Dengan tes-tes berikut, saya sudah bisa mengetahui ekspresi mana yang benar-benar berfungsi dengan baik:

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

Output pada coliru, di sini untuk referensi:

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

Ringkasan

Karena ini tentang "biaya" elemen elemen kode berulang, Anda mungkin menggunakan tabel pencarian. Anda bisa "menyembunyikan" tabel pencarian, jadi itu baik

 LUT[x][y]

atau 

 LUT[x*6+y]

Tentu saja Anda bisa bertele-tele dan tumpul dan mengganti nama LUT

 L[x][y]

Jadi "versi" saya adalah ... 7 karakter . (Atau buat jika fungsi dan L(x,y)bahkan lebih pendek).

Atau, yang lebih penting: benar, dapat diuji dan dipelihara.

lihat
sumber
Menambahkan golf "benar". Tidak lebih pendek dari 9 karakter, tetapi yang pertama benar!
sehe