X 3'ten büyük, X ve Y arasında en az 2 fark var

11

Bazı C ++ aşağı golf çalışıyorum. Bu durumu kısaltmak mümkün mü?

X > 3 & X - Y > 1

(Tabii ki boşlukları kaldırmanın dışında.)

Yani, Xen azından 4ama X >= Y + 2.

Xve Y[0,5] aralığında tamsayılardır.

Bazı bitsel formül bulmaya çalıştım ama başarısız oldu.

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
kaynak
1
@JoeZ. CodeGolf için mi? Neden? Çalıştığı sürece ...
— Cristy
4
@Cristy evet onlar, ama (şimdiye kadar) golf tavsiye hakkında sorular çok nadir iken, tavsiye isteyen çoğu soru sadece genel programlama soruları - konu dışı. Bu nedenle, insanların ilk tepkisinin neden olabileceğini anlayabiliyorum, “oh bu aslında SO'ya ait olan başka bir soru”, hatta golf tavsiyesi hakkında olabileceğini düşünmeden. Ben gelecekte daha Bunlardan görmek istiyorum aslında gibi ve belki onlar için bir gün ya da öylesine bir etiket orada olacağım ve o hemen belli olacaktır Eğer bu siteyi nasıl kullanacağımı biliyorum. ;)
— Martin Ender
4
Eğer 0..5 dahil tamsayılarsa, aynı şeyi yapabilirsiniz x*x-y*y>9. Aynı miktarda karakter olabilir, ancak bu yaklaşıma bir kısayol / alternatif bulabilirsiniz. Sadece bakmanın başka bir yolu.
— Geobits
5
Python kullanın:3<x>y+1
— avall
2
Python'un operatör önceliği ile birçok çözüm buldum, örneğin y+3<2^xC'nin operatör önceliği farklı. Bahse girerim 7 karakterlik bir çözüm var, bunun yerine C operatörünün önceliği ile başa çıkmak için betiğimi değiştirmeniz gerekiyor
— Claudiu

Yanıtlar:

11

9 karakterin altındaki her yararlı sembol kombinasyonunu kaba zorladıktan sonra, daha küçük bir çözüm bulamadım x>3&x-y>1.

Eğlenmek için kaba korkutucu bulunan bazı korkak 9 karakter çözümleri:

-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

Kaba zorlama, hiçbir çocuğun C kurallarına göre ebeveyninden daha düşük bir operatöre sahip olmadığı yukarıdan aşağıya sözdizimi ağaçları oluşturan Python'da yapıldı. Olasılıkları azaltmak için sadece tek haneli değişimlere izin verdim ve hiçbir ikili operatörün iki sabit çocuğu olamaz. İki basamaklı bir değişmez veya ikili bir operatör kullanarak sabit oluşturan bir çözüm düşünemedim. Daha sonra her ifade [0, 5] için değerlendirildi ve eşleşirse yazdırılır.

— orlp
kaynak
Gerçekten beğendim x*x-y*y>9. Belki de çok basamaklı sabitleri denemelisiniz? (ayrıca, parantez)
— John Dvorak
@JanDvorak da beni. "X ve y arasındaki mesafe" mantığını iyi ifade eder. Bence bunu bir grafikte çizerseniz, daha açık olur.
— 15'te
@JanDvorak Parantezlerin daha küçük bir çözüm olabileceğini düşünmüyorum. Daha küçük bir çözüm, en fazla 8 karakter olabilir, bunlardan 2'si xyve 2'si parantez olmalıdır ve yalnızca 4 karakter mantığı bırakır. Brute forcer'ı 2 basamaklı sabitlerle çalıştırmayı deneyeceğim, ama gerçekten bir sonuç vereceğini düşünmüyorum.
— orlp
X, y, sabiti, bir çift parantez ve iki operatöre ne dersiniz?
— John Dvorak
@ JanDvorak Knock out, (a#b)$cbiçimidir. İkisinden biri abcolmak xve y3 olası yerleri bırakarak [0-9xy]ve sadece bir flip xy. Sadece ilginç operatörler +-*/&|^<>, bu yüzden 9 olasılık. Böylece toplam olasılıklar 3 * 12 * 2 * 9 * 9 <5832'den azdır.
— orlp
0

(Harika) golflere yanıt olarak orlp:

Doğruluk önce gelmelidir

  • Bunların çoğu bazı tamsayı türleri için parçalanır. Bu, OP'nin sürümünü içerir
  • İlginçtir, onlar için çalışırlar int16_t- bu yüzden varsayım vardır. Muhtemelen bit kaymaları 32 bit ints için +16'ya ihtiyaç duyacaktır (bu günlerde hemen hemen her yerde). Bu onları bir karakter daha büyük yapar ...

(x>3) && (x > y+1)Yazmanın tek "doğru" yolu IMO'dur x>3&x>y+1(9 karakter).

(Gerçekten imzasız-lık C ++ ifadelerde "bulaşıcı" olduğunu, özellikle de göz önüne (büyük) imzasız türleri olasılığını almak gerekir. Ben uygun olan bu "tespit" varsayalım static_cast<>s tür amacı yenmek ...)

GÜNCELLEME

Aşağıdaki testlerle hangi ifadelerin gerçekten güvenilir bir şekilde çalıştığını anlayabildim :

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

Coliru çıktı, burada referans için:

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

özet

Bu, kaynak kod öğelerini tekrarlamanın "maliyeti" hakkında olduğundan, bir arama tablosu kullanabilirsiniz. Arama tablosunu "gizleyebilirsiniz", bu nedenle

 LUT[x][y]

veya 

 LUT[x*6+y]

Tabii ki bilgiçlik dolu ve geniş olabilir ve LUT'u yeniden adlandırabilirsiniz

 L[x][y]

Yani "versiyonum" ... 7 karakter . (Veya bir işlev yaparsanız ve L(x,y)hatta daha kısa).

Veya daha da önemlisi: doğru, test edilebilir ve bakımı yapılabilir.

— sehe
kaynak
"Gerçek" bir golf eklendi. 9 karakterden daha kısa değil, ancak ilk karakter doğru!
— 15'te selam
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.