zettacode 0.1.0 → 0.1.1

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

@@ -1,13 +1,13 @@
-c BcIAmc {
-    ubc c fuc () {
-          =S.()
-        f (.  2) u
-          = S.F([0])
-         b = S.F([1])
-        c("+b = " + (+b))
-        c("-b = " + (-b))
-        c("*b = " + (*b))
-        c("b = " + (b))
-        c("%b = " + (%b))
+class BasicIntegerArithmetic {
+    public static function main() {
+        var args =Sys.args();
+        if (args.length < 2) return;
+        var a = Std.parseFloat(args[0]);
+        var b = Std.parseFloat(args[1]);
+        trace("a+b = " + (a+b));
+        trace("a-b = " + (a-b));
+        trace("a*b = " + (a*b));
+        trace("a/b = " + (a/b));
+        trace("a%b = " + (a%b));
     }
 }

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

@@ -1,26 +1,26 @@
-A uc  8-b-f. C  b INT, NINT, FLOOR, CEILING,  F IO
-DLG(Ed=A, Ed=B, TI='E umc A d B')
-WRITE(N) A, B
+All numeric is 8-byte-float. Conversions are by INT, NINT, FLOOR, CEILING, or Formatted IO
+DLG(Edit=A, Edit=B, TItle='Enter numeric A and B')
+WRITE(Name) A, B
 WRITE() '              A + B = ', A + B
 WRITE() '              A - B = ', A - B
 WRITE() '              A * B = ', A * B
-WRITE() '              A  B = ', A  B          !  uc
-WRITE() 'uc      A  B = ', INT(A  B)     ! uc  0
-WRITE() 'u     A  B = ', NINT(A  B)    ! uc   
-WRITE() 'u     A  B = ', FLOOR(A  B)   ! uc  u f
-WRITE() 'u u      A  B = ', CEILING(A  B) ! uc  u f
-WRITE() ' f  A  B = ', MOD(A, B)      !    A
-WRITE() 'A    f B = ', A ^ B
-WRITE() 'A    f B = ', A ** B
-A=5 B=-4
+WRITE() '              A / B = ', A / B          ! no truncation
+WRITE() 'truncate      A / B = ', INT(A / B)     ! truncates towards 0
+WRITE() 'round next    A / B = ', NINT(A / B)    ! truncates towards next integer
+WRITE() 'round down    A / B = ', FLOOR(A / B)   ! truncates towards minus infinity
+WRITE() 'round up      A / B = ', CEILING(A / B) ! truncates towards plus infinity
+WRITE() 'remainder of  A / B = ', MOD(A, B)      ! same sign as A
+WRITE() 'A to the power of B = ', A ^ B
+WRITE() 'A to the power of B = ', A ** B
+A=5; B=-4;
               A + B = 1 
               A - B = 9 
               A * B = -20 
-              A  B = -1.25 
-uc      A  B = -1 
-u     A  B = -1 
-u     A  B = -2 
-u u      A  B = -1 
- f  A  B = 1 
-A    f B = 16E-4 
-A    f B = 16E-4 
+              A / B = -1.25 
+truncate      A / B = -1 
+round next    A / B = -1 
+round down    A / B = -2 
+round up      A / B = -1 
+remainder of  A / B = 1 
+A to the power of B = 16E-4 
+A to the power of B = 16E-4 

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

@@ -1,14 +1,14 @@
-I64 *, *b
- = S2I64(GS("E u f ub: "))
-b = S2I64(GS("E u c ub: "))
+I64 *a, *b;
+a = Str2I64(GetStr("Enter your first number: "));
+b = Str2I64(GetStr("Enter your second number: "));
 
-f (b == 0)
-  P("E: T c ub u  b z.\")
- {
-  P(" + b = %\",  + b)
-  P(" - b = %\",  - b)
-  P(" * b = %\",  * b)
-  P("  b = %\",   b) * u  *
-  P(" % b = %\",  % b) *    f  *
-  P(" ` b = %\",  ` b)
+if (b == 0)
+  Print("Error: The second number must not be zero.\n");
+else {
+  Print("a + b = %d\n", a + b);
+  Print("a - b = %d\n", a - b);
+  Print("a * b = %d\n", a * b);
+  Print("a / b = %d\n", a / b); /* rounds down */
+  Print("a % b = %d\n", a % b); /* same sign as first operand */
+  Print("a ` b = %d\n", a ` b);
 }

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

@@ -1,11 +1,11 @@
-m
-	 $= ((' ')) 
-	b $= (('\')) 
+main
+	a $= integer(in(' ')); ignore
+	b $= integer(in('\n')); ignore
 	
-	("Su:"		,  + b)
-	("Dffc:",  - b)
-	("Puc:"	,  * b)
-	("Qu:"	,   b)  u  z
-	("Muu:"	,  % b)     f 
-	("E:"	,  ^ b)
+	print("Sum:"		, a + b)
+	print("Difference:", a - b)
+	print("Product:"	, a * b)
+	print("Quotient:"	, a / b) // rounds towards zero
+	print("Modulus:"	, a % b) // same sign as first operand
+	print("Exponent:"	, a ^ b)
 }

data/zettacode.files/arithmetic.integer/icon}}_and_{{header|unicon.txt

@@ -1,13 +1,13 @@
-ocdu m()
-("Iu 1   := ")
- := (())
-("Iu 2  b := ")
-b := (())
-
-("  + b = ",+b)
-("  - b = ",-b)
-("  * b = ",*b)
-("   b = ",b, " u  0")
-("  % b = ",%b, "   c ")
-("  ^ b = ",^b)
+procedure main()
+writes("Input 1st integer a := ")
+a := integer(read())
+writes("Input 2nd integer b := ")
+b := integer(read())
 
+write(" a + b = ",a+b)
+write(" a - b = ",a-b)
+write(" a * b = ",a*b)
+write(" a / b = ",a/b, " rounds toward 0")
+write(" a % b = ",a%b, " remainder sign matches a")
+write(" a ^ b = ",a^b)
+end

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

@@ -1,27 +1,27 @@
 
-E Two Numb   oom.
+Enter Two Numbers is a room.
 
-Nuc    c    ub. U "[ub]"  uc .
+Numerically entering is an action applying to one number. Understand "[number]" as numerically entering.
 
-T f ub   ub  .
+The first number is a number that varies.
 
-Af uc  f  f :
-	  f ub   ub u.
+After numerically entering for the first time:
+	now the first number is the number understood.
 
-Af uc  f  c :
-	 A b  f ub
-	 B b  ub u
-	 "[A] + [B] = [A + B]." [ ]
-	 "[A] - [B] = [A u B]." [E ]
-	 P b  b P = A * B  P   ub [ qu]
-	 "[A] * [B] = [P]."
-	 Q b  b  D Fu [ qu]
-	 "[A]  [B] = [Q]."
-	 "[A]  [B] = [ f  A b B]."
-	  .
+After numerically entering for the second time:
+	let A be the first number;
+	let B be the number understood;
+	say "[A] + [B] = [A + B]."; [operator syntax]
+	say "[A] - [B] = [A minus B]."; [English syntax]
+	let P be given by P = A * B where P is a number; [inline equation]
+	say "[A] * [B] = [P].";
+	let Q be given by the Division Formula; [named equation]
+	say "[A] / [B] = [Q].";
+	say "[A] mod [B] = [remainder after dividing A by B].";
+	end the story.
 
-Equ - D Fu
-	Q = A  B
- Q   ub, A   ub,  B   ub.
+Equation - Division Formula
+	Q = A / B
+where Q is a number, A is a number, and B is a number.
 
-T u  fu : c , E ,  qu,   qu. D u  z,          qu.
+This solution shows four syntaxes: mathematical operators, English operators, inline equations, and named equations. Division rounds toward zero, and the remainder has the same sign as the quotient.

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

@@ -1,18 +1,18 @@
-cc =:    + , - , * , .@% , |~ , ^
-T fuc cccc cuc   f uc u f  . T  f    u  (c.@%.c) u  (  f),    cb      u .
-   17 cc 3
+calc =:    + , - , * , <.@% , |~ , ^
+The function <code>calc</code> constructs a list of numeric results for this task. The implementation of integer division we use here (<code><.@%.</code>) rounds down (towards negative infinity), and this is compatible with the remainder implementation we use here.
+   17 calc 3
 20 14 51 5 2 4913
 
-T fuc cbc b  u, u:
+The function <code>bia</code> assembles these results, textually:
 
-b  =: ].2 'Sum: Dffc: Poduc: Quo: Rmd: Eoo: '
-cb =: ,. ":@,.
-b     =: b cb cc
+labels  =: ];.2 'Sum: Difference: Product: Quotient: Remainder: Exponentiation: '
+combine =: ,. ":@,.
+bia     =: labels combine calc
 
-   17 b 3
-Su:              20
-Dffc:       14
-Puc:          51
-Qu:          5
-R:         2
-E: 4913
+   17 bia 3
+Sum:              20
+Difference:       14
+Product:          51
+Quotient:          5
+Remainder:         2
+Exponentiation: 4913

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

@@ -1,22 +1,22 @@
-mo jv.u.Sc
+import java.util.Scanner;
 
-ubc c IAc {
-    ubc c  (S[] ) {
-         G  2 ub f c  u
-        Sc c =  Sc(S.)
-          = c.I()
-         b = c.I()
+public class IntegerArithmetic {
+    public static void main(String[] args) {
+        // Get the 2 numbers from command line arguments
+        Scanner sc = new Scanner(System.in);
+        int a = sc.nextInt();
+        int b = sc.nextInt();
 
-         u =  + b         T u f  ''  'b' (N:    cu    u  cfu   cc)
-         ffc =  - b  T u f ubc 'b' f ''
-         uc =  * b     T u f u ''  'b'
-          =   b    T u f  '' b 'b' (N: ''   c  fc u)
-          =  % b   T  f  '' b 'b'
+        int sum = a + b;        // The result of adding 'a' and 'b' (Note: integer addition is discouraged in print statements due to confusion with string concatenation)
+        int difference = a - b; // The result of subtracting 'b' from 'a'
+        int product = a * b;    // The result of multiplying 'a' and 'b'
+        int division = a / b;   // The result of dividing 'a' by 'b' (Note: 'division' does not contain the fractional result)
+        int remainder = a % b;  // The remainder of dividing 'a' by 'b'
 
-        S.u.(" + b = " + u)
-        S.u.(" - b = " + ffc)
-        S.u.(" * b = " + uc)
-        S.u.("qu f   b = " + )    uc  0
-        S.u.(" f   b = " + )       f 
+        System.out.println("a + b = " + sum);
+        System.out.println("a - b = " + difference);
+        System.out.println("a * b = " + product);
+        System.out.println("quotient of a / b = " + division);   // truncates towards 0
+        System.out.println("remainder of a / b = " + remainder);   // same sign as first operand
     }
 }

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

@@ -1,30 +1,30 @@
-===WSc===
-{{ |JSc}}
-{{ |SM}}
-N          f JSc  qu f cfc       u u.
-v  = I(_u("E  "), 10)
- b = I(_u("E  "), 10)
+===WScript===
+{{works with|JScript}}
+{{works with|SpiderMonkey}}
+Note that the operators work the same in all versions of JavaScript; the requirement for specific implementations is in order to get user input.
+var a = parseInt(get_input("Enter an integer"), 10);
+var b = parseInt(get_input("Enter an integer"), 10);
 
-WSc.Ec(" = " + )
-WSc.Ec("b = " + b)
-WSc.Ec("u:  + b = "        + ( + b))
-WSc.Ec("ffc:  - b = " + ( - b))
-WSc.Ec("uc:  * b = "    + ( * b))
-WSc.Ec("qu:   b = "   + (  b | 0))  "| 0" c    
-WSc.Ec(":  % b = "  + ( % b))
+WScript.Echo("a = " + a);
+WScript.Echo("b = " + b);
+WScript.Echo("sum: a + b = "        + (a + b));
+WScript.Echo("difference: a - b = " + (a - b));
+WScript.Echo("product: a * b = "    + (a * b));
+WScript.Echo("quotient: a / b = "   + (a / b | 0)); // "| 0" casts it to an integer
+WScript.Echo("remainder: a % b = "  + (a % b));
 
-fuc _u() {
-    uu()
-     {
-        u WSc.SI.L()
-    } cc() {
-        u ()
+function get_input(prompt) {
+    output(prompt);
+    try {
+        return WScript.StdIn.readLine();
+    } catch(e) {
+        return readline();
     }
 }
-fuc uu() {
-     {
-        WSc.Ec()
-    } cc() {
-        ()
+function output(prompt) {
+    try {
+        WScript.Echo(prompt);
+    } catch(e) {
+        print(prompt);
     }
 }

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

@@ -1,17 +1,17 @@
-# L wc do o v wo   kd:
+# Lines which do not have two integers are skipped:
 
-f c:
-  (" ") | c(  0) | (ub)
-  | f   1 
-    .[0]  $ | .[1]  $b
-    | "F  = \($)  b = \($b):\" +
-      " + b = \($ + $b)\" +
-      " - b = \($ - $b)\" +
-      " * b = \($ * $b)\" +
-      "b|f = \($  $b | f)\" +
-      " % b = \($ % $b)\" +
-      " |  = \($ | )\"
-     
-     
+def arithmetic:
+  split(" ") | select(length > 0) | map(tonumber)
+  | if length > 1 then
+    .[0] as $a | .[1] as $b
+    | "For a = \($a) and b = \($b):\n" +
+      "a + b = \($a + $b)\n" +
+      "a - b = \($a - $b)\n" +
+      "a * b = \($a * $b)\n" +
+      "a/b|floor = \($a / $b | floor)\n" +
+      "a % b = \($a % $b)\n" +
+      "a | exp = \($a | exp)\n"
+    else empty
+    end ;
 
-c
+arithmetic

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

@@ -1,33 +1,33 @@
-"u c"
-* AcI,  J *
-  = c.u()
- u = .c(^\*([+-]?[0-9]+)\+([+-]?[0-9]+)\*)
-  = Nub(u[1])
- b = Nub(u[2])
+"use strict";
+/* Arthimetic/Integer, in Jsish */
+var line = console.input();
+var nums = line.match(/^\s*([+-]?[0-9]+)\s+([+-]?[0-9]+)\s*/);
+var a = Number(nums[1]);
+var b = Number(nums[2]);
 
-u("A  ", , ", B  ", b)
-u("Su               A + B  ",  + b)
-u("Dffc        A - B  ",  - b)
-u("Puc           A * B  ",  * b)
-u("I qu  A  B  ",   b | 0, " uc  0")
-u("R         A % B  ",  % b, "  f f ")
-u("E    A    B  ", M.(, b))
+puts("A is ", a, ", B is ", b);
+puts("Sum               A + B is ", a + b);
+puts("Difference        A - B is ", a - b);
+puts("Product           A * B is ", a * b);
+puts("Integer quotient  A / B is ", a / b | 0, " truncates toward 0");
+puts("Remainder         A % B is ", a % b, " sign follows first operand");
+puts("Exponentiation    A to the power B is ", Math.pow(a, b));
 
-*
+/*
 =!INPUTSTART!=
 7 4
 =!INPUTEND!=
-*
+*/
 
 
-*
+/*
 =!EXPECTSTART!=
-A   7 , B   4
-Su               A + B   11
-Dffc        A - B   3
-Puc           A * B   28
-I qu  A  B   1  uc  0
-R         A % B   3   f f 
-E    A    B   2401
+A is  7 , B is  4
+Sum               A + B is  11
+Difference        A - B is  3
+Product           A * B is  28
+Integer quotient  A / B is  1  truncates toward 0
+Remainder         A % B is  3  sign follows first operand
+Exponentiation    A to the power B is  2401
 =!EXPECTEND!=
-*
+*/

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

@@ -1,4 +1,5 @@
-fuco mc ( = (I, d()), b = (I, d()))
-  f    [+,-,*,,]
-    (" $ b = $((,b))")
-  
+function arithmetic (a = parse(Int, readline()), b = parse(Int, readline()))
+  for op in  [+,-,*,div,rem]
+    println("a $op b = $(op(a,b))")
+  end
+end

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

@@ -1,41 +1,41 @@
- vo 1.1
+// version 1.1
 
-fu (: AS) {
-      = R("""-?\+[ ]+-?\+""")
-    (u) {
-        ("E    b c()  q  qu: ")
-         u: S = L()!!.()
-        f (u == "q" || u == "Q") b
-        f (!u.c()) {
-            ("I u,  ")
-            cu
+fun main(args: Array<String>) {
+    val r = Regex("""-?\d+[ ]+-?\d+""")
+    while(true) {
+        print("Enter two integers separated by space(s) or q to quit: ")
+        val input: String = readLine()!!.trim()
+        if (input == "q" || input == "Q") break
+        if (!input.matches(r)) {
+            println("Invalid input, try again")
+            continue
         }
-          = u.IOf(' ')
-          = u.ub(0, ).E().L()
-         b = u.ub( + 1).L()
-        ("$ + $b = ${ + b}")
-        ("$ - $b = ${ - b}")
-        ("$ * $b = ${ * b}")
-        f (b != 0L) {
-            ("$  $b = ${  b}")   u  z
-            ("$ % $b = ${ % b}")   f -z, c  f f 
+        val index = input.lastIndexOf(' ')
+        val a = input.substring(0, index).trimEnd().toLong()
+        val b = input.substring(index + 1).toLong()
+        println("$a + $b = ${a + b}")
+        println("$a - $b = ${a - b}")
+        println("$a * $b = ${a * b}")
+        if (b != 0L) {
+            println("$a / $b = ${a / b}")  // rounds towards zero
+            println("$a % $b = ${a % b}")  // if non-zero, matches sign of first operand
         }
-         {
-            ("$  $b = uf")
-            ("$ % $b = uf")
+        else {
+            println("$a / $b = undefined")
+            println("$a % $b = undefined")
         }
-          = M.(.Dub(), b.Dub())
-        ("$ ^ $b = ")
-        f ( % 1.0 == 0.0) {
-            f ( = L.MIN_VALUE.Dub()   = L.MAX_VALUE.Dub())
-                ("${.L()}")
-            
-                ("u f ")
+        val d = Math.pow(a.toDouble(), b.toDouble())
+        print("$a ^ $b = ")
+        if (d % 1.0 == 0.0) {
+            if (d >= Long.MIN_VALUE.toDouble() &amp;&amp; d <= Long.MAX_VALUE.toDouble())
+                println("${d.toLong()}")
+            else
+                println("out of range")
         }
-         f (!.F())
-            (" f")
-        
-            (" ")
-        ()
+        else if (!d.isFinite())
+            println("not finite")
+        else
+            println("not integral")
+        println()
     }
 }

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

@@ -1,2 +1,2 @@
-{{VI }}b
-[[F:LbVIEW_Ac_I.]]
+{{VI snippet}}<br/>
+[[File:LabVIEW_Arithmetic_Integer.png]]

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

@@ -1,23 +1,23 @@
-T f Rc
+Translation of Racket
 
-{f c 
- {b {: :}
-  {S. {{b {: : :} 
-                  {b} :  :  : u {: : :}} : :}
-         + - *  %    =  }}}
-- c
+{def arithmetic 
+ {lambda {:x :y}
+  {S.map {{lambda {:x :y :op} 
+                  {br}applying :op on :x & :y returns {:op :x :y}} :x :y}
+         + - * / % pow max min = > <}}}
+-> arithmetic
 
-{c 8 12}
-- 
- +  8  12 u 20 
- -  8  12 u -4 
- *  8  12 u 96 
-   8  12 u 0.6666666666666666 
- %  8  12 u 8 
-   8  12 u 68719476736 
-   8  12 u 12 
-   8  12 u 8 
- =  8  12 u f 
-   8  12 u f 
-   8  12 u u
+{arithmetic 8 12}
+-> 
+applying + on 8 &amp; 12 returns 20 
+applying - on 8 &amp; 12 returns -4 
+applying * on 8 &amp; 12 returns 96 
+applying / on 8 &amp; 12 returns 0.6666666666666666 
+applying % on 8 &amp; 12 returns 8 
+applying pow on 8 &amp; 12 returns 68719476736 
+applying max on 8 &amp; 12 returns 12 
+applying min on 8 &amp; 12 returns 8 
+applying = on 8 &amp; 12 returns false 
+applying > on 8 &amp; 12 returns false 
+applying < on 8 &amp; 12 returns true
 

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

@@ -1,8 +1,8 @@
-oc( = 6, b = 4)
-# + #b  10
-# - #b  2
-# * #b  24
-#  #b  1
-# % #b  2
-_(#,#b)  1296
-_(#b,#)  4096
+local(a = 6, b = 4)
+#a + #b // 10
+#a - #b // 2
+#a * #b // 24
+#a / #b // 1
+#a % #b // 2
+math_pow(#a,#b) // 1296
+math_pow(#b,#a) // 4096