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
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.