X mayor que 3 con al menos 2 diferencias entre X e Y

11

Estoy tratando de jugar golf en C ++. ¿Es posible acortar esta condición?

X > 3 & X - Y > 1

(Además de eliminar espacios en blanco, por supuesto).

Entonces, Xes al menos 4pero X >= Y + 2.

Xy Yson enteros en el intervalo [0,5].

He tratado de encontrar alguna fórmula bit a bit pero fallé.

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
fuente
1
@JoeZ. ¿Para CodeGolf? ¿Por qué? Mientras funcione ...
— Cristy
44
@Cristy sí, pero (hasta ahora) las preguntas sobre consejos de golf son muy raras, mientras que la mayoría de las preguntas que piden consejos son solo preguntas generales de programación, que están fuera de tema. Por lo tanto, puedo entender por qué la primera reacción de las personas podría ser, "oh, esa es otra pregunta que realmente pertenece a SO", sin siquiera pensar que podría tratarse de consejos de golf. Yo realmente como para ver más de estos en el futuro, y tal vez habrá una etiqueta para ellos un día o así, y quedará claro inmediatamente que usted sabe cómo utilizar este sitio. ;)
— Martin Ender
44
Si son enteros entre 0..5 inclusive, puede hacer lo mismo con x*x-y*y>9. Es la misma cantidad de caracteres, pero es posible que pueda encontrar un atajo / alternativa a ese enfoque. Solo otra forma de verlo.
— Geobits
55
El uso de Python:3<x>y+1
— Avall
2
Encontré muchas soluciones con la precedencia del operador de Python, por ejemplo y+3<2^x, pero la precedencia del operador de C es diferente. Apuesto a que hay una solución de 7 caracteres, solo tengo que modificar mi script para lidiar con la precedencia del operador C
— Claudiu

Respuestas:

11

Después de forzar de forma bruta cada combinación útil de símbolos de menos de 9 caracteres, descubrí que no hay una solución más pequeña que x>3&x-y>1.

Por diversión, aquí hay algunas soluciones funky de 9 personajes que encontró el forzador bruto:

-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

El forzamiento bruto se realizó en Python, construyendo árboles de sintaxis de arriba hacia abajo donde ningún niño puede tener un operador con una prioridad inferior a su padre de acuerdo con las reglas de C. Para reducir las posibilidades, solo permití literales de un solo dígito, y ningún operador binario puede tener dos hijos constantes. No podría pensar en ninguna solución que tuviera un literal de dos dígitos, o una que construya una constante usando un operador binario. Luego, cada expresión se evaluó para [0, 5] y si coincide se imprime.

— orlp
fuente
Me gusta mucho x*x-y*y>9. ¿Quizás deberías probar también las constantes de varios dígitos? (también, paréntesis)
— John Dvorak
@ JanDvorak yo también. Expresa bien la lógica de "distancia entre x e y". Creo que si trazas esto en un gráfico, sería más obvio.
— sehe
@ JanDvorak No creo que los paréntesis puedan ser una solución más pequeña. Una solución más pequeña puede tener un máximo de 8 caracteres, de los cuales 2 deben ser xyy 2 deben ser paréntesis, dejando solo 4 caracteres de lógica. Intentaré ejecutar el forzador bruto con constantes de 2 dígitos, pero realmente no creo que dé un resultado.
— orlp
¿Qué tal, x, y, una constante, un par de paréntesis y dos operadores?
— John Dvorak
@ JanDvorak Knock out, (a#b)$ces el formato. De abcdos deben ser xy y, dejando 3 ubicaciones posibles para [0-9xy], y solo una vuelta de xy. Solo los operadores interesantes son +-*/&|^<>, entonces 9 posibilidades. Por lo tanto, las posibilidades totales son inferiores a 3 * 12 * 2 * 9 * 9 <5832.
— orlp
0

En respuesta a los (impresionantes) campos de golf por orlp:

La corrección debe ser lo primero

  • La mayoría de estos se descomponen para algunos tipos enteros. Esto incluye la versión del OP
  • Es interesante que hacer el trabajo de int16_t- por lo que no es el supuesto. Probablemente los cambios de bits necesitarían +16 para entradas de 32 bits (eso es prácticamente en todas partes en estos días). Esto los convierte en un personaje más grande ...

La única forma "correcta" de escribirlo, IMO es (x>3) && (x > y+1), que puede reducirse a x>3&x>y+1(9 caracteres).

(Realmente debe tener en cuenta la posibilidad de tipos sin signo (más grandes), especialmente porque la falta de firma es "contagiosa" en las expresiones de C ++. Supongo que "arreglar" eso con los static_cast<>s apropiados sería un poco frustrante para el propósito ...)

ACTUALIZAR

Con las siguientes pruebas he podido averiguar qué expresiones funcionan realmente de manera confiable:

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

Salida en coliru, aquí para referencia:

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

Resumen

Dado que se trata del "costo" de repetir elementos de código fuente, puede usar una tabla de búsqueda. Puede "ocultar" la tabla de búsqueda, por lo que es

 LUT[x][y]

o 

 LUT[x*6+y]

Por supuesto, puedes ser pedante y obtuso y renombrar el LUT

 L[x][y]

Entonces mi "versión" es ... 7 caracteres . (O hacer si es una función y L(x,y)es aún más corta).

O, lo que es más importante: correcto, comprobable y mantenible.

— sehe
fuente
Se agregó un "verdadero" golf. No menos de 9 caracteres, ¡pero el primero en ser correcto!
— sehe
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.