public static void Main(string[] args)
{
Dictionary <char, IStrategy> strategies = new Dictionary <char, IStrategy>
{
{
'+', new AdditionStrategy()
},
{
'-', new SubtractionStrategy()
},
{
'*', new MultiplyStrategy()
},
{
'/', new DivideStrategy()
}
};
PrimitiveCalculator calc = new PrimitiveCalculator(strategies['+'], strategies);
string[] input = Console.ReadLine().Split();
while (input[0] != "End")
{
if (input[0] == "mode")
{
calc.ChangeStrategy(char.Parse(input[1]));
}
else
{
Console.WriteLine(calc.PerformCalculation(int.Parse(input[0]), int.Parse(input[1])));
}
input = Console.ReadLine().Split();
}
}
public static void Main()
{
var primitiveCalculator = new PrimitiveCalculator();
string command = Console.ReadLine();
while (command != "End")
{
string[] commandArgs = command.Split();
if (commandArgs[0] == "mode")
{
char mode = char.Parse(commandArgs[1]);
primitiveCalculator.ChangeStrategy(mode);
}
else
{
int firstOperand = int.Parse(commandArgs[0]);
int secondOperand = int.Parse(commandArgs[1]);
int result = primitiveCalculator.PerformCalculation(firstOperand, secondOperand);
Console.WriteLine(result);
}
command = Console.ReadLine();
}
}
public static void Main()
{
PrimitiveCalculator calculator = new PrimitiveCalculator();
string line = Console.ReadLine();
while (line != "End")
{
string[] commandArgs = line.Split().ToArray();
if (commandArgs[0] == "mode")
{
char @operator = commandArgs[1].ToCharArray()[0];
calculator.ChangeStrategy(@operator);
}
else
{
int firstOperand = int.Parse(commandArgs[0]);
int secondOperand = int.Parse(commandArgs[1]);
Console.WriteLine(calculator.PerformCalculation(firstOperand, secondOperand));
}
line = Console.ReadLine();
}
}
static void Main(string[] args)
{
PrimitiveCalculator calculator = new PrimitiveCalculator(new AdditionStrategy());
string input;
while ((input = Console.ReadLine()) != "End")
{
string[] tokens = input.Split();
string firstArg = tokens[0];
if (firstArg == "mode")
{
char operand = tokens[1][0];
ICalculationStrategy strategy = null;
switch (operand)
{
case '+':
strategy = new AdditionStrategy();
break;
case '-':
strategy = new SubtractionStrategy();
break;
case '*':
strategy = new MultyplicationStrategy();
break;
case '/':
strategy = new DivideStrategy();
break;
}
if (strategy == null)
{
throw new InvalidOperationException("Invalid Mode!");
}
calculator.ChangeStrategy(strategy);
}
else
{
int first = int.Parse(firstArg);
int second = int.Parse(tokens[1]);
int result = calculator.PerformCalculation(first, second);
Console.WriteLine(result);
}
}
}
static void Main()
{
ICalculationStrategy calcStartegy = new AdditionStrategy();
PrimitiveCalculator calculator = new PrimitiveCalculator(calcStartegy);
string input = "";
while ((input = Console.ReadLine()) != "End")
{
string[] args = input.Split();
if (args[0] == "mode")
{
ICalculationStrategy calculationStrategy = null;
switch (args[1])
{
case "+":
calculationStrategy = new AdditionStrategy();
break;
case "-":
calculationStrategy = new SubtractionStrategy();
break;
case "*":
calculationStrategy = new MultiplicationStrategy();
break;
case "/":
calculationStrategy = new DivisionStrategy();
break;
}
if (calculationStrategy != null)
{
calculator.ChangeStrategy(calculationStrategy);
}
}
else
{
int firstOperand = int.Parse(args[0]);
int secondOperand = int.Parse(args[1]);
int result = calculator.PerformCalculation(firstOperand, secondOperand);
Console.WriteLine(result);
}
}
}
public static void Main()
{
string input = Console.ReadLine();
var calc = new PrimitiveCalculator();
while (input != "End")
{
string[] data = input.Split();
int num1;
if (int.TryParse(data[0], out num1))
{
int num2 = int.Parse(data[1]);
int result = calc.PerformCalculation(num1, num2);
Console.WriteLine(result);
}
else
{
char @operator = Convert.ToChar(data[1]);
switch (@operator)
{
case '+':
IStrategy addition = new AdditionStrategy();
calc.ChangeStrategy(addition);
break;
case '-':
IStrategy subtraction = new SubtractionStrategy();
calc.ChangeStrategy(subtraction);
break;
case '*':
IStrategy multiplication = new MultiplicationStrategy();
calc.ChangeStrategy(multiplication);
break;
case '/':
IStrategy division = new DivisionStrategy();
calc.ChangeStrategy(division);
break;
default:
throw new InvalidOperationException("Invalid operator!");
}
}
input = Console.ReadLine();
}
}
static void Main()
{
PrimitiveCalculator calculator = new PrimitiveCalculator();
string input = Console.ReadLine();
while (input != "End")
{
string[] commandTokens = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (commandTokens[0] == "mode")
{
ICalculatable strategy = null;
switch (commandTokens[1])
{
case "+":
strategy = new AdditionStrategy();
break;
case "-":
strategy = new SubtractionStrategy();
break;
case "*":
strategy = new MultiplyStrategy();
break;
case "/":
strategy = new DivisionStrategy();
break;
}
calculator.ChangeStrategy(strategy);
}
else
{
int leftOperand = int.Parse(commandTokens[0]);
int rightOperand = int.Parse(commandTokens[1]);
int result = calculator.PerformCalculation(leftOperand, rightOperand);
Console.WriteLine(result);
}
input = Console.ReadLine();
}
}
public static void Main()
{
var input = string.Empty;
var calculator = new PrimitiveCalculator();
while ((input = Console.ReadLine()) != "End")
{
var tokens = input.Split().ToList();
if (tokens[0] == "mode")
{
calculator.ChangeStrategy(char.Parse(tokens[1]));
}
else
{
Console.WriteLine(calculator.PerformCalculation(int.Parse(tokens[0]), int.Parse(tokens[1])));
}
}
}
public void Run()
{
string command;
while ((command = Console.ReadLine()) != "End")
{
string[] data = command.Split();
if (data[0] == "mode")
{
char calculationType = data[1][0];
ICalculationStrategy strategy = null;
switch (calculationType)
{
case '-':
strategy = new SubtractionStrategy();
break;
case '+':
strategy = new AdditionStrategy();
break;
case '*':
strategy = new MultiplyingStrategy();
break;
case '/':
strategy = new DivisionStrategy();
break;
}
this.calculator.ChangeStrategy(strategy);
}
else
{
int firstOperand = int.Parse(data[0]);
int secondOperand = int.Parse(data[1]);
int result = calculator.PerformCalculation(firstOperand, secondOperand);
Console.WriteLine(result);
}
}
}
public static void Main()
{
var calculator = new PrimitiveCalculator();
string input;
while ((input = Console.ReadLine()) != "End")
{
var args = input.Split();
if (args[0] == "mode")
{
calculator.ChangeStrategy(args[1][0]);
continue;
}
int result = calculator.PerformCalculation(int.Parse(args[0]), int.Parse(args[1]));
Console.WriteLine(result);
}
}
public static void Main()
{
PrimitiveCalculator calc = new PrimitiveCalculator();
string commandArgs = string.Empty;
while ((commandArgs = Console.ReadLine()) != "End")
{
if (commandArgs.StartsWith("mode"))
{
char @operator = commandArgs.TrimEnd().ToCharArray().Last();
calc.ChangeStrategy(@operator);
}
else
{
int[] numbers = commandArgs.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
Console.WriteLine(calc.PerformCalculation(numbers[0], numbers[1]));
}
}
}
static void Main()
{
PrimitiveCalculator calculator = new PrimitiveCalculator();
IStrategy newStrategy = new AdditionStrategy();
string input = Console.ReadLine();
while (input != "End")
{
string[] commandInfo = input.Split();
if (commandInfo[0] == "mode")
{
switch (commandInfo[1][0])
{
case '+':
newStrategy = new AdditionStrategy();
break;
case '-':
newStrategy = new SubtractionStrategy();
break;
case '/':
newStrategy = new DivisionStrategy();
break;
case '*':
newStrategy = new MultiplicationStrategy();
break;
}
calculator.ChangeStrategy(newStrategy);
}
else
{
int result = calculator.PerformCalculation(int.Parse(commandInfo[0]), int.Parse(commandInfo[1]));
Console.WriteLine(result);
}
input = Console.ReadLine();
}
}
static void Main(string[] args)
{
string input = string.Empty;
PrimitiveCalculator calculator = new PrimitiveCalculator();
while ((input = Console.ReadLine()) != "End")
{
string[] operands = input.Split(' ');
if (operands[0] == "mode")
{
char operand = operands[1][0];
calculator.ChangeStrategy(operand);
}
else
{
int firstOperand = int.Parse(operands[0]);
int secondOperand = int.Parse(operands[1]);
Console.WriteLine(calculator.PerformCalculation(firstOperand, secondOperand));
}
}
Console.ReadLine();
}
static void Main(string[] args)
{
var calculator = new PrimitiveCalculator();
var input = "";
while ((input = Console.ReadLine()) != "End")
{
var cmdArgs = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (cmdArgs[0] == "mode")
{
calculator.ChangeStrategy(char.Parse(cmdArgs[1]));
}
else
{
var firstOperand = int.Parse(cmdArgs[0]);
var secondOprand = int.Parse(cmdArgs[1]);
Console.WriteLine(calculator.PerformCalculation(firstOperand, secondOprand));
}
}
}
public static void Main(string[] args)
{
var calc = new PrimitiveCalculator();
string input;
while ((input = Console.ReadLine()) != "End")
{
var paramArgs = input.Split(' ');
var first = paramArgs[0];
var second = paramArgs[1];
if (first == "mode")
{
calc.ChangeStrategy(char.Parse(second));
}
else
{
Console.WriteLine(calc.PerformCalculation(int.Parse(first), int.Parse(second)));
}
}
}
static void Main()
{
var calculator = new PrimitiveCalculator(new AdditionStrategy());
var input = Console.ReadLine().Split();
while (!input[0].Equals("End"))
{
if (input[0].Equals("mode"))
{
calculator.ChangeStrategy(char.Parse(input[1]));
}
else
{
var firstNum = int.Parse(input[0]);
var secondNum = int.Parse(input[1]);
Console.WriteLine(calculator.PerformCalculation(firstNum, secondNum));
}
input = Console.ReadLine().Split();
}
}
