Arithmetic/Integer: Difference between revisions

From Rosetta Code
Content added Content deleted
No edit summary
(Modula-3)
Line 294: Line 294:
format "Quotient: %\n" (x / y)
format "Quotient: %\n" (x / y)
format "Remainder: %\n" (mod x y)
format "Remainder: %\n" (mod x y)

=={{header|Modula-3}}==
<lang modula3>MODULE Arith EXPORTS Main;

IMPORT IO, Fmt;

VAR a, b: INTEGER;

BEGIN
a := IO.GetInt();
b := IO.GetInt();
IO.Put("a+b = " & Fmt.Int(a + b) & "\n");
IO.Put("a-b = " & Fmt.Int(a - b) & "\n");
IO.Put("a*b = " & Fmt.Int(a * b) & "\n");
IO.Put("a DIV b = " & Fmt.Int(a DIV b) & "\n");
IO.Put("a MOD b = " & Fmt.Int(a MOD b) & "\n");
END Arith.</lang>


=={{header|OCaml}}==
=={{header|OCaml}}==

Revision as of 00:24, 5 March 2009

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

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

<lang 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;</lang>

ALGOL 68

main:(
  LONG INT a=355, b=113;
  printf(($"a+b = "gl$, a + b));
  printf(($"a-b = "gl$, a - b));
  printf(($"a*b = a×b = "gl$, a * b));
  printf(($"a/b = "gl$, a / b));
  printf(($"a OVER b = a%b = a÷b = "gl$, a % b));
  printf(($"a MOD b = a%*b = a%×b = a÷×b = a÷*b = "gl$, a %* b));
  printf(($"a UP b = a**b = a↑b = "gl$, a ** b))
)

Output:

a+b =                                 +468

a-b =                                 +242
a*b = a×b =                               +40115
a/b = +3.141592920353982300884955752e  +0
a OVER b = a%b = a÷b =                                   +3
a MOD b = a%*b = a%×b = a÷×b = a÷*b =                                  +16


a UP b = a**b = a↑b = +1.499007808785573768814747570e+288

ALGOL 68R has the curious (and consequently non-standard) /:= operator. This operator delivers two INTs as a result. eg. 

INT quotient:=355, remainder;
remainder := quotient /:= 113;

Giving a quotient of 3, and a remainder of 16.

AWK

/[0-9]* [0-9]*/{ print ($1 + $2)
		print ($1 - $2)
		print ($1 * $2)
		print int($1 / $2)
		print ($1 % $2)
		exit}

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

<lang c>#include <stdio.h>

  1. 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;

}</lang>

C++

<lang cpp>#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;

}</lang>

C#

<lang csharp>using System;

class Program { 

  static void Main(string[] args)
  {
      int a, b;
      if (args.Length < 2)
          return;
      b = Convert.ToInt32(args[1]);
      if (b == 0)
          return;
      a = Convert.ToInt32(args[0]);
      Console.WriteLine("a + b = {0}", a + b);
      Console.WriteLine("a - b = {0}", a - b);
      Console.WriteLine("a * b = {0}", a * b);
      Console.WriteLine("a / b = {0}", a / b);
      Console.WriteLine("a % b = {0}", a % b);
  }

}</lang>

Common Lisp

<lang lisp>(defun arithmetic () 

 (let ((a (read *query-io*)) (b (read *query-io*)))
   (format t "a + b = ~a~%" (+ a b))
   (format t "a - b = ~a~%" (- a b))
   (format t "a * b = ~a~%" (* a b))
   (format t "a / b = ~a~%" (/ a b))
   (format t "a % b = ~a~%" (mod a b))))</lang>

D

<lang d>import std.stdio, std.string;

void main() { 

 auto a = readln().atoi(), b = readln().atoi();
 writefln("a + b = ", a+b);
 writefln("a - b = ", a-b);
 writefln("a * b = ", a*b);
 writefln("a / b = ", a/b);
 writefln("a % b = ", a%b);

}</lang>

DOS Batch File

@set /P A=Enter 1st Number :
@set /P B=Enter 2nd Number :
@set D=%A% + %B% & call :printC
@set D=%A% - %B% & call :printC
@set D=%A% * %B% & call :printC
@set D=%A% / %B% & call :printC
@set D=%A% %% %B% 
:printC
@set /A C=%D%
@echo %D% = %C%

E

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

Factor

 USING: combinators io kernel math math.functions math.order
 math.parser prettyprint ;
 
 "a=" "b=" [ write readln string>number ] bi@
 {
     [ + "sum: " write . ]
     [ - "difference: " write . ] 
     [ * "product: " write . ]
     [ / "quotient: " write . ]
     [ /i "integer quotient: " write . ]
     [ rem "remainder: " write . ]
     [ mod "modulo: " write . ]
     [ max "maximum: " write . ]
     [ min "minimum: " write . ]
     [ gcd "gcd: " write . drop ]
     [ lcm "lcm: " write . ]
 } 2cleave

output: 

 a=8
 b=12
 sum: 20
 difference: -4
 product: 96
 quotient: 2/3
 integer quotient: 0
 remainder: 8
 modulo: 8
 maximum: 12
 minimum: 8
 gcd: 4
 lcm: 24

This example illustrates the use of cleave and apply combinators to alleviate the usage of shuffle words in a concatenative language. bi@ applies a quotation to 2 inputs and 2cleave applies a sequence of quotations to 2 inputs.

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 ;

Fortran

In ANSI FORTRAN 77 or later: 

     INTEGER A, B
     PRINT *, 'Type in two integer numbers separated by white space',
    +         ' and press ENTER'
     READ *, A, B
     PRINT *, '   A + B = ', (A + B)
     PRINT *, '   A - B = ', (A - B)
     PRINT *, '   A * B = ', (A * B)
     PRINT *, '   A / B = ', (A / B)
     PRINT *, 'MOD(A,B) = ', MOD(A,B)
     PRINT *
     PRINT *, 'Even though you did not ask, ',
    +         'exponentiation is an intrinsic op in Fortran, so...'
     PRINT *, '  A ** B = ', (A ** B)
     END

Haskell

main = do
  a <- readLn :: IO Integer
  b <- readLn :: IO Integer
  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)
  putStrLn $ "a % b = " ++ show (a `mod` b)

J

bia     =: title"_ combine calc
calc    =: + , - , * , <.@% , |
combine =: [ ,. ":@|:@,:@]
title   =: >;.2 'Sum: Difference: Product: Quotient: Remainder: '

Note that the verb calc produces all the processing specified for this problem, and that its output is of numeric type. Since other examples here provide textual output, bia produces like results.

Java

<lang java>import java.util.Scanner;

public static void main(String[] args){ 

 Scanner sc = new Scanner(System.in);
 int a = sc.nextInt();
 int b = sc.nextInt();
 
 int sum = a + b;//integer addition is discouraged in print statements due to confusion with String concatenation
 System.out.println("a + b = " + sum);
 System.out.println("a - b = " + (a - b));
 System.out.println("a * b = " + (a * b));
 System.out.println("quotient of a / b = " + (a / b));//integer division truncates decimal places
 System.out.println("remainder of a / b = " + (a % b));

}</lang> 

to operate :a :b
  (print [a =] :a)
  (print [b =] :b)
  (print [a + b =] :a + :b)
  (print [a - b =] :a - :b)
  (print [a * b =] :a * :b)
  (print [a / b =] int :a / :b)
  (print [a mod b =] modulo :a :b)
end

Each infix operator also has a prefix synonym (sum, difference, product, quotient). Sum and product can also have arity greater than two when used in parentheses (sum 1 2 3). Infix operators in general have high precedence; you may need to enclose their arguments in parentheses to obtain the correct expression.

LSE64

over : 2 pick
2dup : over over

arithmetic : \
  " A=" ,t over , sp " B=" ,t dup , nl \
  " A+B=" ,t 2dup + , nl \
  " A-B=" ,t 2dup - , nl \
  " A*B=" ,t 2dup * , nl \
  " A/B=" ,t 2dup / , nl \
  " A%B=" ,t      % , nl

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)

Modula-3

<lang modula3>MODULE Arith EXPORTS Main;

IMPORT IO, Fmt;

VAR a, b: INTEGER;

BEGIN 

 a := IO.GetInt();
 b := IO.GetInt();
 IO.Put("a+b = " & Fmt.Int(a + b) & "\n");
 IO.Put("a-b = " & Fmt.Int(a - b) & "\n");
 IO.Put("a*b = " & Fmt.Int(a * b) & "\n");
 IO.Put("a DIV b = " & Fmt.Int(a DIV b) & "\n");
 IO.Put("a MOD b = " & Fmt.Int(a MOD b) & "\n");

END Arith.</lang>

OCaml

<lang ocaml>let _ = 

 let a = read_int ()
 and b = read_int () in

 Printf.printf "a + b = %d\n" (a + b);
 Printf.printf "a - b = %d\n" (a - b);
 Printf.printf "a * b = %d\n" (a * b);
 Printf.printf "a / b = %d\n" (a / b);
 Printf.printf "a mod b = %d\n" (a mod b)</lang>

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

Works with: Perl version 5.x

<lang 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"
   ;</lang>

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

<lang 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) # or x // y for newer python versions. print "Remainder: %d" % (x % y)

    1. Only used to keep the display up when the program ends

raw_input( )</lang>

Notes: In Python3 raw_input() will be renamed to input() (the old input() built-in will go away, though one could use eval(input()) to emulate the old ... and ill-advised ... behavior). Also a better program would wrap the attempted int() conversions in a try: ... except ValueError:... construct such as:

<lang python> def getnum(prompt): 

   while True: # retrying ...
       try:
           n = int(raw_input(prompt))
       except ValueError:
           print "Input could not be parsed as an integer. Please try again."\
           continue
       break
   return n

x = getnum("Number1: ") y = getnum("Number2: ") ... </lang>

(In general it's good practice to perform parsing of all input in exception handling blocks. This is especially true of interactive user input, but also applies to data read from configuration and other files, and marshaled from other processes via any IPC mechanism).

Python also has the procedure divmod that returns both quotient and remainder. eg 

quotient, remainder = divmod(355,113)

Giving a quotient of 3, and a remainder of 16.

Python 3.0 compatible code

<lang python>def arithmetic(x, y): 

   for op in "+ - * // %".split():
       expr = "%(x)s %(op)s %(y)s" % vars()
       print("%s\t=> %s" % (expr, eval(expr)))


arithmetic(12, 8) arithmetic(input("Number 1: "), input("Number 2: "))</lang> Output: 

12 + 8  => 20
12 - 8  => 4
12 * 8  => 96
12 // 8 => 1
12 % 8  => 4
Number 1: 20
Number 2: 4
20 + 4  => 24
20 - 4  => 16
20 * 4  => 80
20 // 4 => 5
20 % 4  => 0

Raven

'  Number 1: ' print expect 0 prefer as x
'  Number 2: ' print expect 0 prefer as y

x y + "       sum: %d\n" print
x y - "difference: %d\n" print
x y * "   product: %d\n" print
x y / "  quotient: %d\n" print
x y % " remainder: %d\n" print

Ruby

<lang 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}"</lang>

Scheme

<lang 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)</lang> 

 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 different way 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

UNIX Shell

With external utilities:

Works with: Bourne shell
 #!/bin/sh
 read a; read b;
 echo "a+b     = "  `expr $a  +  $b`
 echo "a-b     = "  `expr $a  -  $b`
 echo "a*b     = "  `expr $a \*  $b`
 echo "a mod b = "  `expr $a  %  $b`

(Notes: Using the ` (backtick operators, also available in most Bourne shells via the $(...) syntax) allows us to keep the results on their labels in the most efficient and portable way. The spaces around the operators in the expr command line arguments are required and the shell requires us to quote or escape the * character has shown, to prevent any possible "globbing" --- filename expansion of the * as a wildcard character.

With SUSv3 parameter expansions:

Works with: Almquist SHell
Works with: Bourne Again SHell version 3.2
Works with: Korn SHell version 5.2.14
Works with: Z SHell
 #!/bin/sh
 read a; read b;
 echo "a+b     = $(($a+$b))"
 echo "a-b     = $(($a-$b))"
 echo "a*b     = $(($a*$b))"
 echo "a mod b = $(($a%$b))"

(Note: spaces inside the $((...)) are optional and not required; the $((...)) expressions can be inside the double quotes, but the `...` expressions could also have been enclosed in the double quotes in the previous example).

Vedit macro language

 #1 = Get_Num("Give number a: ")
 #2 = Get_Num("Give number b: ")
 Message("a + b = ") Num_Type(#1 + #2)
 Message("a - b = ") Num_Type(#1 - #2)
 Message("a * b = ") Num_Type(#1 * #2)
 Message("a / b = ") Num_Type(#1 / #2)
 Message("a % b = ") Num_Type(#1 % #2)

Visual Basic .NET

 Imports System.Console
 Module Module1
   Sub Main
     Dim a = CInt(ReadLine)
     Dim b = CInt(ReadLine)
     WriteLine("Sum " & a + b)
     WriteLine("Difference " & a - b)
     WriteLine("Product " & a - b)
     WriteLine("Quotient " & a / b)
     WriteLine("Integer Quotient " & a \ b)
     WriteLine("Remainder " & a Mod b)
   End Sub
 End Module

XSLT

<xsl:template name="arithmetic">
  <xsl:param name="a">5</xsl:param>
  <xsl:param name="b">2</xsl:param>
  <fo:block>a + b = <xsl:value-of select="$a + $b"/></fo:block>
  <fo:block>a - b = <xsl:value-of select="$a - $b"/></fo:block>
  <fo:block>a * b = <xsl:value-of select="$a * $b"/></fo:block>
  <fo:block>a / b = <xsl:value-of select="round($a div $b)"/></fo:block>
  <fo:block>a mod b = <xsl:value-of select="$a mod $b"/></fo:block>
</xsl:template>
Retrieved from "https://rosettacode.org/wiki/Arithmetic/Integer?oldid=31105"