zettacode 0.1.0 → 0.1.1

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

@@ -1,43 +1,43 @@
        IDENTIFICATION DIVISION.
-       PROGRAM-ID. I-Ac.
+       PROGRAM-ID. Int-Arithmetic.
 
        DATA DIVISION.
        WORKING-STORAGE SECTION.
 
        01 A      PIC S9(10).
        01 B      PIC S9(10).
-       01 Ru PIC S9(10).
+       01 Result PIC S9(10).
 
        PROCEDURE DIVISION.
-           DISPLAY "F ub: " WITH NO ADVANCING
+           DISPLAY "First number: " WITH NO ADVANCING
            ACCEPT A
-           DISPLAY "Sc ub: " WITH NO ADVANCING
+           DISPLAY "Second number: " WITH NO ADVANCING
            ACCEPT B
            
-*          * N: T u ADDSUBTRACTc.  c b
-*          * c  COMPUTE , c  
-*          *   b f    u,
-*          * .. COMPUTE Ru = A + 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 Ru
-           DISPLAY "A + B = " Ru
+           ADD A TO B GIVING Result
+           DISPLAY "A + B = " Result
 
-           SUBTRACT B FROM A GIVING Ru
-           DISPLAY "A - B = " Ru
+           SUBTRACT B FROM A GIVING Result
+           DISPLAY "A - B = " Result
 
-           MULTIPLY A BY B GIVING Ru
-           DISPLAY "A * B = " Ru
+           MULTIPLY A BY B GIVING Result
+           DISPLAY "A * B = " Result
 
-*          * D  uc  z. DIVIDE c  
-*          * ROUNDED cu, c  u  u   
-*          * .
-           DIVIDE A BY B GIVING Ru
-           DISPLAY "A  B = " Ru
+*          *> 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 Ru = A ^ B
-           DISPLAY "A ^ B = " Ru
+           COMPUTE Result = A ^ B
+           DISPLAY "A ^ B = " Result
        
-*          * Mc  f f u.
+*          *> Matches sign of first argument.
            DISPLAY "A % B = " FUNCTION REM(A, B)
 
            GOBACK

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

@@ -1,29 +1,29 @@
 
-(dfu mc (moo ( (d *qu-o*)) (b (d *qu-o*)))
-  (c
-    (b ()
-      (f  "~ = ~~%" (   b) (fuc (b-fuc )  b)))
-    '(+ - *   f c uc u ))
-  (u))
+(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))
 
-C L'   fuc  cfc, ccc, cucc,  cuc. T ff    u  qu.
+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.
 
-{| c="b"
-! T fuc !! u  qu 
+{| class="wikitable"
+! The function !! rounds its quotient towards
 |-
-! cfc
-|  f
+! <code>floor</code>
+| negative infinity
 |-
-! ccc
-|  f
+! <code>ceiling</code>
+| positive infinity
 |-
-! cucc
-| z
+! <code>truncate</code>
+| zero
 |-
-! cuc
-|    (f    f  c qu  qu f  )
+! <code>round</code>
+| the nearest integer (preferring the even integer if the mathematical quotient is equidistant from two integers)
 |}
 
-Ec fuc  u     c u, uc 
-  qu *  +  =  .
-c(  b)c  c(  b)c u ub qu   c u f c(f  b)c  c(uc  b)c, c.
+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/zettacode.files/arithmetic.integer/component_pascal.txt

@@ -1,32 +1,32 @@
-W  G P C Pc
+Works with Gardens Point Component Pascal
 
-MODULE Ac
-IMPORT CP,C,RTS
+MODULE Arithmetic;
+IMPORT CPmain,Console,RTS;
 
 VAR
-   ,	  : INTEGER
-   	  : ARRAY 128 OF CHAR
-   u : BOOLEAN
+   x,y	  : INTEGER;
+   arg	  : ARRAY 128 OF CHAR;
+   status : BOOLEAN;
    
 
-PROCEDURE E(IN  : ARRAY OF CHAR)
+PROCEDURE Error(IN str : ARRAY OF CHAR);
 BEGIN
-   C.WS()C.WL
+   Console.WriteString(str);Console.WriteLn;
    HALT(1)
-END E
+END Error;
 
 
 BEGIN
-   IF CP.ANub()  2 THEN E("G   !") END
-   CP.GA(0,) RTS.STI(,,u)
-   IF ~u THEN E("C' c 	'"++"'  I") END
-   CP.GA(1,) RTS.STI(,,u)
-   IF ~u THEN E("C' c '"++"'  I") END
-   C.WS(" +  ")C.WI( + ,6)C.WL
-   C.WS(" -  ")C.WI( - ,6)C.WL
-   C.WS(" *  ")C.WI( * ,6)C.WL
-   C.WS("   ")C.WI( DIV ,6)C.WL
-   C.WS(" MOD  ")C.WI( MOD ,6)C.WL
-END Ac.
+   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.
 
-c: cu Ac 12 23b
+command: <i>cprun Arithmetic 12 23</i><br/>

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

@@ -1,11 +1,11 @@
- = .o_!.o_64
-b = ._!._64
+a = gets.not_nil!.to_i64
+b = gets.not_nil!.to_i64
 
-u "Su: #{ + b}"
-u "Dffc: #{ - b}"
-u "Puc: #{ * b}"
-u "Qu (f ): #{  b}"  #   u  f.
-u "Qu (f ): #{  b}"
-u "R: #{ % b}" # S f  c  f  c  (b).
-u "P: #{ ** b}"    # I c  b     .
+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/zettacode.files/arithmetic.integer/d.txt

@@ -1,17 +1,17 @@
-mo d.do, d., d.cov
+import std.stdio, std.string, std.conv;
 
- () {
-      = 10, b = 20
-     {
-         = ().().!()
-        b = ().().!()
-    } cc (SEc ) {}
-    (" = ", , ", b = ", b)
+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);
 
-    (" + b = ",  + b)
-    (" - b = ",  - b)
-    (" * b = ",  * b)
-    ("  b = ",   b)
-    (" % b = ",  % b)
-    (" ^^ 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/zettacode.files/arithmetic.integer/dc.txt

@@ -1,10 +1,10 @@
-[E 2  o 1 .
-  U c  . E: 2 3
-  U uc f  . E: _10
-]P ? b 
-[: ]P  b +  z
-[ub: ]P  b -  z
-[u: ]P  b *  z
-[: ]P  b   z  [uc  z]z
-[: ]P  b %  z  [ c f ]z
-[: ]P  b ^  z
+[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/zettacode.files/arithmetic.integer/dcl.txt

@@ -1,8 +1,8 @@
-$ qu  "E f umb"
-$  = f$(  )
-$ qu b "E c ub"
-$ b = f$( b )
-$  $uu " + b = ",  + b
-$  $uu " - b = ",  - b
-$  $uu " * b = ",  * b
-$  $uu "  b = ",   b  ! uc 
+$ 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/zettacode.files/arithmetic.integer/delphi.txt

@@ -1,19 +1,19 @@
-om IAmc
+program IntegerArithmetic;
 
 {$APPTYPE CONSOLE}
 
-u SU, M
+uses SysUtils, Math;
 
+var
+  a, b: Integer;
+begin
+  a := StrToInt(ParamStr(1));
+  b := StrToInt(ParamStr(2));
 
-  , b: I
-b
-   := STI(PS(1))
-  b := STI(PS(2))
-
-  WL(F('% + % = %', [, b,  + b]))
-  WL(F('% - % = %', [, b,  - b]))
-  WL(F('% * % = %', [, b,  * b]))
-  WL(F('%  % = %', [, b,   b]))  u  0
-  WL(F('% %% % = %', [, b,   b]))  c  f  f 
-  WL(F('% ^ % = %', [, b, Tuc(P(, 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 * 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/zettacode.files/arithmetic.integer/dwscript.txt

@@ -1,9 +1,9 @@
-v  := SToI(PmS(0))
- b := STI(PS(1))
+var a := StrToInt(ParamStr(0));
+var b := StrToInt(ParamStr(1));
 
-PL(F('% + % = %', [, b,  + b]))
-PL(F('% - % = %', [, b,  - b]))
-PL(F('% * % = %', [, b,  * b]))
-PL(F('%  % = %', [, b,   b])) 
-PL(F('%  % = %', [, b,   b])) 
-PL(F('% ^ % = %', [, b, Tuc(P(, 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 * 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/zettacode.files/arithmetic.integer/dyalect.txt

@@ -1,13 +1,13 @@
 
-{{|Sf}}
+{{trans|Swift}}
 
-Dc    f .
+Dyalect has no operator for exponential.
 
-  = 6 
- b = 4
+let a = 6 
+let b = 4
  
-("u = \(+b)")
-("ffc = \(-b)")
-("uc = \(*b)")
-("I qu = \(b)")
-("R = \(%b)")
+print("sum = \(a+b)")
+print("difference = \(a-b)")
+print("product = \(a*b)")
+print("Integer quotient = \(a/b)")
+print("Remainder = \(a%b)")

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

@@ -1,9 +1,9 @@
 
-df mc( :, b :) {
-  u `$\
-   Su:        ${ + b}
-   Dffc: ${ - b}
-   Puc:    ${ * b}
-   Qu:   ${  b}
-   R:  ${ % b}$\`
+def arithmetic(a :int, b :int) {
+  return `$\
+   Sum:        ${a + b}
+   Difference: ${a - b}
+   Product:    ${a * b}
+   Quotient:   ${a // b}
+   Remainder:  ${a % b}$\n`
 }

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

@@ -1,9 +1,9 @@
 
- = umb u
-b = ub u
-  + b
-  - b
-  * b
-   b
-   b
-   b
+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/zettacode.files/arithmetic.integer/ecl.txt

@@ -1,33 +1,33 @@
 
-AcD(INTEGER A,INTEGER B) := FUNCTION
-  ADD       := A + B
-  SUBTRACT  := A - B
-  MULTIPLY  := A * B
-  INTDIVIDE := A DIV B INTEGER DIVISION
-  DIVIDE    := A  B    
-  R   := A % B
-  EXP       := POWER(A,B)
-  DS          := DATASET([{A,B,'A PLUS B :',ADD},
-                          {A,B,'A MINUS B :',SUBTRACT},
-			  {A,B,'A TIMES B :',MULTIPLY},
-			  {A,B,'A INT DIVIDE BY B :',INTDIVIDE},
-			  {A,B,'REMAINDER :',R},
-			  {A,B,'A DIVIDE BY B :',DIVIDE},
-			  {A,B,'A RAISED TO B:',EXP}],
-			  {INTEGER AV,INTEGER BV,STRING18 u,STRING })
+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
+  RETURN DS;
+  END;
 	
-AcD(1,1)
-AcD(2,2)
-AcD(50,5)
-AcD(10,3)
-AcD(-1,2)
+ArithmeticDemo(1,1);
+ArithmeticDemo(2,2);
+ArithmeticDemo(50,5);
+ArithmeticDemo(10,3);
+ArithmeticDemo(-1,2);
 	
-* 	NOTE:D b z fu    z u (0), 
-   	    “ b z” . 
-   	T    uc  b   jb. 
-   	T fu b c b c
-*
+/* 	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/zettacode.files/arithmetic.integer/efene.txt

@@ -1,16 +1,16 @@
 
-@ubc
-u = f () {
+@public
+run = fn () {
 
-    F = ._("F ub: ")
-    Sc = ._("Sc ub: ")
+    First = io.get_line("First number: ")
+    Second = io.get_line("Second number: ")
 
-    A = __(.($\, F))
-    B = __(.($\, Sc))
+    A = list_to_integer(lists.delete($\n, First))
+    B = list_to_integer(lists.delete($\n, Second))
 
-    .f("Su: ~~", [A + B])
-    .f("Dffc: ~~", [A - B])
-    .f("Puc: ~~", [A * B])
-    .f("Qu: ~~", [A  B])
-    .f("R: ~~", [A % B])
+    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/zettacode.files/arithmetic.integer/eiffel.txt

@@ -1,32 +1,32 @@
-{{ |SEff|2.4}}
-I  f c .:
-c MAIN
-    c 
-    fu  
-        c
-            , b: REAL
-        
-            (" = ")
-            ._
-             := ._
+{{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;
 
-            ("b = ")
-            ._
-            b := ._
+            print("b = ");
+            io.read_real;
+            b := io.last_real;
 
-            (" + b = ")
-            .u_( + b)
-            ("%N - b = ")
-            .u_( - b)
-            ("%N * b = ")
-            .u_( * b)
-            ("%N  b = ")
-            .u_(  b)
-            ("%N %% b = ")
-            .u_(((  b) - (  b).f) * b)
-            ("%N ^ b = ")
-            .u_(.(b))
-            ("%N")
-        
-
-N   cu   bu u  (\\). H,   b  u  uc  SEff.
+            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/zettacode.files/arithmetic.integer/elena.txt

@@ -1,16 +1,16 @@
-ELENA 4. :
-mo m'm
- 
+ELENA 4.x :
+import system'math;
+import extensions;
 
-ubc ()
+public program()
 {
-      := c.LT( I())
-     b := c.LT( I())
+    var a := console.loadLineTo(new Integer());
+    var b := console.loadLineTo(new Integer());
     
-    c.L(," + ",b," = ", + b)
-    c.L(," - ",b," = ", - b)
-    c.L(," * ",b," = ", * b)
-    c.L(,"  ",b," = ",  b)    uc  0
-    c.L(," % ",b," = ",.:b)  c  f f 
-    c.L(," ^ ",b," = ", ^ b)
+    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/zettacode.files/arithmetic.integer/elixir.txt

@@ -1,26 +1,26 @@
-{{ |E|1.4}}
-dfmodu Amc_I do
-  # Fuc    b  c   
-  f _() 
-    IO.() | S. | S._
+{{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
   
-  
-  f  
-    # G u u
-     = _("E u f : ") 
-    b = _("E u c : ")
+  def task do
+    # Get user input
+    a = get_int("Enter your first integer: ") 
+    b = get_int("Enter your second integer: ")
     
-    IO.u "E I Ac:\"
-    IO.u "Su:            #{ + b}"
-    IO.u "Dffc:     #{ - b}"
-    IO.u "Puc:        #{ * b}"
-    IO.u "Tu D:  #{  b}"                  # F
-    IO.u "D:       #{(,b)}"               # Tuc T 0
-    IO.u "F D: #{I.f_(,b)}" # f  
-    IO.u "R:      #{(,b)}"               # S f f 
-    IO.u "Mu:         #{I.(,b)}"       # u  (u f )
-    IO.u "E:       #{:.(,b)}"         # F, u E' :
-  
-
+    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
 
-Ac_I.
+Arithmetic_Integer.task