X supérieur à 3 avec au moins 2 différences entre X et Y

11

J'essaie de jouer au golf en C ++. Est-il possible de raccourcir cette condition?

X > 3 & X - Y > 1

(En plus de supprimer les espaces, bien sûr.)

Donc, Xc'est au moins 4mais X >= Y + 2.

Xet Ysont des entiers dans l'intervalle [0,5].

J'ai essayé de trouver une formule au niveau du bit mais j'ai échoué.

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
la source
1
@JoeZ. Pour CodeGolf? Pourquoi? Tant que ça marche ...
Cristy
4
@Cristy oui, mais (jusqu'à présent) les questions concernant les conseils sur le golf sont très rares alors que la plupart des questions demandant des conseils ne sont en fait que des questions générales de programmation - qui sont hors sujet. Par conséquent, je peux comprendre pourquoi la première réaction des gens pourrait être, "oh c'est une autre question qui appartient en fait à SO", sans même penser qu'il pourrait s'agir de conseils de golf. J'aimerais en voir plus à l'avenir, et peut-être qu'il y aura un tag pour eux un jour ou deux, et il sera clair immédiatement que vous savez comment utiliser ce site. ;)
Martin Ender
4
S'il s'agit d'entiers compris entre 0 et 5 inclus, vous pouvez faire la même chose avec x*x-y*y>9. C'est le même nombre de caractères, mais vous pourrez peut-être trouver un raccourci / une alternative à cette approche. Juste une autre façon de voir les choses.
Geobits
5
Utilisez Python:3<x>y+1
avall
2
J'ai trouvé beaucoup de solutions avec la priorité d'opérateur de Python, par exemple y+3<2^x, mais la priorité d'opérateur de C est différente. Je parie qu'il existe une solution à 7 caractères, il suffit de modifier mon script pour gérer la priorité de l'opérateur C à la place
Claudiu

Réponses:

11

Après avoir forcé brutalement toutes les combinaisons utiles de symboles de moins de 9 caractères, j'ai trouvé qu'il n'y avait pas de solution plus petite que x>3&x-y>1.

Pour le plaisir, voici quelques solutions géniales à 9 caractères trouvées par le forceur brut:

-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

Le forçage brutal a été effectué en Python, créant des arbres de syntaxe descendants où aucun enfant ne peut avoir un opérateur de priorité inférieure à son parent selon les règles de C. Pour réduire les possibilités, je n'autorisais que des littéraux à un chiffre, et aucun opérateur binaire ne peut avoir deux enfants constants. Je ne pouvais pas penser à une solution qui aurait un littéral à deux chiffres, ou une qui construit une constante à l'aide d'un opérateur binaire. Ensuite, chaque expression a été évaluée pour [0, 5] et si elle correspond, elle est imprimée.

orlp
la source
J'aime vraiment x*x-y*y>9. Peut-être devriez-vous également essayer des constantes à plusieurs chiffres? (aussi, parenthèses)
John Dvorak
@JanDvorak moi aussi. Il exprime bien la logique de la "distance entre x et y". Je pense que si vous tracez cela dans un graphique, cela deviendrait plus évident.
sehe
@JanDvorak Je ne pense pas que les parenthèses puissent jamais être une solution plus petite. Une solution plus petite peut comprendre un maximum de 8 caractères, dont 2 doivent être xyet 2 doivent être les parenthèses, ne laissant que 4 caractères de logique. Je vais essayer d'exécuter le forceur brut avec des constantes à 2 chiffres, mais je ne pense vraiment pas que cela donnera un résultat.
orlp
Que diriez-vous, x, y, une constante, une paire de parenthèses et deux opérateurs?
John Dvorak
@JanDvorak Assommez-vous, (a#b)$cc'est le format. Sur abcdeux doivent être xet y, laissant 3 emplacements possibles pour [0-9xy], et un seul flip de xy. Seuls les opérateurs intéressants le sont +-*/&|^<>, donc 9 possibilités. Ainsi, les possibilités totales sont inférieures à 3 * 12 * 2 * 9 * 9 <5832.
orlp
0

En réponse aux (super) golfs orlp:

La correction doit venir en premier

  • La plupart d'entre eux se décomposent pour certains types entiers. Cela inclut la version de l'OP
  • Fait intéressant , ils font le travail pour int16_t- donc il y a l'hypothèse. Probablement, les décalages de bits auraient besoin de +16 pour les entiers 32 bits (c'est à peu près partout ces jours-ci). Cela en fait un personnage plus grand ...

La seule façon "correcte" de l'écrire, c'est l'OMI (x>3) && (x > y+1), qui peut être jouée jusqu'à x>3&x>y+1(9 caractères).

(Vous devez vraiment prendre en compte la possibilité de types non signés (plus grands), d'autant plus que unsigned-ness est "contagieux" dans les expressions C ++. Je suppose que "réparer" qu'avec les static_cast<>s appropriés irait à l'encontre du but ...)

METTRE À JOUR

Avec les tests suivants, j'ai pu déterminer quelles expressions fonctionnent réellement de manière fiable:

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

Sortie sur coliru, ici pour référence:

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

Résumé

Étant donné qu'il s'agit du «coût» de la répétition des éléments de code source, vous pouvez utiliser une table de recherche. Vous pouvez "masquer" la table de recherche, il est donc possible

 LUT[x][y]

ou 

 LUT[x*6+y]

Bien sûr, vous pouvez être pédant et obtus et renommer la LUT

 L[x][y]

Donc ma "version" est ... 7 caractères . (Ou faites si c'est une fonction et L(x,y)est encore plus courte).

Ou, plus important encore: correct, testable et maintenable.

sehe
la source
Ajout d'un "vrai" golf. Pas plus court que 9 caractères, mais le premier à être correct!
sehe