Arithmetic/Integer

Arithmetic/Integer
You are encouraged to solve this task according to the task description, using any language you may know.

Control Structures

These are examples of control structures. You may also be interested in:

• Conditional structures
• Exceptions
• Flow-control structures
• Loops

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Get two integers from the user, and then output the sum, difference, product, integer quotient and remainder of those numbers. Don't include error handling.

Ada

with Ada.Text_Io;
with Ada.Integer_Text_IO;

procedure Integer_Arithmetic is
   use Ada.Text_IO;
   use Ada.Integer_Text_Io;

   A, B : Integer;
begin
   Get(A);
   Get(B);
   Put_Line("a+b = " & Integer'Image(A + B));
   Put_Line("a-b = " & Integer'Image(A - B));
   Put_Line("a*b = " & Integer'Image(A * B));
   Put_Line("a/b = " & Integer'Image(A / B) & ", remainder " & Integer'Image(A mod B));  
end Integer_Arithmetic;

Befunge

 &&00p"=A",,:."=B ",,,00g.55+,v
         v,+55.+g00:,,,,"A+B="<
         >"=B-A",,,,:00g-.55+,v
         v,+55.*g00:,,,,"A*B="<
         >"=B/A",,,,:00g/.55+,v
          @,+55.%g00,,,,"A%B="<

C

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

int main(int argc, char *argv[])
{
  int a, b;
  if (argc < 3) exit(1);
  b = atoi(argv[--argc]);
  if (b == 0) exit(2);
  a = atoi(argv[--argc]);
  printf("a+b = %d\n", a+b);
  printf("a-b = %d\n", a-b);
  printf("a*b = %d\n", a*b);
  printf("a/b = %d\n", a/b);
  printf("a%%b = %d\n", a%b);
  return 0;
}

C++

#include <iostream>

int main()
{
  int a, b;
  std::cin >> a >> b;
  std::cout << "a+b = " << a+b << "\n";
  std::cout << "a-b = " << a-b << "\n";
  std::cout << "a*b = " << a*b << "\n";
  std::cout << "a/b = " << a/b << ", remainder " << a%b << "\n";
  return 0;
}

E

def arithmetic(a :int, b :int) {
  return `$\
   Sum:        ${a + b}
   Difference: ${a - b}
   Product:    ${a * b}
   Quotient:   ${a // b}
   Remainder:  ${a % b}$\n`
}

Forth

To keep the example simple, the word takes the two numbers from the stack. /mod returns two results; the stack effect is ( a b -- a%b a/b ).

: arithmetic ( a b -- )
  cr ." a=" over . ." b=" dup .
  cr ." a+b=" 2dup + .
  cr ." a-b=" 2dup - .
  cr ." a*b=" 2dup * .
  cr ." a/b=" /mod .
  cr ." a mod b = " . cr ;

Haskell

main = do
  as <- getLine
  bs <- getLine
  let 
    a :: Integer
    a = read as
    b :: Integer
    b = read bs
  putStrLn $ "a + b = " ++ show (a + b)
  putStrLn $ "a - b = " ++ show (a - b)
  putStrLn $ "a * b = " ++ show (a * b)
  putStrLn $ "a / b = " ++ show (a `div` b)

MAXScript

x = getKBValue prompt:"First number"
y = getKBValue prompt:"Second number:"

format "Sum: %\n" (x + y) 
format "Difference: %\n" (x - y) 
format "Product: %\n" (x * y) 
format "Quotient: %\n" (x / y) 
format "Remainder: %\n" (mod x y) 

Pascal

program arithmetic(input, output)

var
 a, b: integer;

begin
 readln(a, b);
 writeln('a+b = ', a+b);
 writeln('a-b = ', a-b);
 writeln('a*b = ', a*b);
 writeln('a/b = ', a div b, ', remainder ", a mod b);
end.

Perl

my $a = <>;
my $b = <>;

print
    "sum:              ", $a + $b, "\n",
    "difference:       ", $a - $b, "\n",
    "product:          ", $a * $b, "\n",
    "integer quotient: ", int($a / $b), "\n",
    "remainder:        ", $a % $b, "\n"
    ;

Pop11

;;; Setup token reader
vars itemrep;
incharitem(charin) -> itemrep;
;;; read the numbers
lvars a = itemrep(), b = itemrep();
;;; Print results
printf(a + b, 'a + b = %p\n');
printf(a - b, 'a - b = %p\n');
printf(a * b, 'a * b = %p\n');
printf(a div b, 'a div b = %p\n');
printf(a mod b, 'a mod b = %p\n');

Python

x = int(raw_input("Number 1: "))
y = int(raw_input("Number 2: "))

print "Sum: %d" % (x + y)
print "Difference: %d" % (x - y)
print "Product: %d" % (x * y)
print "Quotient: %d" % (x / y)
print "Remainder: %d" % (x % y)

## Only used to keep the display up when the program ends
raw_input( )

Ruby

   puts 'Enter x and y'
   x=gets.to_i
   y=gets.to_i

   puts "Sum: #{x+y}",
        "Difference: #{x-y}",
        "Product: #{x*y}",
        "Quotient: #{x/y}",
        "Remainder: #{x%y}"

Scheme

(define (arithmetic x y)
  (for-each (lambda (op)
              (write  (list op x y))
              (display " => ")
              (write ((eval op) x y))
              (write-char #\newline))
            '(+ - * / quotient remainder modulo max min gcd lcm)))
           
(arithmetic 8 12)

 prints this:

(+ 8 12) => 20
(- 8 12) => -4
(* 8 12) => 96
(/ 8 12) => 2/3
(quotient 8 12) => 0
(remainder 8 12) => 8
(modulo 8 12) => 8
(max 8 12) => 12
(min 8 12) => 8
(gcd 8 12) => 4
(lcm 8 12) => 24

Tcl

puts "Please enter two numbers:"

gets stdin x
gets stdin y

puts "
  $x + $y = [expr $x+$y]
  $x - $y = [expr $x-$y]
  $x * $y = [expr $x*$y]
  $x / $y = [expr int($x / $y)]
  $x mod $y = [expr $x % $y]
"

Since Tcl doesn't really know about the "type" of a variable, the "expr" command is used to declare whatever follows as an "expression". This means there is no such thing as "integer arithmetic" and hence the kludge int( $x / $y ).

Often, these operations would be performed in a way differently from what is shown here. For example to increase the variable "x" by the value of the variable "y", one would write

incr x $y

etc

Toka

[ ( a b -- )
  2dup ." a+b = " + . cr  
  2dup ." a-b = " - . cr  
  2dup ." a*b = " * . cr  
  2dup ." a/b = " / . ." remainder " mod . cr  
] is mathops