zettacode 0.1.3 → 0.1.4

data/files.zettacode2/arithmetic.integer/cobol.txt

@@ -0,0 +1,44 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. Int-Arithmetic.
+
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+
+       01 A      PIC S9(10).
+       01 B      PIC S9(10).
+       01 Result PIC S9(10).
+
+       PROCEDURE DIVISION.
+           DISPLAY "First number: " WITH NO ADVANCING
+           ACCEPT A
+           DISPLAY "Second number: " WITH NO ADVANCING
+           ACCEPT B
+           
+*          *> Note: The various ADD/SUBTRACT/etc. statements can be
+*          *> replaced with COMPUTE statements, which allow those
+*          *> operations to be defined similarly to other languages,
+*          *> e.g. COMPUTE Result = A + B
+
+           ADD A TO B GIVING Result
+           DISPLAY "A + B = " Result
+
+           SUBTRACT B FROM A GIVING Result
+           DISPLAY "A - B = " Result
+
+           MULTIPLY A BY B GIVING Result
+           DISPLAY "A * B = " Result
+
+*          *> Division here truncates towards zero. DIVIDE can take a
+*          *> ROUNDED clause, which will round the result to the nearest
+*          *> integer.
+           DIVIDE A BY B GIVING Result
+           DISPLAY "A / B = " Result
+
+           COMPUTE Result = A ^ B
+           DISPLAY "A ^ B = " Result
+       
+*          *> Matches sign of first argument.
+           DISPLAY "A % B = " FUNCTION REM(A, B)
+
+           GOBACK
+           .

data/files.zettacode2/arithmetic.integer/common_lisp.txt

@@ -0,0 +1,29 @@
+
+(defun arithmetic (&optional (a (read *query-io*)) (b (read *query-io*)))
+  (mapc
+    (lambda (op)
+      (format t "~a => ~a~%" (list op a b) (funcall (symbol-function op) a b)))
+    '(+ - * mod rem floor ceiling truncate round expt))
+  (values))
+
+Common Lisp's integer division functions are <code>floor</code>, <code>ceiling</code>, <code>truncate</code>, and <code>round</code>. They differ in how they round their quotient.
+
+{| class="wikitable"
+! The function !! rounds its quotient towards
+|-
+! <code>floor</code>
+| negative infinity
+|-
+! <code>ceiling</code>
+| positive infinity
+|-
+! <code>truncate</code>
+| zero
+|-
+! <code>round</code>
+| the nearest integer (preferring the even integer if the mathematical quotient is equidistant from two integers)
+|}
+
+Each function also returns a remainder as its secondary value, such that
+  quotient * divisor + remainder = dividend .
+<code>(mod a b)</code> and <code>(rem a b)</code> return numbers equal to the secondary values of <code>(floor a b)</code> and <code>(truncate a b)</code>, respectively.

data/files.zettacode2/arithmetic.integer/component_pascal.txt

@@ -0,0 +1,32 @@
+Works with Gardens Point Component Pascal
+
+MODULE Arithmetic;
+IMPORT CPmain,Console,RTS;
+
+VAR
+   x,y	  : INTEGER;
+   arg	  : ARRAY 128 OF CHAR;
+   status : BOOLEAN;
+   
+
+PROCEDURE Error(IN str : ARRAY OF CHAR);
+BEGIN
+   Console.WriteString(str);Console.WriteLn;
+   HALT(1)
+END Error;
+
+
+BEGIN
+   IF CPmain.ArgNumber() < 2 THEN Error("Give me two integers!") END;
+   CPmain.GetArg(0,arg); RTS.StrToInt(arg,x,status);
+   IF ~status THEN Error("Can't convert 	'"+arg+"' to Integer") END;
+   CPmain.GetArg(1,arg); RTS.StrToInt(arg,y,status);
+   IF ~status THEN Error("Can't convert '"+arg+"' to Integer") END;
+   Console.WriteString("x + y >");Console.WriteInt(x + y,6);Console.WriteLn;
+   Console.WriteString("x - y >");Console.WriteInt(x - y,6);Console.WriteLn;
+   Console.WriteString("x * y >");Console.WriteInt(x * y,6);Console.WriteLn;
+   Console.WriteString("x / y >");Console.WriteInt(x DIV y,6);Console.WriteLn;
+   Console.WriteString("x MOD y >");Console.WriteInt(x MOD y,6);Console.WriteLn;
+END Arithmetic.
+
+command: <i>cprun Arithmetic 12 23</i><br/>

data/files.zettacode2/arithmetic.integer/crystal.txt

@@ -0,0 +1,11 @@
+a = gets.not_nil!.to_i64
+b = gets.not_nil!.to_i64
+
+puts "Sum: #{a + b}"
+puts "Difference: #{a - b}"
+puts "Product: #{a * b}"
+puts "Quotient (float division): #{a / b}"  # / always returns a float.
+puts "Quotient (floor division): #{a // b}"
+puts "Remainder: #{a % b}" # Sign of remainder matches that of the second operand (b).
+puts "Power: #{a ** b}"    # Integers can only be raised to a positive exponent.
+

data/files.zettacode2/arithmetic.integer/d.txt

@@ -0,0 +1,17 @@
+import std.stdio, std.string, std.conv;
+
+void main() {
+    int a = 10, b = 20;
+    try {
+        a = readln().strip().to!int();
+        b = readln().strip().to!int();
+    } catch (StdioException e) {}
+    writeln("a = ", a, ", b = ", b);
+
+    writeln("a + b = ", a + b);
+    writeln("a - b = ", a - b);
+    writeln("a * b = ", a * b);
+    writeln("a / b = ", a / b);
+    writeln("a % b = ", a % b);
+    writeln("a ^^ b = ", a ^^ b);
+}

data/files.zettacode2/arithmetic.integer/dc.txt

@@ -0,0 +1,10 @@
+[Enter 2 integers on 1 line.
+  Use whitespace to separate. Example: 2 3
+  Use underscore for negative integers. Example: _10
+]P ? sb sa
+[add: ]P la lb + p sz
+[sub: ]P la lb - p sz
+[mul: ]P la lb * p sz
+[div: ]P la lb / p sz  [truncates toward zero]sz
+[mod: ]P la lb % p sz  [sign matches first operand]sz
+[pow: ]P la lb ^ p sz

data/files.zettacode2/arithmetic.integer/dcl.txt

@@ -0,0 +1,8 @@
+$ inquire a "Enter first number"
+$ a = f$integer( a )
+$ inquire b "Enter second number"
+$ b = f$integer( b )
+$ write sys$output "a + b = ", a + b
+$ write sys$output "a - b = ", a - b
+$ write sys$output "a * b = ", a * b
+$ write sys$output "a / b = ", a / b  ! truncates down

data/files.zettacode2/arithmetic.integer/delphi.txt

@@ -0,0 +1,19 @@
+program IntegerArithmetic;
+
+{$APPTYPE CONSOLE}
+
+uses SysUtils, Math;
+
+var
+  a, b: Integer;
+begin
+  a := StrToInt(ParamStr(1));
+  b := StrToInt(ParamStr(2));
+
+  WriteLn(Format('%d + %d = %d', [a, b, a + b]));
+  WriteLn(Format('%d - %d = %d', [a, b, a - b]));
+  WriteLn(Format('%d * %d = %d', [a, b, a * b]));
+  WriteLn(Format('%d / %d = %d', [a, b, a div b])); // rounds towards 0
+  WriteLn(Format('%d %% %d = %d', [a, b, a mod b])); // matches sign of the first operand
+  WriteLn(Format('%d ^ %d = %d', [a, b, Trunc(Power(a, b))]));
+end.

data/files.zettacode2/arithmetic.integer/dwscript.txt

@@ -0,0 +1,9 @@
+var a := StrToInt(ParamStr(0));
+var b := StrToInt(ParamStr(1));
+
+PrintLn(Format('%d + %d = %d', [a, b, a + b]));
+PrintLn(Format('%d - %d = %d', [a, b, a - b]));
+PrintLn(Format('%d * %d = %d', [a, b, a * b]));
+PrintLn(Format('%d / %d = %d', [a, b, a div b])); 
+PrintLn(Format('%d mod %d = %d', [a, b, a mod b])); 
+PrintLn(Format('%d ^ %d = %d', [a, b, Trunc(Power(a, b))]));

data/files.zettacode2/arithmetic.integer/dyalect.txt

@@ -0,0 +1,13 @@
+
+{{trans|Swift}}
+
+Dyalect has no operator for exponential.
+
+let a = 6 
+let b = 4
+ 
+print("sum = \(a+b)")
+print("difference = \(a-b)")
+print("product = \(a*b)")
+print("Integer quotient = \(a/b)")
+print("Remainder = \(a%b)")

data/files.zettacode2/arithmetic.integer/e.txt

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

data/files.zettacode2/arithmetic.integer/easylang.txt

@@ -0,0 +1,9 @@
+
+a = number input
+b = number input
+print a + b
+print a - b
+print a * b
+print a div b
+print a mod b
+print pow a b

data/files.zettacode2/arithmetic.integer/ecl.txt

@@ -0,0 +1,33 @@
+
+ArithmeticDemo(INTEGER A,INTEGER B) := FUNCTION
+  ADDit       := A + B;
+  SUBTRACTit  := A - B;
+  MULTIPLYit  := A * B;
+  INTDIVIDEit := A DIV B; //INTEGER DIVISION
+  DIVIDEit    := A / B;   //standard division
+  Remainder   := A % B;
+  EXPit       := POWER(A,B);
+  DS          := DATASET([{A,B,'A PLUS B is:',ADDit},
+                          {A,B,'A MINUS B is:',SUBTRACTit},
+			  {A,B,'A TIMES B is:',MULTIPLYit},
+			  {A,B,'A INT DIVIDE BY B is:',INTDIVIDEit},
+			  {A,B,'REMAINDER is:',Remainder},
+			  {A,B,'A DIVIDE BY B is:',DIVIDEit},
+			  {A,B,'A RAISED TO B:',EXPit}],
+			  {INTEGER AVal,INTEGER BVal,STRING18 valuetype,STRING val});
+										
+  RETURN DS;
+  END;
+	
+ArithmeticDemo(1,1);
+ArithmeticDemo(2,2);
+ArithmeticDemo(50,5);
+ArithmeticDemo(10,3);
+ArithmeticDemo(-1,2);
+	
+/* 	NOTE:Division by zero defaults to generating a zero result (0), 
+   	rather than reporting a “divide by zero” error. 
+   	This avoids invalid or unexpected data aborting a long job. 
+   	This default behavior can be changed
+*/
+

data/files.zettacode2/arithmetic.integer/efene.txt

@@ -0,0 +1,16 @@
+
+@public
+run = fn () {
+
+    First = io.get_line("First number: ")
+    Second = io.get_line("Second number: ")
+
+    A = list_to_integer(lists.delete($\n, First))
+    B = list_to_integer(lists.delete($\n, Second))
+
+    io.format("Sum: ~p~n", [A + B])
+    io.format("Difference: ~p~n", [A - B])
+    io.format("Product: ~p~n", [A * B])
+    io.format("Quotient: ~p~n", [A / B])
+    io.format("Remainder: ~p~n", [A % B])
+}

data/files.zettacode2/arithmetic.integer/eiffel.txt

@@ -0,0 +1,32 @@
+{{works with|SmartEiffel|2.4}}
+In a file called main.e:
+class MAIN
+    creation make
+    feature make is
+        local
+            a, b: REAL;
+        do
+            print("a = ");
+            io.read_real;
+            a := io.last_real;
+
+            print("b = ");
+            io.read_real;
+            b := io.last_real;
+
+            print("a + b = ");
+            io.put_real(a + b);
+            print("%Na - b = ");
+            io.put_real(a - b);
+            print("%Na * b = ");
+            io.put_real(a * b);
+            print("%Na / b = ");
+            io.put_real(a / b);
+            print("%Na %% b = ");
+            io.put_real(((a / b) - (a / b).floor) * b);
+            print("%Na ^ b = ");
+            io.put_real(a.pow(b));
+            print("%N");
+        end
+end
+Note that there actually is a builtin modulo operator (\\). However, it seems impossible to use that instruction with SmartEiffel.

data/files.zettacode2/arithmetic.integer/elena.txt

@@ -0,0 +1,16 @@
+ELENA 4.x :
+import system'math;
+import extensions;
+
+public program()
+{
+    var a := console.loadLineTo(new Integer());
+    var b := console.loadLineTo(new Integer());
+    
+    console.printLine(a," + ",b," = ",a + b);
+    console.printLine(a," - ",b," = ",a - b);
+    console.printLine(a," * ",b," = ",a * b);
+    console.printLine(a," / ",b," = ",a / b);   // truncates towards 0
+    console.printLine(a," % ",b," = ",a.mod:b); // matches sign of first operand
+    console.printLine(a," ^ ",b," = ",a ^ b);
+}

data/files.zettacode2/arithmetic.integer/elixir.txt

@@ -0,0 +1,26 @@
+{{works with|Elixir|1.4}}
+defmodule Arithmetic_Integer do
+  # Function to remove line breaks and convert string to int
+  defp get_int(msg) do
+    IO.gets(msg) |> String.strip |> String.to_integer
+  end
+  
+  def task do
+    # Get user input
+    a = get_int("Enter your first integer: ") 
+    b = get_int("Enter your second integer: ")
+    
+    IO.puts "Elixir Integer Arithmetic:\n"
+    IO.puts "Sum:            #{a + b}"
+    IO.puts "Difference:     #{a - b}"
+    IO.puts "Product:        #{a * b}"
+    IO.puts "True Division:  #{a / b}"                  # Float
+    IO.puts "Division:       #{div(a,b)}"               # Truncated Towards 0
+    IO.puts "Floor Division: #{Integer.floor_div(a,b)}" # floored integer division
+    IO.puts "Remainder:      #{rem(a,b)}"               # Sign from first digit
+    IO.puts "Modulo:         #{Integer.mod(a,b)}"       # modulo remainder (uses floored division)
+    IO.puts "Exponent:       #{:math.pow(a,b)}"         # Float, using Erlang's :math
+  end
+end
+
+Arithmetic_Integer.task

data/files.zettacode2/arithmetic.integer/emojicode.txt

@@ -0,0 +1,9 @@
+🏁🍇
+  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ x 💭 Get first number
+  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ y 💭 Get second number
+  😀 🔤Sum: 🧲x➕y🧲🔤 ❗
+  😀 🔤Difference: 🧲x➖y🧲🔤 ❗
+  😀 🔤Product: 🧲x✖️y🧲🔤 ❗
+  😀 🔤Quotient: 🧲x➗️y🧲🔤 ❗ 💭 Rounds towards 0
+  😀 🔤Remainder: 🧲x🚮️y🧲🔤 ❗ 💭 Matches sign of first operand
+🍉️

data/files.zettacode2/arithmetic.integer/erlang.txt

@@ -0,0 +1,15 @@
+% Implemented by Arjun Sunel
+-module(arith).
+-export([start/0]).
+ 
+start() ->
+   case io:fread("","~d~d") of
+       {ok, [A,B]} ->
+           io:format("Sum = ~w~n",[A+B]),
+           io:format("Difference = ~w~n",[A-B]),
+           io:format("Product = ~w~n",[A*B]),
+           io:format("Quotient = ~w~n",[A div B]),      % truncates towards zero
+           io:format("Remainder= ~w~n",[A rem B]),    % same sign as the first operand
+           halt()
+   end.
+

data/files.zettacode2/arithmetic.integer/erre.txt

@@ -0,0 +1,20 @@
+
+PROGRAM INTEGER_ARITHMETIC
+
+!
+! for rosettacode.org
+!
+
+!$INTEGER
+
+BEGIN
+  INPUT("Enter a number ",A)
+  INPUT("Enter another number ",B)
+
+  PRINT("Addition ";A;"+";B;"=";(A+B))
+  PRINT("Subtraction ";A;"-";B;"=";(A-B))
+  PRINT("Multiplication ";A;"*";B;"=";(A*B))
+  PRINT("Integer division ";A;"div";B;"=";(A DIV B))
+  PRINT("Remainder or modulo ";A;"mod";B;"=";(A MOD B))
+  PRINT("Power ";A;"^";B;"=";(A^B))
+END PROGRAM

data/files.zettacode2/arithmetic.integer/euphoria.txt

@@ -0,0 +1,13 @@
+include get.e
+
+integer a,b
+
+a = floor(prompt_number("a = ",{}))
+b = floor(prompt_number("b = ",{}))
+
+printf(1,"a + b = %d\n", a+b)
+printf(1,"a - b = %d\n", a-b)
+printf(1,"a * b = %d\n", a*b)
+printf(1,"a / b = %g\n", a/b) -- does not truncate
+printf(1,"remainder(a,b) = %d\n", remainder(a,b)) -- same sign as first operand
+printf(1,"power(a,b) = %g\n", power(a,b))

data/files.zettacode2/arithmetic.integer/excel.txt

@@ -0,0 +1,32 @@
+
+If the numbers are typed into cells A1 and B1
+
+For sum, type in C1
+
+=$A1+$B1
+
+
+For difference, type in D1
+
+=$A1-$B1
+
+
+For product, type in E1
+
+=$A1*$B1
+
+
+For quotient, type in F1
+
+=QUOTIENT($A1,$B1)
+
+
+For remainder, type in G1
+
+=MOD($A1,$B1)
+
+
+For exponentiation, type in H1
+
+=$A1^$B1
+

data/files.zettacode2/arithmetic.integer/f_sharp|f#.txt

@@ -0,0 +1,15 @@
+As F# is a functional language, we can easily create a list of pairs of the string name of a function and the function itself to iterate over printing the operation and applying the function to obtain the result:
+
+do
+  let a, b = int Sys.argv.[1], int Sys.argv.[2]
+  for str, f in ["+", ( + ); "-", ( - ); "*", ( * ); "/", ( / ); "%", ( % )] do
+    printf "%d %s %d = %d\n" a str b (f a b)
+
+For example, the output with the arguments 4 and 3 is:
+
+4 + 3 = 7
+4 - 3 = 1
+4 * 3 = 12
+4 / 3 = 1
+4 % 3 = 1
+

data/files.zettacode2/arithmetic.integer/factor.txt

@@ -0,0 +1,17 @@
+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

data/files.zettacode2/arithmetic.integer/false.txt

@@ -0,0 +1,8 @@
+12 7
+\$@$@$@$@$@$@$@$@$@$@\  { 6 copies }
+"sum = "+."
+difference = "-."
+product = "*."
+quotient = "/."
+modulus = "/*-."
+"

data/files.zettacode2/arithmetic.integer/fermat.txt

@@ -0,0 +1,10 @@
+Integer division rounds towards zero; remainders are always positive regardless of the signs of the numbers.
+
+?a;
+?b;
+!!('Sum:              a+b=',a+b);
+!!('Difference:       a-b=',a-b);
+!!('Product:          a*b=',a*b);
+!!('Integer quotient: a\b=',a\b);
+!!('Remainder:        a|b=',a|b);
+!!('Exponentiation:   a^b=',a^b);

data/files.zettacode2/arithmetic.integer/forth.txt

@@ -0,0 +1,19 @@
+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 ;
+
+Different host systems have different native signed division behavior. ANS Forth defines two primitive double-precision signed division operations, from which the implementation may choose the most natural to implement the basic divide operations ( / , /mod , mod , */ ). This is partly due to differing specifications in the two previous standards, Forth-79 and Forth-83.
+
+FM/MOD ( d n -- mod div )   \ floored
+SM/REM ( d n -- rem div )   \ symmetric
+M* ( n n -- d )
+
+In addition, there are unsigned variants.
+
+UM/MOD ( ud u -- umod udiv )
+UM* ( u u -- ud )

data/files.zettacode2/arithmetic.integer/fortran.txt

@@ -0,0 +1,15 @@
+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

data/files.zettacode2/arithmetic.integer/freebasic.txt

@@ -0,0 +1,18 @@
+' FB 1.05.0 Win64
+
+Dim As Integer i, j
+Input "Enter two integers separated by a comma"; i, j
+Print i;" + "; j; " = "; i + j
+Print i;" - "; j; " = "; i - j
+Print i;" * "; j; " = "; i * j
+Print i;" / "; j; " = "; i \ j
+Print i;" % "; j; " = "; i Mod j 
+Print i;" ^ "; j; " = "; i ^ j
+Sleep
+
+' Integer division (for which FB uses the '\' operator) rounds towards zero
+
+' Remainder (for which FB uses the Mod operator) will, if non-zero, match the sign
+' of the first operand
+
+Sample input and output:-

data/files.zettacode2/arithmetic.integer/friendly_interactive_shell.txt

@@ -0,0 +1,10 @@
+
+read a
+read b
+echo 'a + b =' (math "$a + $b") # Sum
+echo 'a - b =' (math "$a - $b") # Difference
+echo 'a * b =' (math "$a * $b") # Product
+echo 'a / b =' (math "$a / $b") # Integer quotient
+echo 'a % b =' (math "$a % $b") # Remainder
+echo 'a ^ b =' (math "$a ^ $b") # Exponentation
+

data/files.zettacode2/arithmetic.integer/frink.txt

@@ -0,0 +1,10 @@
+This demonstrates normal division (which produces rational numbers when possible), <CODE>div</CODE>, and <CODE>mod</CODE>.  <CODE>div</CODE> rounds toward negative infinity (defined as <CODE>floor[x/y]</CODE>).  <CODE>mod</CODE> uses the sign of the second number (defined as <CODE>x - y * floor[x/y]</CODE>).  All operators automatically produce big integers or exact rational numbers when necessary.
+
+[a,b] = input["Enter numbers",["a","b"]]
+ops=["+", "-", "*", "/", "div" ,"mod" ,"^"]
+for op = ops
+{
+   str = "$a $op $b"
+   println["$str = " + eval[str]]
+}
+