Gerando expressão matemática aleatória

Eu tenho essa idéia circulando na minha cabeça, para gerar e avaliar expressões matemáticas aleatórias. Então, decidi tentar e elaborar um algoritmo, antes de codificá-lo para testá-lo.

Exemplo:

Aqui estão alguns exemplos de expressões que eu quero gerar aleatoriamente:

4 + 2                           [easy]
3 * 6 - 7 + 2                   [medium]
6 * 2 + (5 - 3) * 3 - 8         [hard]
(3 + 4) + 7 * 2 - 1 - 9         [hard]
5 - 2 + 4 * (8 - (5 + 1)) + 9   [harder]
(8 - 1 + 3) * 6 - ((3 + 7) * 2) [harder]

Os fáceis e médios são bem diretos. Random inté separado por operadores aleatórios, nada de louco aqui. Mas eu estou tendo alguns problemas para começar com algo que poderia criar uma das duras e mais duras exemplos. Não tenho certeza de que um único algoritmo possa me dar os dois últimos.

O que estou considerando:

Não posso dizer que tentei essas idéias, porque realmente não queria perder muito tempo indo em uma direção que não tinha chance de trabalhar em primeiro lugar. Mas ainda assim, pensei em algumas soluções:

• Usando árvores
• Usando expressões regulares
• Usando um loop "for-type" louco (certamente o pior)

O que estou olhando:

Gostaria de saber qual o melhor caminho a seguir, entre as soluções que considerei e suas próprias idéias.

Se você vir uma boa maneira de começar, eu apreciaria uma vantagem na direção certa, por exemplo, com o início do algoritmo ou com uma estrutura geral dele.

Observe também que terei que avaliar essas expressões. Isso pode ser feito após a expressão ser gerada ou durante sua criação. Se você levar isso em consideração na sua resposta, isso é ótimo.

Não estou procurando nada relacionado à linguagem, mas, para o registro, estou pensando em implementá-la no Objective-C, pois é a linguagem com a qual mais estou trabalhando recentemente.

Esses exemplos não incluíram o :operador, já que eu quero apenas manipular ints, e esse operador adiciona muitas verificações. Se sua resposta fornecer uma solução para lidar com essa, isso é ótimo.

Se minha pergunta precisar de algum esclarecimento, pergunte nos comentários. Obrigado pela ajuda.

Aqui está uma interpretação teórica do seu problema.

Você está procurando gerar aleatoriamente palavras (expressão algébrica) a partir de um determinado idioma (o conjunto infinito de todas as expressões algébricas sintaticamente corretas). Aqui está uma descrição formal de uma gramática algébrica simplificada que suporta apenas adição e multiplicação:

E -> I 
E -> (E '+' E)
E -> (E '*' E)

Aqui, Eestá uma expressão (ou seja, uma palavra do seu idioma) e Ié um símbolo terminal (ou seja, não é expandido mais) representando um número inteiro. A definição acima para Etem três regras de produção . Com base nessa definição, podemos construir aleatoriamente uma aritmética válida da seguinte maneira:

1. Comece com Eo símbolo único da palavra de saída.
2. Escolha uniformemente aleatoriamente um dos símbolos não terminais.
3. Escolha de maneira uniforme, aleatoriamente, uma das regras de produção para esse símbolo e aplique-a.
4. Repita as etapas 2 - 4 até restarem apenas os símbolos do terminal.
5. Substitua todos os símbolos do terminal Ipor números inteiros aleatórios.

Aqui está um exemplo da aplicação desses algoritmos:

E
(E + E)
(E + (E * E))
(E + (I * E))
((E + E) + (I * E))
((I + E) + (I * E))
((I + E) + (I * I))
((I + (E * E)) + (I * I))
((I + (E * I)) + (I * I))
((I + (I * I)) + (I * I))
((2 + (5 * 1)) + (7 * 4))

Eu suponho que você iria escolher para representar uma expressão com uma interface Expressionque é implementada por classes IntExpression, AddExpressione MultiplyExpression. Os dois últimos teriam um leftExpressione rightExpression. Todas as Expressionsubclasses são necessárias para implementar um evaluatemétodo, que funcione recursivamente na estrutura em árvore definida por esses objetos e efetivamente implemente o padrão composto .

Observe que, para a gramática e algoritmo acima, a probabilidade de expandir uma expressão Eem um símbolo terminal Ié apenas p = 1/3, enquanto a probabilidade de expandir uma expressão em duas expressões adicionais é 1-p = 2/3. Portanto, o número esperado de números inteiros em uma fórmula produzida pelo algoritmo acima é realmente infinito. O comprimento esperado de uma expressão está sujeito à relação de recorrência

l(0) = 1
l(n) = p * l(n-1) + (1-p) * (l(n-1) + 1)
     = l(n-1) + (1-p)

onde l(n)denota o comprimento esperado da expressão aritmética após a naplicação das regras de produção. Por isso, sugiro que você atribua uma probabilidade bastante alta pà regra, de E -> Imodo que você acabe com uma expressão bastante pequena e com alta probabilidade.

Edição : Se você está preocupado que a gramática acima produz muitos parênteses, observe a resposta de Sebastian Negraszus , cuja gramática evita esse problema com muita elegância.

Antes de tudo, eu realmente geraria a expressão na notação postfix , você pode facilmente converter em infixo ou avaliar depois de gerar sua expressão aleatória, mas fazê-lo no postfix significa que você não precisa se preocupar com parênteses ou precedência.

Eu também manteria um total em execução do número de termos disponíveis para o próximo operador em sua expressão (supondo que você queira evitar a geração de expressões malformadas), ou seja, algo como isto:

string postfixExpression =""
int termsCount = 0;
while(weWantMoreTerms)
{
    if (termsCount>= 2)
    {
         var next = RandomNumberOrOperator();
         postfixExpression.Append(next);
         if(IsNumber(next)) { termsCount++;}
         else { termsCount--;}
    }
    else
    {
       postfixExpression.Append(RandomNumber);
       termsCount++;
     }
}

obviamente, esse é um pseudo-código, portanto não é testado / pode conter erros e você provavelmente não usaria uma string, mas uma pilha de alguma união discriminada como o tipo

A resposta de Blubb é um bom começo, mas sua gramática formal cria muitas parênteses.

Aqui está a minha opinião:

E -> I
E -> M '*' M
E -> E '+' E
M -> I
M -> M '*' M
M -> '(' E '+' E ')'

Eé uma expressão, Ium número inteiro e Mé uma expressão que é um argumento para uma operação de multiplicação.

Os parênteses na expressão "rígida" representam a ordem da avaliação. Em vez de tentar gerar o formulário exibido diretamente, basta criar uma lista de operadores em ordem aleatória e derivar o formulário de exibição da expressão.

Números: 1 3 3 9 7 2

Operadores: + * / + *

Resultado: ((1 + 3) * 3 / 9 + 7) * 2

A derivação do formulário de exibição é um algoritmo recursivo relativamente simples.

Atualização: aqui está um algoritmo em Perl para gerar o formulário de exibição. Porque +e *são distributivos, randomiza a ordem dos termos para esses operadores. Isso ajuda a impedir que os parênteses se acumulem de um lado.

use warnings;
use strict;

sub build_expression
{
    my ($num,$op) = @_;

    #Start with the final term.
    my $last_num = pop @$num; 
    my $last_op = pop @$op;

    #Base case: return the number if there is just a number 
    return $last_num unless defined $last_op;

    #Recursively call for the expression minus the final term.
    my $rest = build_expression($num,$op); 

    #Add parentheses if there is a bare + or - and this term is * or /
    $rest = "($rest)" if ($rest =~ /[+-][^)]+$|^[^)]+[+-]/ and $last_op !~ /[+-]/);

    #Return the two components in a random order for + or *.
    return $last_op =~ m|[-/]| || rand(2) >= 1 ? 
        "$rest $last_op $last_num" : "$last_num $last_op $rest";        
}

my @numbers   = qw/1 3 4 3 9 7 2 1 10/;
my @operators = qw|+ + * / + * * +|;

print build_expression([@numbers],[@operators]) , "\n";

Para expandir a abordagem em árvore, digamos que cada nó seja uma folha ou uma expressão binária:

Node := Leaf | Node Operator Node

Observe que uma folha é apenas um número inteiro gerado aleatoriamente aqui.

Agora, podemos gerar aleatoriamente uma árvore. Decidir a probabilidade de cada nó ser uma folha nos permite controlar a profundidade esperada, embora você também queira uma profundidade máxima absoluta:

Node random_tree(leaf_prob, max_depth)
    if (max_depth == 0 || random() > leaf_prob)
        return random_leaf()

    LHS = random_tree(leaf_prob, max_depth-1)
    RHS = random_tree(leaf_prob, max_depth-1)
    return Node(LHS, RHS, random_operator())

Então, a regra mais simples para imprimir a árvore é envolver ()cada expressão que não seja folha e evitar preocupações com a precedência do operador.

Por exemplo, se eu colocar parênteses sua última expressão de amostra:

(8 - 1 + 3) * 6 - ((3 + 7) * 2)
((((8 - 1) + 3) * 6) - ((3 + 7) * 2))

você pode ler a árvore que a geraria:

                    SUB
                  /      \
               MUL        MUL
             /     6     /   2
          ADD          ADD
         /   3        3   7
       SUB
      8   1

Eu usaria árvores. Eles podem lhe dar um grande controle sobre a geração das expressões. Por exemplo, você pode limitar a profundidade por ramo e a largura de cada nível separadamente. A geração baseada em árvore também fornece a resposta já durante a geração, o que é útil se você deseja garantir que também o resultado (e sub-resultados) sejam difíceis o suficiente e / ou não muito difíceis de resolver. Especialmente se você adicionar um operador de divisão em algum momento, poderá gerar expressões que serão avaliadas em números inteiros.

Aqui está uma visão um pouco diferente da excelente resposta de Blubb:

O que você está tentando construir aqui é essencialmente um analisador que opera em sentido inverso. O que seu problema e um analisador têm em comum é uma gramática sem contexto , esta na forma Backus-Naur :

digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
number ::= <digit> | <digit> <number>
op ::= '+' | '-' | '*' | '/'
expr ::= <number> <op> <number> | '(' <expr> ')' | '(' <expr> <op> <expr> ')'

Os analisadores começam com um fluxo de terminais (tokens literais como 5ou *) e tentam montá-los em não-terminais (itens compostos por terminais e outros não-terminais, como numberouop ). Seu problema começa com os não terminais e funciona ao contrário, escolhendo qualquer coisa entre os símbolos "ou" (canal) aleatoriamente quando um é encontrado e repetindo recursivamente o processo até chegar a um terminal.

Algumas das outras respostas sugeriram que esse é um problema de árvore, que é para uma certa classe restrita de casos em que não existem termos não terminais que se referem direta ou indiretamente a outros não termos. Como as gramáticas permitem isso, esse problema é realmente um gráfico direcionado . (Referências indiretas através de outros não-terminais também contam para isso.)

Havia um programa chamado Spew publicado na Usenet no final dos anos 80, que foi originalmente projetado para gerar manchetes aleatórios dos tablóides e também é um ótimo veículo para experimentar essas "gramáticas reversas". Ele opera lendo um modelo que direciona a produção de um fluxo aleatório de terminais. Além do seu valor de diversão (manchetes, músicas country, rabiscos pronunciados em inglês), escrevi vários modelos que são úteis para gerar dados de teste que variam de texto sem formatação a XML a C. sintaticamente correto, mas não compilável. Apesar de ter 26 anos e escrito em K&R C e com um formato de modelo feio, ele compila muito bem e funciona como anunciado. Eu criei um modelo que resolve o seu problema e publiquei no pastebin já que adicionar muito texto aqui não parece apropriado.