class String
    def rpn # Reverse Polish Notation.
        stack, string = Array.new, self.strip
        while string[" "]
            midval, string = string[0, string.index(" ")], string[string.index(" "), string.length - string.index(" ")].strip
            (stack.push(eval("#{stack[-2]}#{midval}#{stack[-1]}")).push(stack.pop(3)[2]; next) unless ("0".."9") === midval[0]
            stack.push(midval.to_i)
        end
        return eval("#{stack[0]}#{string}#{stack[1]}")
    end
end

puts gets.rpn
gets

def rpn(string):
    stack, tokens = [], string.strip().split(" ")
    for token in tokens:
        if not token.isdigit():
          token = eval("%s%s%s" % (stack[-2],token,stack[-1])
          stack = stack[:-2]
        stack.append(int(token))
    return stack[0]

string = raw_input("Your command? ")
print rpn(string)

rpn.rb:9:in `rpn': (eval):1:in `rpn': compile error (SyntaxError)
(eval):1: syntax error, unexpected $end
        from rpn.rb:13:in `eval'
        from rpn.rb:9:in `rpn'
        from rpn.rb:13

class String
    def rpn # Reverse Polish Notation.
        stack, tokens = Array.new, self.strip.split(" ")
        for token in tokens
            (stack.push(eval("#{stack[-2]}#{token}#{stack[-1]}")).push(stack.pop(3)[2]; next) unless ("0".."9") === token[0]
            stack.push(token.to_i)
        end
        return stack[0]
    end
end

puts gets.rpn
gets

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;

public class RPN {
	
	private Deque<Float> numberstack;
	
	public RPN()
	{
		numberstack = new ArrayDeque<Float>();
	}
	
	public float run(String code)
	{
		Scanner sc = new Scanner(code);
		String t;
		float op1 = 0;
		float op2 = 0;
		short op = 0;
		
		while (sc.hasNext())
		{
			t = sc.next();
			op = getOperation(t);
			switch (op)
			{
			case 0: //Try to read value
				try
				{
					numberstack.push(Float.parseFloat(t));
				}
				catch (java.lang.NumberFormatException exc)
				{
					//Nope, it's not a value. Simply ignore it.
				}
			break;
			default: //Operation. Get operands here.
				
				if (!numberstack.isEmpty())
				{
					op2 = numberstack.pop();
					if (!numberstack.isEmpty())
						op1 = numberstack.pop();
					else
						op1 = 0;
				}
				else
					op2 = 0;	
			}
			if (op == 0)
				continue;
			switch (op)
			{	
			case 1: //Add
				numberstack.push(op1 + op2);
			break;	

			case 2: //Subtract
				numberstack.push(op1 - op2);
			break;	

			case 3: //Multiply
				numberstack.push(op1 * op2);
			break;	

			case 4: //Divide
				numberstack.push(op1 / op2);
			break;	

			case 5: //Power
			{
				float acc = 1;
				for (int i = 0; i < op2 ; i++)
				{
					acc *= op1;
				}
				numberstack.push(acc);
			}	
			break;
			}
		}
		
		sc.close();
		return numberstack.size() != 0 ? numberstack.peekFirst() : 0;
	}
	
	private short getOperation(String s)
	{
		char c = s.charAt(0);
		//Operations:
		//0 - no valid operation. Is operand or nothing at all.
		//1 - add			- +
		//2 - subtract		- -
		//3 - multiply		- *
		//4 - divide		- /
		//5 - power			- ^
		switch (c)
		{
		case '+': return 1;
		case '-': return 2;
		case '*': return 3;
		case '/': return 4;
		case '^': return 5;
		}
		return 0;
	}
	
}

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;

public class RPN {
   
   private Deque<Float> numberstack;
   
   public RPN()
   {
      numberstack = new ArrayDeque<Float>();
   }
   
   public float run(String code)
   {
      Scanner sc = new Scanner(code);
      String t;
      float op1 = 0;
      float op2 = 0;
      short op = 0;
      
      while (sc.hasNext())
      {
         t = sc.next();
         op = getOperation(t);
         switch (op)
         {
         case 0: //Try to read value
            try
            {
               numberstack.push(Float.parseFloat(t));
            }
            catch (java.lang.NumberFormatException exc)
            {
               //Nope, it's not a value. Simply ignore it.
            }
         break;
         default: //Operation. Get operands here.
            
            if (!numberstack.isEmpty())
            {
               op2 = numberstack.pop();
               if (!numberstack.isEmpty())
                  op1 = numberstack.pop();
               else
                  op1 = 0;
            }
            else
               op2 = 0;   
         }
         if (op == 0)
            continue;
         switch (op)
         {   
         case 1: //Add
            numberstack.push(op1 + op2);
         break;   

         case 2: //Subtract
            numberstack.push(op1 - op2);
         break;   

         case 3: //Multiply
            numberstack.push(op1 * op2);
         break;   

         case 4: //Divide
            numberstack.push(op1 / op2);
         break;   

         case 5: //Power
         {
            float acc = 1;
            for (int i = 0; i < op2 ; i++)
            {
               acc *= op1;
            }
            numberstack.push(acc);
         }   
         break;
         }
      }
      
      sc.close();
      float res = numberstack.size() != 0 ? numberstack.peekFirst() : 0;
      while(!numberstack.isEmpty()) //there you go. :P
         numberstack.pop();
      return res;
   }
   
   private short getOperation(String s)
   {
      char c = s.charAt(0);
      //Operations:
      //0 - no valid operation. Is operand or nothing at all.
      //1 - add         - +
      //2 - subtract      - -
      //3 - multiply      - *
      //4 - divide      - /
      //5 - power         - ^
      switch (c)
      {
      case '+': return 1;
      case '-': return 2;
      case '*': return 3;
      case '/': return 4;
      case '^': return 5;
      }
      return 0;
   }
   
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;


public class RPN {

    private abstract class Operation {
        private String opString;
        
        public Operation(String opString) {
            this.opString = opString;
        }
        
        public String getOpString(){
            return opString;
        }
        
        public abstract Integer doOp(Integer first, Integer second);
    }
    
    
    private class Addition extends Operation {
        public Addition() {
            super("+");
        }

        public Integer doOp(Integer first, Integer second) {
            return first + second;
        }
    }
    
    private class Subtraction extends Operation {
        public Subtraction() {
            super("-");
        }

        public Integer doOp(Integer first, Integer second) {
            return first - second;
        }
    }
    
    private class Multiplication extends Operation {
        public Multiplication() {
            super("*");
        }

        public Integer doOp(Integer first, Integer second) {
            return first * second;
        }
    }
    
    private class Division extends Operation {
        public Division() {
            super("/");
        }

        public Integer doOp(Integer first, Integer second) {
            return first / second;
        }
    }
    
    private class Token {
        private boolean isOperation;
        private Operation operation;
        private Integer number;
        
        public Token(Operation op){
            isOperation = true;
            this.operation = op;
        }
        
        public Token(Integer number){
            isOperation = false;
            this.number = number;
        }
        
        public boolean isOperation(){
            return isOperation;
        }
        
        public Operation getOperation(){
            if(!isOperation()){
                throw new UnsupportedOperationException();
            }
            return operation;
        }
        
        public Integer getInteger(){
            if(isOperation()){
                throw new UnsupportedOperationException();
            }
            return number;
        }
        
        public void act(Stack<Integer> stack){
            if(isOperation){
                Integer second = stack.pop();
                Integer first = stack.pop();
                stack.add(getOperation().doOp(first, second));
            } else {
                stack.add(getInteger());
            }
        }
    }
    
    private class TokenFactory{
        private Map<String, Token> map;
        public TokenFactory(){
            map = new HashMap<String, Token>();
            
            addOperation(new Addition());
            addOperation(new Subtraction());
            addOperation(new Multiplication());
            addOperation(new Division());
        }
        
        private void addOperation(Operation op){
            map.put(op.getOpString(), new Token(op));
        }
        
        public Token get(String in){
            if(map.containsKey(in)){
                return map.get(in);
            } else {
                //TODO: should probably catch NumberFormatException and
                //wrap in own exception
                Integer number = Integer.parseInt(in);
                return new Token(number);
            }
        }
    }
    
    private Stack<Integer> stack = new Stack<Integer>();
    
    public Integer run(String string){
        List<Token> tokens = tokenize(string);
        for (Token t : tokens){
            t.act(stack);
        }
        return stack.pop();
    }
    
    private List<Token> tokenize(String string){
        List<Token> tokens = new ArrayList<Token>();
        String[] splitstring = string.split("\\s");
        TokenFactory tf = new TokenFactory();
        for(String part:splitstring){
            tokens.add(tf.get(part));
        }
        return tokens;
    }
    
    public static void main(String[] args) {
        RPN rpn = new RPN();
        System.out.println(rpn.run("20 45 *"));
        System.out.println(rpn.run("1 2 + 4 * 5 6 7 - - -"));
    }
}

"Amarth" said:
Bah. That's way too procedural. While, break, continue, if-then-else... And you're using magic numbers. Also, why use Deque and not just Stack?

"E_net4" said:

"Amarth" said:
Bah. That's way too procedural. While, break, continue, if-then-else... And you're using magic numbers. Also, why use Deque and not just Stack?

I read that and went WAT. Then I looked at that code and admitted that was even more Object Oriented than my version.
Hmm... what's the abstract tag for...

Plus, I used Deque because of this.

But heh, you're actually using more classes for the same thing. Is that what you call bloated?

Oh, and if I go on with this, I'll give Linoleum a shot. It should be easy to work with integers.

"Amarth" said:
Pythonic solution:

def rpn(string):
    stack, tokens = [], string.strip().split(" ")
    for token in tokens:
        if not token.isdigit():
          token = eval("%s%s%s" % (stack[-2],token,stack[-1])
          stack = stack[:-2]
        stack.append(int(token))
    return stack[0]

string = raw_input("Your command? ")
print rpn(string)

Some slight differences from your code, in particular I first split the string into tokens instead of parsing it in a while-loop, and I don't push on the stack for no reasons :p.

def rpn(string):
    stack, tokens = [], string.strip().split(" ")
    for token in tokens:
        if not token.isdigit():
          token = eval("{} {} {}".format(stack[-2], token, stack[-1])
          stack = stack[:-2]
        stack.append(int(token))
    return stack[-1]

string = input("Your command? ")
print rpn(string)

"MageKing17" said:
Shouldn't it return stack[-1]? I mean, it just seems logical that "4 3 + 0" would result in 0, not 7, pointless though it may be.

(
 *	Reverse Polish Notation library
 *		Made by E_net4
 *	
 *	Example of use:
 * rpn . run : [p my command];
 * 
 * where [p my command] points to a string of the command. The string should be in UCS-4.
)

"libraries"
	data/string/strlen;
(	data/heap/dynamic/mgrab; )
	
	
"directors"

	unit = 32;
	namespace = rpn;

"constants"

	char Space	= 20h;
	char Add 	= 2Bh;
	char Sub 	= 2Dh;
	char Mul	= 2Ah;
	char Slash	= 2Fh;
	char Zero	= 30h;
	char Nine	= 39h;
	
	status init		= 0;
	status value	= 1;

"variables"

( default command )
	null command 	= 0;
( pointer to command )
	p command 		= null command;

"workspace"

	w var;
	s len;
	
"preambles"
	
leave ( preambles );



"run": [p command];

	with,
		[s len] <- string . strlen: [p command];
		
	as,
		A = 0;					( operand 1 / temp read value / result of single instruction )
		B = 0;					( operand 2 / temp value )
		C = 0;					( number of elements in stack )
		D = [p command];		( pointer to character in command string )
		E = 0;					( supposed result )
		[wvar] = status init;	( Current status of reading command... I ran out of registers, ok? )
		[s len];				( length in units of command string )
		
	"run loop"
	
		with,
			B = [D];
		
		(CHECK FOR NUMBER)
		? B < char Zero > char type is not number;
		? B > char Nine > char type is not number;
		"char type is number"
		
			A * 10;
			B - char zero; (we now have value of char)
			A + B; (put value into our number)
			[wvar] = status value; (we're reading a value for sure)
			> continue run loop;
		
		"char type is not number"
		
		( CHECK FOR SPACE )
		? B ! char Space > char type is not space;
		
			(
			  We found a space character.
			  If status is init, then do nothing.
			  If status is value, then push the value,
			    and set status to init.
			)
			? [wvar] = status init > continue run loop;
			
			--> A; (Push value to stack)
			+ C; (Update nr. of elements)
			A = 0;
			[wvar] = status init;
			> continue run loop;
		
		"char type is not space"
			[wvar] = status init;		
		(CHECK ADDITION)
		? B ! char Add > char type is not addition;
			
			A = 0;
			B = 0;	
			? C = 0 > no op1 to add;
			
			<-- B; (Pop op 2)
			- C;

			"no op1 to add" ( or done taking op1 )
			? C = 0 > no op2 to add;
			
			<-- A; (Pop op 1)
			- C;
	
			"no op2 to add" ( or done taking op2 )
			A + B; (Perform operation)
			
			--> A;
			+ C;
			> continue run loop;
		
		"char type is not addition"

		(CHECK SUBTRACTION)
		? B ! char Sub > char type is not subtraction;

			A = 0;
			B = 0;			
			? C = 0 > no op1 to subtract;
			
			<-- B; (Pop op 2)
			- C;

			"no op1 to subtract" ( or done taking op1 )
			? C = 0 > no op2 to subtract;
			
			<-- A; (Pop op 1)
			- C;
	
			"no op2 to subtract" ( or done taking op2 )
			A - B; (Perform operation)
			
			--> A;
			+ C;
			> continue run loop;
		
		"char type is not subtraction"
		
		(CHECK MULTIPLICATION)
		? B ! char Mul > char type is not multiplication;
		
			A = 0;
			B = 0;	
			? C = 0 > no op1 to multiply;
			
			<-- B; (Pop op 2)
			- C;

			"no op1 to multiply" ( or done taking op1 )
			? C = 0 > no op2 to multiply;
			
			<-- A; (Pop op 1)
			- C;
	
			"no op2 to multiply" ( or done taking op2 )
			A * B; (Perform operation)
			
			--> A;
			+ C;

			> continue run loop;
		
		"char type is not multiplication"

		(CHECK DIVISION)
		? B ! char Slash > char type is not dvision; ( D - Vision : for when division is not possible)
		
			A = 0;
			B = 0;	
			? C = 0 > no op1 to dvide;
			
			<-- B; (Pop op 2)
			- C;

			"no op1 to dvide" ( or done taking op1 )
			? C = 0 > no op2 to dvide;
			
			<-- A; (Pop op 1)
			- C;
	
			"no op2 to dvide" ( or done taking op2 )
			A / B; (Perform operation)
			
			--> A;
			+ C;

			> continue run loop;
		
		"char type is not dvision"

		( And we're done checking the character )
		
		"continue run loop"
		+ D; ( next character )
	? D < [s len] > run loop;
	
	? C = 0 > zero result;
	<-- E; ( Result is here! )
	- C;
	"zero result"
	( There. E holds the result. Now we empty our part of the stack...
	
	"empty stack"
	? C = 0 > stack is empty;
		<-- A; (We have to pop it to somewhere...
		- C;
	> empty stack;
	"stack is empty"
	
	( And we're done )

return [register] E;

use Math::RPN;
print "Your command? ";
$_ = <>;
chomp;
@expr = split(' ');
$value = rpn(@expr);
print $value . "\n";

"Narvius" said:
brainfuck implementation

#include <string>
#include <map>
#include <stack>
#include <sstream>
#include <stdexcept>
#include <iostream>
#include <iterator>

template <class valType>
class Operator
{
    public:
        virtual valType operator() (valType, valType) = 0;
};

template<class valType>
class Add : public Operator<valType>
{
    valType operator() (valType first, valType second) { return first + second; }
};

template<class valType>
class Subtract : public Operator<valType>
{
    valType operator() (valType first, valType second) { return second - first; }
};

template<class valType>
class Multiply : public Operator<valType>
{
    valType operator() (valType first, valType second) { return first * second; }
};

template<class valType>
class Divide : public Operator<valType>
{
    valType operator() (valType first, valType second) { return second / first; }
};

template <class valType>
class RPNHandler
{
    private:
        // This is a bit of hackery, current C++ implementation doesn't support string literals as non-type template parameters
        // (Infact it doesn't support any sort of literal, templated paramaters have to be linked globally to one degree or another).
        // I would have prefered to use template specialisations as it would mean we could bypass this level of indirection
        // and automatically handle operators, but apparently that'll have to wait until the new standard.
        // This just provides a map for operator functors through the Operator abstract base class.
        std::map<std::string, Operator<valType>*> operatorMap;

        std::stack<valType> opStack;
    public:
        RPNHandler()
        {
            //You can add your own operators as well if need be, they just can't contain any whitespace (fixable but meh)
            operatorMap["+"] = new Add<valType>;
            operatorMap["-"] = new Subtract<valType>;
            operatorMap["*"] = new Multiply<valType>;
            operatorMap["/"] = new Divide<valType>;
        }

        void operator()(std::string token)
        {
            std::istringstream stream(token);
            valType digit;

            if (stream>>digit)
            {
                //Token is a number
                opStack.push(digit);
            }
            else
            {
                //Assume it's an operator
                if (operatorMap.find(token) == operatorMap.end() || opStack.size() < 2)
                {
                    throw std::runtime_error("Invalid RPN Expression");
                }
                valType first = opStack.top(); opStack.pop();
                valType second = opStack.top(); opStack.pop();
                
                opStack.push( (*operatorMap[token](first, second));
            }
        }

        valType result()
        {
            if (opStack.size() != 1)
            {
                throw std::runtime_error("Invalid RPN Expression");
            }
            return opStack.top();
        }

};

int main(int argc, char** argv)
{
    std::cout<<"Your command? ";
    std::string input;
    std::getline(std::cin, input);

    //Tokenise the input (split on whitespace)
    std::stringstream stream(input);
    std::istream_iterator<std::string> tokens_begin(stream);
    std::istream_iterator<std::string> tokens_end;

    RPNHandler<int> rpn;
    //Probably an STL algorithm for this...
    for (std::istream_iterator<std::string> it = tokens_begin; it != tokens_end; ++it)
    {
        rpn(*it);
    }

    std::cout<<"\n"<<rpn.result()<<"\n\nPress enter to continue... ";
    std::cin.get();
    return 0;
}

"Vacuus" said:
class RPNHandler
{
private:
...

"Venom31" said:

"Vacuus" said:
class RPNHandler
{
private:
...

Usually the class starts by private members as default, you don't have to specify it. Except for those who do not understand C++ :sic:

function string:split(splitter)
        local splitter, fields = splitter or " ", {}
        local pattern = string.format("([^%s]+)", splitter)
        self:gsub(pattern, function(c) fields[#fields+1] = c end)
        return fields
end


function rpnEquation()
	local self = {} --Mimics an object; lua tables are very powerful
	local stack = {}

	function self.proc(token)
		if tonumber(token) then table.insert(stack, 1, tonumber(token))
		else
			--Assume it's an operator.
			assert( #stack >= 2, "Invalid RPN Equation")
			first, second = stack[1], stack[2]
		    	--Better ways to do this but I'm lazy
			table.remove(stack, 1)
		    	table.remove(stack, 1)

		    	table.insert(stack, 1, assert(loadstring("return " .. second .. token .. first) )() )
		  end
	end
	
	function self.result() return stack[1] end

	return self
end

io.write("Your command? ")
input = io.read("*line")

rpn = rpnEquation()
for _,token in ipairs(input:split(" ")) do rpn.proc(token) end
print(rpn.result())
print("Press enter to quit... ")
io.read()

class Array
	def but_first
		return self[1, length]
	end
end

class RPNStack < Array
	def initialize(type = Numeric)
		@type = type
	end
	
	def execute
		stack = []
		for item in self
			if item.is_a? @type then stack.push(item)
			elsif item.is_a? Symbol
				arity = stack[-1].method(item).arity
				items = stack.pop(arity < 0 ? 2 : arity + 1)
				stack.push(items[0].send(item, *(items.but_first)))
			else raise("Incompatible object pushed on RPNStack.") end
		end
		return stack[0]
	end
end

rpn = RPNStack.new

for token in gets.strip.split(" ")
	if ("0".."9") === token[0] or token[0] == "-"
		if token.include? "."
			rpn.push(token.to_f)
		else
			rpn.push(token.to_i)
		end
	else
		rpn.push(token.to_sym)
	end
end

puts rpn.execute