1077

+8

ggroth respondido 9 years ago

Seguem alguns (poucos) casos de teste. Espero que possam ser úteis.

Input:

4
A*(2+3)
A+(2+3)
A*(2/3)
(2*(4/a)^b*1+2*(3+5))/(2*(c-3))

Output:

A23+*
A23++
A23/*
24a/b^*1*235+*+2c3-*/

+5

rseocepython respondido 8 years ago

Segue mais um caso de teste:

Entrada:

4
(A)+b
a
((b+2)^3)/4^4*(3+1)
(g+b)*((4^4^4^4)+3)

Saida:

Ab+
a
b2+3^44^/31+*
gb+44^4^4^3+*

+1

mcamargo6 respondido 7 years ago

Alguém sabe dizer qual o formato da entrada? Input no prompt? String? Vetor? Da pra passar essa entrada como parâmetro pra função?

Valeu!

+1

madiniz respondido 9 years ago

Aceito

+1

ccdsantos respondido 9 years ago

Boa noite!

Galera, gostaria que me ajudassem... pq estou recebendo wrong answer 60%?

#include <iostream>
#include <sstream>
#include <stack>
#include <string>

using namespace std;

int prioridade(char);
int main(){

    stack <char> operador;

    string expressao;
    int i,n=0;

    cin>>n;
    while(n>0){
    stringstream posfixa;
    cin>>expressao;

    for(i=0;i<expressao.size();i++){
        if(expressao[i]=='+' || expressao[i]=='-'||expressao[i]=='*'||expressao[i]=='/'||expressao[i]=='^'){
            if(!operador.empty()&&operador.top()!='('&&operador.top()!=')'){
            if(prioridade(operador.top())<= prioridade(expressao[i])){
                posfixa<<operador.top();
                operador.pop();
                operador.push(expressao[i]);
            }else{
               operador.push(expressao[i]);
            }
            }else{
               operador.push(expressao[i]);
            }
        }
        else{
           if(expressao[i]=='('){
                operador.push(expressao[i]);
              }else{
                 if(expressao[i]==')'){
                    while(operador.top()!='(' && !operador.empty()){
                            posfixa<<operador.top();
                            operador.pop();
                          }
                          if(operador.top()=='('){
                                operador.pop();
                             }

                 }else{
                    posfixa<<expressao[i];
                }

              }

        }
    }

    while(!operador.empty()){
            if(operador.top()!='('){
                posfixa<<operador.top();
                operador.pop();
              }else{
                 operador.pop();
              }
    }

              cout<<posfixa.str()<<endl;
      n--;
    }
return 0;
}

int prioridade (char operador){
   int priority;

   if(operador=='^'){
    priority=1;
   }else{
      if(operador=='*' || operador=='/'){
        priority=2;
      }else{
        if(operador=='+' || operador=='-'){
            priority=3;
        }
      }
   }
   return priority;
}

Valeu!!

+1

lhnegri respondido on fev. 17 2014

Nota: a precedência esperada por este problema é:

Subtração e soma: 1 Multiplicação e divisão: 2 Exponenciação: 3

0

FelipeDerkian respondido 7 years ago

alguem pode me ajudar?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/* Constantes */
#define VERDADEIRO 1
#define FALSO 0

/* Estrutura para a pilha */
typedef struct{
char dados[150]; /* Matriz para armazenar as informações da pilha */
int topo; /* Topo da pilha */
} PILHA;

/* Prototipação das funções */
void iniciaPilha(PILHA *pilha);
void pega_infixo(char infixo[]);
void converteParaPosfixo(char infixo[], char posfixo[]);
int eOperador(char c);
int precedencia(char operador1, char operador2);
int precedenciaNivel(char ch);
void colocaNaPilha(PILHA *pilha, char value);
char tiraDaPilha(PILHA *pilha);
char topoDaPilha(PILHA *pilha);
int estaVazia(PILHA *pilha);
int estaCheia(PILHA *pilha);
void imprimeResultado(char infixo[], char posfixo[]);
void imprimeMensagem(void);

/* Função Principal */
int main(void){
int n;
scanf("%d",&n);
while(n--){

char infixo[350], posfixo[350]="";
/* Chama a função que converte de infixo para posfixo */
converteParaPosfixo(infixo, posfixo);
infixo[strlen(infixo)-2]='\0';
/* Imprime o resultado */
imprimeResultado(infixo, posfixo);
}
return EXIT_SUCCESS;
}
//------------fim MAIN---------------
/* Inicializa a pilha */
void iniciaPilha(PILHA *pilha){
pilha->topo = -1; /* Inicia vazia */
}

/* Pega a expressão infixa */
void pega_infixo(char infixo[]){
int i;

//printf("Digite a expressao infixa: ");
fflush(stdin); /*Captura a entrada*/

/* Lendo os caracteres */
for ( i=0; i<360; ){
if ((infixo[i]=getchar())=='\n'){ //Se no final, sai
i++;
break;
}else if (!(isspace(infixo[i]))) //Se não é espaço, continua
i++;
}
infixo[i] = '\0';
}

/* Converte de infixo para posfixo */
void converteParaPosfixo(char infixo[], char posfixo[]){
int i, tamanho;
int j=0;
char topo_ch;
PILHA pilha;

iniciaPilha(&pilha); /* Inicializa a pilha */
pega_infixo(infixo); /* Chama a funão que captura os caracteres */
tamanho = strlen(infixo);

/* Se o tamanho for maior que zero */
if (tamanho){
colocaNaPilha(&pilha,'(');
strcat(infixo,")"); //Concatena
tamanho++;

for (i=0;i<tamanho;i++){
/* Se é dígito */
if (isdigit(infixo[i])){
posfixo[j++] = infixo[i];
}
/* Se é parêntese esquerdo */
else if (infixo[i]=='('){
colocaNaPilha(&pilha,'(');
}

/* Se é operador */
else if (eOperador(infixo[i])){
while (VERDADEIRO){
/* Pega o Topo */
topo_ch = topoDaPilha(&pilha);

/* Critica */
if (topo_ch=='\0'){
printf("\nExpressao invalida\n");
imprimeMensagem();
exit(1);
}else{
if (eOperador(topo_ch)){
if (precedenciaNivel(topo_ch)>=precedenciaNivel(infixo[i]))
posfixo[j++] = tiraDaPilha(&pilha);
else
break;
}else
break;
}
}
colocaNaPilha(&pilha, infixo[i]);
}
else if(infixo[i]>='A'&& infixo[i]<='Z' ||infixo[i]>='a' && infixo[i]<='z'){

        posfixo[j++]=(&pilha, infixo[i]);

}
/* Se é parêntese direito */
else if (infixo[i]==')'){
while (VERDADEIRO){
/* Pega o topo */
topo_ch=topoDaPilha(&pilha);

/* Critica */
if (topo_ch=='\0'){
printf("\nExpressao invalida\n");
imprimeMensagem();
exit(1);
}else{
if (topo_ch!='('){
posfixo[j++] = topo_ch;
tiraDaPilha(&pilha);
}else{
tiraDaPilha(&pilha);
break;
}
}
}
continue;
}
}
}

posfixo[j] = '\0';
}

/* Verifica qual é o operador */
int eOperador(char o){
if (o=='+'||o=='-'||o=='*'||o=='/'||o=='%'||o=='^'){
return VERDADEIRO;
}else
return FALSO;
}

/* Veririca o nível de precedência */
int precedenciaNivel(char p){
if (p=='+'||p=='-')
return 1;
else if (p=='^')
return 3;
else
return 2;
}

/* Veririca se a precedência do Operador1 é Menor, Igual ou Maior que a precedência
do Operador2 */
int precedencia(char operador1, char operador2){
if (precedenciaNivel(operador1)>precedenciaNivel(operador2))
return 1;
else if (precedenciaNivel(operador1)<precedenciaNivel(operador2) )
return -1;
else
return 0;
}

/* Push */
void colocaNaPilha(PILHA *pilha, char valor){
if (!(estaCheia(pilha))){ /* Se não está cheia */
(pilha->topo)++;
pilha->dados[pilha->topo]=valor;
}
}

/* Pop */
char tiraDaPilha(PILHA *pilha){
char c;

if (!(estaVazia(pilha))){ /* Se não está vazia */
c = pilha->dados[pilha->topo];
(pilha->topo)--;
return c;
}else
return '\0';
}

/* Retorna o topo da pilha sem retirar o elemento do topo */
char topoDaPilha(PILHA *pilha){
if (!(estaVazia(pilha))) /* Se não está vazia */
return pilha->dados[pilha->topo];
else
return '\0';
}

/* Verifica se a pilha está vazia */
int estaVazia(PILHA *pilha){
/* Vazia */
if (pilha->topo==-1)
return VERDADEIRO;
/* Não vazia */
else
return FALSO;
}

/* Verifica se a pilha está cheia */
int estaCheia(PILHA *pilha){
/* Cheia */
if (pilha->topo==19)
return VERDADEIRO;
/* Não cheia */
else
return FALSO;
}

/* Mostra o resultado da Notação Pos-fixa */
void imprimeResultado(char infixo[], char posfixo[]){
//printf("\n");
printf("%s\n", posfixo);
//imprimeMensagem();
}

/* Imprime a mensagem de saída */
void imprimeMensagem(void){
printf("Pressione ENTER para sair");
fflush(stdin);
getchar();
}

MOD

0

FelipeDerkian respondido 7 years ago

alguém pode me ajudar?

# include <stdio.h>
# include <stdlib.h>

typedef struct _Pilha
{
    char op;
    struct _Pilha *prox;
}Pilha;

void transfereTempPos( Pilha **pPos, Pilha **pTemp, Pilha *aux )
{
    aux = ( *pTemp ) -> prox;
    ( *pTemp ) -> prox = *pPos;
    *pPos = *pTemp;
    *pTemp = aux;
}

void alocaCharNaPilha( Pilha **pilha, Pilha *aux, char op )
{
    aux = ( Pilha *) malloc( sizeof( Pilha ) );
    aux -> op = op;
    aux -> prox = *pilha;
    *pilha = aux;
}

void leOperacao( Pilha **pPos, Pilha **pTemp )
{
    char op;
    Pilha *aux;

    scanf( "%c", &op );
    while( op != '\n' )
    {

        switch( op )
        {
            case '+':
            case '-':

                while( ( *pTemp ) && ( (*pTemp) -> op != '(' ) )
                {
                    transfereTempPos( &( *pPos ), &( *pTemp ), aux );
                }

                alocaCharNaPilha( &( *pTemp ), aux, op );

                break;

            case '*':
            case '/':

                while( ( *pTemp ) && ( (*pTemp) -> op != '+' && (*pTemp) -> op != '-'
                      && (*pTemp) -> op != '^'  && (*pTemp) -> op != '(' ) )
                {
                    transfereTempPos( &( *pPos ), &( *pTemp ), aux );
                }

                alocaCharNaPilha( &( *pTemp ), aux, op );

                break;

            case '^':

                while( ( *pTemp ) && ( (*pTemp) -> op != '+' && (*pTemp) -> op != '-'
                      && (*pTemp) -> op != '*' && (*pTemp) -> op != '/' && (*pTemp) -> op != '(' ) )
                {
                    transfereTempPos( &( *pPos ), &( *pTemp ), aux );
                }

                alocaCharNaPilha( &( *pTemp ), aux, op );

                break;

            case ')':
                while( ( *pTemp ) && ( (*pTemp) -> op != '(' ) )
                {
                    transfereTempPos( &( *pPos ), &( *pTemp ), aux );
                }

                if( (*pTemp) && (*pTemp) -> op == '(' )
                {
                    aux = *pTemp;
                    *pTemp = (*pTemp) -> prox;
                    free( aux );
                }

                break;

            case '(':
                alocaCharNaPilha( &( *pTemp ), aux, op );

                break;

            default:
                alocaCharNaPilha( &( *pPos ), aux, op );

                break;
        }

        scanf( "%c", &op );
    }

    while( *pTemp )
    {
        transfereTempPos( &( *pPos ), &( *pTemp ), aux );
    }

}

void imprime( Pilha *topo )
{
    if( topo )
    {
        imprime( topo -> prox );
        printf( "%c", topo -> op );
    }
}

int main(){
  //  printf("DIGITE QUANTOS TESTES\n");
    int n;
    scanf("%d",&n);
    while(n--){
    setbuf(stdin,NULL);
    Pilha *pPos = NULL;
    Pilha *pTemp = NULL;
   // printf( "Operacao Infixa: " );
    leOperacao( &pPos, &pTemp );
  //  printf( "Operacao Posfixa: " );
    imprime( pPos );
    printf( "\n" );
    }
    return 0;
}

MOD

0

UBIRAJARA respondido 7 years ago

Está dando wrong answer(10%), alguem pode me ajudar.

def isOperator(operador):
    Operadores=["*","/","+","-"]
    for i in range(len(operadores)):
        if operador==Operadores[i]:
            return True
    return False

def isOperand(operando):
    if(operando.isalpha() or operando.isnumeric()):
        return True
    return False

def isEmpty(stack):
    if len(stack)==0:
        return True
    return False

def InfixtoPostFix(sequence):
    PostFixList=[]
    opStack=[]
    prec={}
    prec["("]=3
    prec["*"]=2
    prec["/"]=2
    prec["+"]=1
    prec["-"]=1
    for i in range(len(sequence)):
        if isOperand(sequence[i]):
            PostFixList.append(sequence[i])
        elif sequence[i]=='(':
            opStack.append(sequence[i])
        elif sequence[i]==')':
            topStack=opStack.pop()
            while topStack!='(':
                PostFixList.append(topStack)
                topStack=opStack.pop()
        else:
            while not isEmpty(opStack) and prec[opStack[-1]]>=prec[sequence[i]]:
                PostFixList.append(opStack.pop())
            opStack.append(sequence[i])
    while not isEmpty(opStack):
        PostFixList.append(opStack.pop())
    return " ".join(PostFixList)
print()
print(InfixtoPostFix(input()))

0

nstreppel respondido 9 years ago

Um grande agradecimento ao darksshades. Este era o meu problema, também.

0

Gustjc respondido 9 years ago

As vezes é bom testar os casos mais simples, estava recebendo wrong(60%) também por conta da prioridade estar sendo feita errada. Me preocupei tanto com os parenteses e não confirmei o básico.

Teste o caso:

Entrada:

1
a+b*a/d-u/b

Saida:

aba*d/+ub/-

0

ggroth respondido 9 years ago

Bom, se esse for o código que você está tentando submeter, você receberá Compilation Error. Em vários lugares, vc tem um espaço no meio da chamada a função 'charAt(i)'. Você está colocando ';' após os ifs. Não tem todas as variáveis declaradas e nem está lendo a entrada ;)

0

AmandaCortez respondido 9 years ago

Boa Noite Por favor me orientar o que está faltando.

public class Main{ public void infixaPosfixa() {
String exame = expressao;
int prioridadeSinal;

for(int i=0; i<exame.length();i++)  {
  if ( exame.charAt(i) =='(') elementos.empilha("(");  
    else if ( exame.char At(i) == '+');
      prioridadeSinal("+");  
    else if ( exame.char At(i) == '-');
      prioridadeSinal("-");
    else if ( exame.char At(i) == '*');
      prioridadeSinal("*"); 
    else if ( exame.char At(i) == '/');
      prioridadeSinal("/");  
    else if ( exame.char At(i) ==')');
       prioridadeSinal(")");  
    else saida += exame.charAt(i);  
    }  

    while ( ! elementos.vazia ()) saida += elementos.desempilha();  
    System.out.println(saida);

}// infixaPosfixa
}

Obrigada.

0

tmateus respondido 9 years ago

Fala aí, não estou conseguindo achar algum erro, o código ficou muito extenso, entenderei se ninguem responder heheheh

/* Includes necess?rios */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>//manipulação de caracters
#include<iostream>
/* Constantes */
#define VERDADEIRO 1
#define FALSO 0

/* Estrutura para a pilha */
//definição de um novo nome
typedef struct{
char dados[310]; /* Matriz para armazenar as informa??es da pilha */
int topo; /* Topo da pilha */
} PILHA;

/* sei que não seria necessario retornar ponteiros e nem buscalos
pois estou usando um tipo local "PILHA", pois acesso a ela em qualque lugar, mas o código foi mudado
e tentado de outro jeito, sem ponteiros e retornos, acbei não sendo muito feliz então priorizando por este método*/

void iniciaPilha(PILHA *pilha);
void pega_infixo(char infixo[]);
void converteParaPosfixo(char infixo[], char posfixo[]);
int eOperador(char c);
int precedencia(char operador1, char operador2);
int precedenciaNivel(char ch);
void colocaNaPilha(PILHA *pilha, char value);
char tiraDaPilha(PILHA *pilha);
char topoDaPilha(PILHA *pilha);
int estaVazia(PILHA *pilha);
int estaCheia(PILHA *pilha);
void imprimeResultado(char infixo[], char posfixo[]);

/* Fun??o Principal */
int main(){
char infixo[310], posfixo[310]="";
/* Chama a fun??o que converte de infixo para posfixo */
converteParaPosfixo(infixo, posfixo);
infixo[strlen(infixo)-2]='\0';
/* Imprime o resultado */

}

/* Inicializa a pilha */
void iniciaPilha(PILHA *pilha){
pilha->topo = -1; /* Inicia vazia */
}

/* Pega a express?o infixa */
void pega_infixo(char infixo[]){
int i;

fflush(stdin); /*Captura a entrada*/

/* Lendo os caracteres */
for ( i=0; i<310; ){
if ((infixo[i]=getchar())=='\n'){ //Se no final, sai
i++;
break;
}else if (!(isspace(infixo[i]))) //Se n?o ? espa?o, continua
i++;
}
infixo[i] = '\0';
}

/* Converte de infixo para posfixo */
void converteParaPosfixo(char infixo[], char posfixo[]){
     int A,T;
     scanf("%d",&A);
 for(T=0;T<A;T++){
 int i, tamanho;
int j=0;
char topo_ch;
PILHA pilha;

iniciaPilha(&pilha); /* Inicializa a pilha */
pega_infixo(infixo); /* Chama a fun?o que captura os caracteres */
tamanho = strlen(infixo);//determina o tamanho de uma string

/* Se o tamanho for maior que zero */
if (tamanho){
colocaNaPilha(&pilha,'(');
strcat(infixo,")"); //Concatena
tamanho++;

for (i=0;i<tamanho;i++){
/* Se ? d?gito */
if (isdigit(infixo[i]) || infixo[i]=='A' || infixo[i]=='B' || infixo[i]=='C' || infixo[i]=='D' || infixo[i]=='E' || infixo[i]=='F' || infixo[i]=='G' || infixo[i]=='H'
|| infixo[i]=='I' || infixo[i]=='J' || infixo[i]=='K' || infixo[i]=='L' || infixo[i]=='M' || infixo[i]=='N' || infixo[i]=='O' || infixo[i]=='P' || infixo[i]=='Q' || infixo[i]=='R' || infixo[i]=='S' || infixo[i]=='T' || infixo[i]=='U'
|| infixo[i]=='V' || infixo[i]=='W' || infixo[i]=='Y' || infixo[i]=='Z' || infixo[i]=='X' || infixo[i]=='a' || infixo[i]=='b' || infixo[i]=='c' || infixo[i]=='d' || infixo[i]=='e' || infixo[i]=='f' || infixo[i]=='g' || infixo[i]=='h'
|| infixo[i]=='i' || infixo[i]=='j' || infixo[i]=='k' || infixo[i]=='l' || infixo[i]=='m' || infixo[i]=='n' || infixo[i]=='o' || infixo[i]=='p' || infixo[i]=='q' || infixo[i]=='r' || infixo[i]=='s' || infixo[i]=='t' || infixo[i]=='u'|| infixo[i]=='v'
|| infixo[i]=='x' || infixo[i]=='y' || infixo[i]=='w' || infixo[i]=='z'){
posfixo[j++] = infixo[i];
}
/* Se ? par?ntese esquerdo */
else if (infixo[i]=='('){
colocaNaPilha(&pilha,'(');
}

/* Se ? operador */
else if (eOperador(infixo[i])){
while (VERDADEIRO){
/* Pega o Topo */
topo_ch = topoDaPilha(&pilha);

/* Critica */
if (topo_ch=='\0'){
exit(1);
}else{
if (eOperador(topo_ch)){
if (precedenciaNivel(topo_ch)>=precedenciaNivel(infixo[i])){
posfixo[j++] = tiraDaPilha(&pilha);}
else
break;
}else
break;
}
}
colocaNaPilha(&pilha, infixo[i]);
}

/* Se ? par?ntese direito */
else if (infixo[i]==')'){
while (VERDADEIRO){
/* Pega o topo */
topo_ch=topoDaPilha(&pilha);

/* Critica */
if (topo_ch=='\0'){
exit(1);
}else{
if (topo_ch!='('){
posfixo[j++] = topo_ch;
tiraDaPilha(&pilha);
}else{
tiraDaPilha(&pilha);
break;
}
}
}
continue;//faz pular para o proximo
}
}
}

  imprimeResultado(infixo, posfixo);
}

}

/* Verifica qual ? o operador */
int eOperador(char o){
if (o=='+'||o=='-'||o=='*'||o=='/'||o=='%'||o=='^'){
return VERDADEIRO;
}else
return FALSO;
}

/* Veririca o n?vel de preced?ncia */
int precedenciaNivel(char p){
if (p=='+'||p=='-')
return 1;
else if (p=='^')
return 3;
else
return 2;
}

/* Veririca se a preced?ncia do Operador1 ? Menor, Igual ou Maior que a preced?ncia
do Operador2 */
int precedencia(char operador1, char operador2){
if (precedenciaNivel(operador1)>precedenciaNivel(operador2))
return 1;
else if (precedenciaNivel(operador1)<precedenciaNivel(operador2) )
return -1;
else
return 0;
}

/* Push */
void colocaNaPilha(PILHA *pilha, char valor){
if (!(estaCheia(pilha))){ /* Se n?o est? cheia */
(pilha->topo)++;
pilha->dados[pilha->topo]=valor;
}
}

/* Pop */
char tiraDaPilha(PILHA *pilha){
char c;

if (!(estaVazia(pilha))){ /* Se n?o est? vazia */
c = pilha->dados[pilha->topo];
(pilha->topo)--;
return c;
}else
return '\0';
}

/* Retorna o topo da pilha sem retirar o elemento do topo */
char topoDaPilha(PILHA *pilha){
if (!(estaVazia(pilha))) /* Se n?o est? vazia */
return pilha->dados[pilha->topo];
else
return '\0';
}

/* Verifica se a pilha est? vazia */
int estaVazia(PILHA *pilha){
/* Vazia */
if (pilha->topo==-1)
return VERDADEIRO;
/* N?o vazia */
else{
return FALSO;
pilha->topo=-1;
}
}

/* Verifica se a pilha est? cheia */
int estaCheia(PILHA *pilha){
/* Cheia */
if (pilha->topo==19)
return VERDADEIRO;
/* N?o cheia */
else
return FALSO;
}

/* Mostra o resultado da Nota??o Pos-fixa */
void imprimeResultado(char infixo[], char posfixo[]){

printf("%s\n", posfixo);
}

0

pmoggi respondido 9 years ago

Olá, Teria como alguém passar um arquivo com alguns casos de teste?

Em todos meus testes o resultado foi o mesmo do toolkit, porém ainda estou recebendo 60% Wrong answer.

E estou com dúvida se haverá parênteses dentro de parênteses. (pq o tempo sobe muito caso haja parênteses dentro de parênteses...)

Grato.

0

ccdsantos respondido 9 years ago

[size=150:10q8sywf]Alguém pode me ajudar? Estou quase louca pois todos os casos do exemplo dão certo. Tentei outros e tbm tá td ok! Obg desde já!!![/size:10q8sywf]

0

bertol respondido on jan. 31 2014

Bom dia... Estou recebendo "Wrong answer (60%)".

RESOLVIDO (obrigado)

0

bertol respondido on jan. 30 2014

Boa tarde,

Tem como passar os arquivos de entrada e saída? Estou inseguro quanto a minha solução e gostaria de testar com mais casos.

Obrigado.

0

lsteffen respondido on out. 6 2013

Eis: wrong answer

#include <stdio.h>
//
struct pilha{
    int Top;
    char Pilha[310];
};
//
void ZeraPilha(struct pilha *pP);
int Prioridade(char A);
void Push(struct pilha *pP, char C);
char Pop(struct pilha *pP);
//
int main(void)
{
    int i,n,N;
    char S[310];
    struct pilha Operandos;
    scanf("%d%*c",&N);
    for(n=0;n<N;n++){
        ZeraPilha(&Operandos);
        scanf("%s",S);
        for(i=0;S[i];i++){
            if((S[i]>='a'&&S[i]<='z')||(S[i]>='A'&&S[i]<='Z')||(S[i]>='0'&&S[i]<='9')){ //Se for número ou letra,
                printf("%c",S[i]); //apenas os imprime
            }
            else if(!Operandos.Top){ //Se a pilha estiver vazia,
                Push(&Operandos,S[i]); //apenas adiciona
            }
            else if(S[i]=='('){ //Se o caractere é '(',
                Push(&Operandos,S[i]); //apenas adiciona
            }
            else if(S[i]==')'){ //Se fecha um bloco,
                while(Operandos.Pilha[Operandos.Top]!='('){ //vai até achar '('
                    printf("%c",Pop(&Operandos));
                }
                Pop(&Operandos); //Como para ao enconrar '(', dá um último Pop para tirá-lo
            }
            else if(Prioridade(S[i])<=Prioridade(Operandos.Pilha[Operandos.Top])){ //Se a prioridade do que está é menor que a do topo
                while(Operandos.Top){ //enquanto não atingo o índice zero,
                    if(Operandos.Pilha[Operandos.Top]=='(')break; //(break caso encontrar '(')
                    printf("%c",Pop(&Operandos)); //retira todos da pilha
                }
                Push(&Operandos,S[i]); //Depois que esvazia insere o operador
            }
            else{
                Push(&Operandos,S[i]); //Uma vez que deve ser retirado, apenas o insere...
            }
        }
        while(Operandos.Top){ //Esvazia a pilha caso haja algum depois que acaba a expressão
            printf("%c",Pop(&Operandos));
        }
        printf("\n");
    }
    return(0);
}
//
void ZeraPilha(struct pilha *pP)
{
    pP->Top=0;
    return;
}
//
void Push(struct pilha *pP,char C)
{
    pP->Top+=1;
    pP->Pilha[pP->Top]=C;
    return;
}
//
char Pop(struct pilha *pP)
{
    char C=pP->Pilha[pP->Top];
    pP->Top-=1;
    return(C);
}
//
int Prioridade(char C)
{
    int P[]={1,1,2,2,3};
    char S[]={'-','+','*','/','^','\0'};
    for(int i=0;S[i];i++){
        if(S[i]==C)return(P[i]);
    }
    return(0);
}

Funciona com os 4 testes na descrição do problema...

beecrowd

TÓPICO

beecrowd perguntou on fev. 8 2013

ggroth respondido 9 years ago

rseocepython respondido 8 years ago

mcamargo6 respondido 7 years ago

madiniz respondido 9 years ago

ccdsantos respondido 9 years ago

lhnegri respondido on fev. 17 2014

FelipeDerkian respondido 7 years ago

FelipeDerkian respondido 7 years ago

UBIRAJARA respondido 7 years ago

nstreppel respondido 9 years ago

Gustjc respondido 9 years ago

ggroth respondido 9 years ago

AmandaCortez respondido 9 years ago

tmateus respondido 9 years ago

pmoggi respondido 9 years ago

ccdsantos respondido 9 years ago

bertol respondido on jan. 31 2014

bertol respondido on jan. 30 2014

lsteffen respondido on out. 6 2013