X maior que 3 com pelo menos 2 diferenças entre X e Y

11

Estou tentando jogar golfe em C ++. É possível diminuir essa condição?

X > 3 & X - Y > 1

(Além de remover o espaço em branco, é claro.)

Então, Xé pelo menos 4mas X >= Y + 2.

Xe Ysão inteiros no intervalo [0,5].

Eu tentei encontrar alguma fórmula bit a bit, mas falhei.

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
fonte
1
@JoeZ. Para CodeGolf? Por quê? Enquanto ele está funcionando ...
Cristy
4
@ Christ sim, sim, mas (até agora) as perguntas sobre conselhos sobre golfe são muito raras, enquanto a maioria das perguntas sobre conselhos são de fato apenas questões gerais de programação - que são fora de tópico. Portanto, eu posso entender por que a primeira reação das pessoas pode ser "oh, essa é outra questão que realmente pertence ao SO", sem nem pensar que poderia ser sobre conselhos sobre golfe. Na verdade, eu gostaria de ver mais dessas no futuro, e talvez haja uma tag para elas em algum dia, e fique claro imediatamente que você sabe como usar este site. ;)
Martin Ender
4
Se eles são inteiros entre 0..5 inclusive, você pode fazer o mesmo com x*x-y*y>9. É a mesma quantidade de caracteres, mas você pode encontrar um atalho / alternativa a essa abordagem. Apenas outra maneira de ver isso.
Geobits
5
Use Python:3<x>y+1
avall
2
Encontrei muitas soluções com a precedência do operador do Python, por exemplo y+3<2^x, mas a precedência do operador do C é diferente. Eu estou apostando há uma solução de 7-char, só tem que modificar meu script para lidar com C precedência do operador em vez
Claudiu

Respostas:

11

Depois de forçar brutalmente todas as combinações úteis de símbolos com menos de 9 caracteres, descobri que não há solução menor do que x>3&x-y>1.

Por diversão, aqui estão algumas soluções descoladas de 9 personagens que o bruto encontrou:

-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

O forçamento bruto foi feito em Python, construindo árvores de sintaxe de cima para baixo, nas quais nenhum filho pode ter um operador com precedência menor que seu pai, de acordo com as regras de C. Para reduzir as possibilidades, permiti apenas literais de um dígito e nenhum operador binário pode ter dois filhos constantes. Eu não conseguia pensar em nenhuma solução que tivesse um literal de dois dígitos ou que construa uma constante usando um operador binário. Cada expressão foi avaliada para [0, 5] e, se corresponder, será impressa.

orlp
fonte
Eu realmente gosto x*x-y*y>9. Talvez você deva tentar constantes com vários dígitos também? (também entre parênteses)
John Dvorak
@JanDvorak me também. Expressa bem a lógica da "distância entre x e y". Eu acho que se você traçar isso em um gráfico, isso se tornaria mais óbvio.
precisa
@JanDvorak Eu não acho que parênteses possam ser uma solução menor. Uma solução menor pode ter no máximo 8 caracteres, dos quais 2 devem ser xye 2 devem ser parênteses, deixando apenas 4 caracteres de lógica. Vou tentar executar o forute bruto com constantes de 2 dígitos, mas realmente não acho que isso dará um resultado.
Ou orp
Que tal, x, y, uma constante, um par de parênteses e dois operadores?
John Dvorak
@JanDvorak Nocauteie-se, (a#b)$cé o formato. Um dos abcdois deve ser xe y, deixando três locais possíveis para [0-9xy]e apenas um deles xy. Apenas operadores interessantes são +-*/&|^<>, portanto, 9 possibilidades. Assim, as possibilidades no total é menos do que 3 * 12 * 2 * 9 * 9 <5832.
orlp
0

Em resposta aos (impressionantes) campos de golfe por orlp:

A correção deve vir primeiro

  • A maioria deles divide-se em alguns tipos inteiros. Isso inclui a versão do OP
  • Curiosamente eles fazem trabalho para int16_t- para que haja a suposição. Provavelmente, as trocas de bits precisariam de +16 por ints de 32 bits (que estão praticamente em todos os lugares hoje em dia). Isso os torna um personagem maior ...

A única maneira "correta" de escrevê-lo, é a IMO (x>3) && (x > y+1), que pode ter até x>3&x>y+19 caracteres.

(Você realmente precisa levar em consideração a possibilidade de tipos não assinados (maiores), especialmente porque a assinatura não assinada é "contagiosa" nas expressões C ++. Suponho que "consertar" que, com os static_cast<>s apropriados, acabaria com o objetivo ...)

ATUALIZAR

Com os seguintes testes, consegui descobrir quais expressões realmente funcionam de maneira confiável:

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

Saída em coliru, aqui para referência:

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

Sumário

Como esse é o "custo" de repetir os elementos do código-fonte, você pode usar uma tabela de pesquisa. Você pode "ocultar" a tabela de pesquisa, para que seja

 LUT[x][y]

ou 

 LUT[x*6+y]

Claro que você pode ser pedante e obtuso e renomear o LUT

 L[x][y]

Então, minha "versão" é ... 7 caracteres . (Ou faça se uma função e L(x,y)é ainda mais curta).

Ou, mais importante: correto, testável e sustentável.

ver
fonte
Adicionado um golfe "verdadeiro". Não inferior a 9 caracteres, mas o primeiro a estar correto!
11335 Ver as