zettacode 0.1.0 → 0.1.1

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

@@ -1,28 +1,28 @@
-{{ |GNU S}}
-|  b |
-'Iu ub : ' .
- := ( L) I.
-'Iu ub b: ' .
-b := ( L) I.
-('+b=%1' % {  + b }) N.
-('-b=%1' % {  - b }) N.
-('*b=%1' % {  * b }) N.
-('b=%1' % {   b }) N.
-('%%b=%1' % {  \\ b }) N.
+{{works with|GNU Smalltalk}}
+| a b |
+'Input number a: ' display.
+a := (stdin nextLine) asInteger.
+'Input number b: ' display.
+b := (stdin nextLine) asInteger.
+('a+b=%1' % { a + b }) displayNl.
+('a-b=%1' % { a - b }) displayNl.
+('a*b=%1' % { a * b }) displayNl.
+('a/b=%1' % { a // b }) displayNl.
+('a%%b=%1' % { a \\ b }) displayNl.
 
-{{ |SX}} (   S)
-| b|
- := (D qu:'E f ub:') Nub.
-b := (D qu:'E c ub:') Nub.
-#( + -  *  \\ qu: : T: **) :[: |
-    |u|
-    u :=  f: :b.
-    '%P % %P = %P\' f:{ .  . b . u} :Tc
+{{works with|Smalltalk/X}} (and all other Smalltalks)
+|a b|
+a := (Dialog request:'Enter first number:') asNumber.
+b := (Dialog request:'Enter second number:') asNumber.
+#( + - / * // \\ quo: rem: raisedTo: **) do:[:operator |
+    |result|
+    result := a perform:operator with:b.
+    '%P %s %P => %P\n' printf:{a . operator . b . result} on:Transcript
 ].
-  c 
-b  uc  (  f) 
-b\\   f \\
-bqu:  uc  ( z) 
-b\\   f qu:
-b**  ju   f T:
-E 10  3, :
+/ is exact division
+<br>// is truncating division (towards negative infinity) 
+<br>\\ is remainder from \\
+<br>quo: is truncating division (towards zero) 
+<br>\\ is remainder from quo:
+<br>** is just an alias for raisedTo:
+<p>Entering 10 and 3, generates:

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

@@ -1,18 +1,18 @@
-INPUT "E f umb.":f
-INPUT "E c ub.":c
-PRINT "T u f"f""c" "f+c"."
-PRINT "T ffc b"f""c" "ABS(f-c)"."
-PRINT "T uc f"f""c" "f*c"."
-IF c THEN
-    PRINT "T  qu f"f""c" "INTEG(fc)"."
+INPUT "Enter first number.":first
+INPUT "Enter second number.":second
+PRINT "The sum of";first;"and";second;"is ";first+second&"."
+PRINT "The difference between";first;"and";second;"is ";ABS(first-second)&"."
+PRINT "The product of";first;"and";second;"is ";first*second&"."
+IF second THEN
+    PRINT "The integer quotient of";first;"and";second;"is ";INTEG(first/second)&"."
 ELSE
-    PRINT "D b z  c."
+    PRINT "Division by zero not cool."
 ENDIF
-PRINT "T  b..."f%c"."
-PRINT STR$(f)"    f"c" "f^c"."
-
-'''NOTES:''' S cuu c f  BASIC     c :
-
-I  BASIC, T c INTEG   u  fuc    u f  ccc. T  BASIC INT c ccu   u fuc. T ff f    f BASIC.
- BASIC uc  c  f  b ub. T c cu uc f u  cb uu f uc b  . I   u   c, u u u   ()  cc  uc u   f  (  c,      f c c). I  c f  c, u u c  uc u   u  STR$ c (     f  c).
+PRINT "The remainder being...";first%second&"."
+PRINT STR$(first);"raised to the power of";second;"is ";first^second&"."
 
+'''NOTES:''' Some curious aspects of smart BASIC to note in this code example:
+<ol>
+<li>In smart BASIC, The command INTEG is a true integer function providing only the value of the characteristic. The smart BASIC INT command calculates as a rounding function. This differs from some other versions of BASIC.</li>
+<li>smart BASIC automatically inserts spaces ahead of and behind numbers. This can cause unexpected formatting issues when combining output from numeric variables with text. In order to suppress the trailing space, you must use the ampersand (&amp;) to concatenate the numeric value with the following text (in this case, a period at the end of each sentence). In the case of leading spaces, you must convert the numeric value to text using the STR$ command (as with the last line of the code).
+</ol>

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

@@ -1,12 +1,12 @@
 
-        uu = "E f :"
-  	f = u
-	uu = "E c :"
-	c = u
-	uu = "u  = " f + c
-	uu = "ff = " f - c
-	uu = " = " f * c
-	uu = "qu = " (qu = f  c)
-	uu = "  = " f - (qu * c)
-	uu = "  = " f ** c
-
+        output = "Enter first integer:"
+  	first = input
+	output = "Enter second integer:"
+	second = input
+	output = "sum  = " first + second
+	output = "diff = " first - second
+	output = "prod = " first * second
+	output = "quot = " (qout = first / second)
+	output = "rem  = " first - (qout * second)
+	output = "expo  = " first ** second
+end

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

@@ -1,60 +1,60 @@
-A  BF , SNUSP   c  c   . H  u f  bc c u   ub  u.
+As a BF derivative, SNUSP only has increment and decrement as native operations. Here are routines for other basic arithmetic upon single digit numbers and results.
 
-''S : [[E Muc]]''
+''See also: [[Ethiopian Multiplication]]''
 $\
  ,
  @
- \=@@@-@-----#  
- 
+ \=@@@-@-----#  atoi
+ >
  ,
  @
  \=@@@-@-----#
- 
- @     #        4 c
- \=!?!-++++?\#
-   | #\?++++-
+ <
+ @     #        4 copies
+ \=!/?!/->>+>>+>>+>>+<<<<<<<<?\#
+ >  | #\?<<<<<<<<+>>+>>+>>+>>-/
  @  |
- \==
- \\
- 
+ \==/
+ \>>>>\
+ />>>>/
  @
- \==!===?\#    
-    \+-
+ \==!/===?\#    add
+ <   \>+<-/
  @
- \=@@@+@+++++#  
+ \=@@@+@+++++#  itoa
  .
- 
+ <
  @
- \==!===?\#    ubc
-    \--
+ \==!/===?\#    subtract
+ <   \>-<-/
  @
  \=@@@+@+++++#
  .
  !
- \
- ?-             u
- \ #?++-==\     ==-++?\#    ==-+?\#
-    \-++!?#   #\?\!++-    #\?\!+-
- @         ==|=========|=====\   -\    |
- \======?!@-?!\@-?\=!\?!@#
-          \=======|==========   -\  |
- @                 \======!\?=
+ /\
+ ?-             multiply
+ \/ #/?<<+>+>-==\     /==-<+<+>>?\#    /==-<<+>>?\#
+ <   \->+>+<<!/?/#   #\?\!>>+<+<-/    #\?\!>>+<<-/
+ @         /==|=========|=====\   /-\    |
+ \======<?!/>@/<-?!\>>>@/<<<-?\=>!\?/>!/@/<#
+ <         \=======|==========/   /-\  |
+ @                 \done======>>>!\?/<=/
  \=@@@+@+++++#
  .
  !
- \
- ?-  z
- \
-               
- @    -\
- \?\!\?#!===+\      -\
- | \==@\@\!?!=?\!\?#
- |      |  |  #\--+
- |      \=!\=?!-+?\#
- @            #\?+-
+ /\
+ ?-  zero
+ \/
+ <              divmod
+ @    /-\
+ \?\<!\?/#!===+<<<\      /-\
+ | \<==@\>@\>>!/?!/=<?\>!\?/<<#
+ |      |  |  #\->->+</
+ |      \=!\=?!/->>+<<?\#
+ @            #\?<<+>>-/
  \=@@@+@+++++#
  .
- 
+ <
  @
  \=@@@+@+++++#
  .

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

@@ -1,44 +1,44 @@
-{{ |Oc}}
+{{works with|Oracle}}
 
--- .q
--- T  SQL*u
+-- test.sql
+-- Tested in SQL*plus
 
- b 
+drop table test;
 
-c b  ( , b )
+create table test (a integer, b integer);
 
-   u ('A','B')
+insert into test values ('&&A','&&B');
 
-c
+commit;
 
-c -b ffc f 
+select a-b difference from test;
 
-c *b uc f 
+select a*b product from test;
 
-c uc(b) _qu f   
+select trunc(a/b) integer_quotient from test;  
 
-c (,b)  f 
+select mod(a,b) remainder from test;
 
-c (,b)  f 
+select power(a,b) exponentiation from test;
 
 
 
-SQL @.q
+SQL> @test.sql
 
-Tb .
+Table dropped.
 
 
-Tb c.
+Table created.
 
-E u f : 3
-E u f b: 4
-   1:    u ('A','B')
-   1:    u ('3','4')
+Enter value for a: 3
+Enter value for b: 4
+old   1: insert into test values ('&&A','&&B')
+new   1: insert into test values ('3','4')
 
-1  c.
+1 row created.
 
 
-C c.
+Commit complete.
 
 
 DIFFERENCE

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

@@ -1,15 +1,15 @@
-T     SSEM u   ubc. T  u  001 Sub. uc  f  ffc b   b, u       20  21 c.
-00101000000000100000000000000000   0. -20 o c
-10100000000001100000000000000000   1. c  5
-10100000000000100000000000000000   2. -5  c
+The only operation that the SSEM supports natively is substraction. This program uses the <tt>001 Sub.</tt> instruction to find the difference between <i>a</i> and <i>b</i>, assuming they are loaded into storage addresses 20 and 21 respectively.
+00101000000000100000000000000000   0. -20 to c
+10100000000001100000000000000000   1. c to 5
+10100000000000100000000000000000   2. -5 to c
 10101000000000010000000000000000   3. Sub. 21
-00000000000001110000000000000000   4. S
+00000000000001110000000000000000   4. Stop
 00000000000000000000000000000000   5. 0
-T u    cc   u  b, bcu  SSEM c   u   ccuu (c ) f  u     c—    uff   f  bc u        bf  c ubc b f . T , ,       u   ubc. I  ,  f    ubc b,    u  f   u, b b  u f   .
-00101000000000100000000000000000   0. -20 o c
+The routine is slightly more complicated than it would otherwise be, because the SSEM cannot load a value into the accumulator (<tt>c</tt> register) from storage without negating it in the process—so we have to shuffle the negation of <i>a</i> back out into storage and then negate it again before we can subtract <i>b</i> from it. This does, however, make it easy to implement addition using negation and subtraction. In this program, we first negate <i>a</i>; then subtract <i>b</i>, and store the result; and finally negate that result, thereby obtaining the sum of the two integers.
+00101000000000100000000000000000   0. -20 to c
 10101000000000010000000000000000   1. Sub. 21
-10100000000001100000000000000000   2. c  5
-10100000000000100000000000000000   3. -5  c
-00000000000001110000000000000000   4. S
+10100000000001100000000000000000   2. c to 5
+10100000000000100000000000000000   3. -5 to c
+00000000000001110000000000000000   4. Stop
 00000000000000000000000000000000   5. 0
-A uc   b fu  [[Fuc f#SSEM]],    f    [[LF   cf #SSEM]].
+A multiplication program will be found at [[Function definition#SSEM]], and one that performs integer division at [[Loops/For with a specified step#SSEM]].

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

@@ -1,13 +1,13 @@
-v () = 
-    = Of (I.fS (Of (TIO.uL TIO.I)))
-   b = Of (I.fS (Of (TIO.uL TIO.I)))
-
-   (" + b = "   ^ I.S ( + b)   ^ "\")
-   (" - b = "   ^ I.S ( - b)   ^ "\")
-   (" * b = "   ^ I.S ( * b)   ^ "\")
-   ("  b = " ^ I.S (  b) ^ "\")         (* uc   f *)
-   ("  b = " ^ I.S (  b) ^ "\")         (*    c  *)
-   (" qu b = " ^ I.S (I.qu (, b)) ^ "\")(* uc  0 *)
-   ("  b = " ^ I.S (I. (, b)) ^ "\")  (*    f  *)
-   ("~ = "      ^ I.S (~)      ^ "\")          (* u , uuu  c   u *)
-
+val () = let
+  val a = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))
+  val b = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))
+in
+  print ("a + b = "   ^ Int.toString (a + b)   ^ "\n");
+  print ("a - b = "   ^ Int.toString (a - b)   ^ "\n");
+  print ("a * b = "   ^ Int.toString (a * b)   ^ "\n");
+  print ("a div b = " ^ Int.toString (a div b) ^ "\n");         (* truncates towards negative infinity *)
+  print ("a mod b = " ^ Int.toString (a mod b) ^ "\n");         (* same sign as second operand *)
+  print ("a quot b = " ^ Int.toString (Int.quot (a, b)) ^ "\n");(* truncates towards 0 *)
+  print ("a rem b = " ^ Int.toString (Int.rem (a, b)) ^ "\n");  (* same sign as first operand *)
+  print ("~a = "      ^ Int.toString (~a)      ^ "\n")          (* unary negation, unusual notation compared to other languages *)
+end

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

@@ -1,11 +1,11 @@
 
-  = 6 
- b = 4
+let a = 6 
+let b = 4
 
-("u =\(+b)")
-("ffc = \(-b)")
-("uc = \(*b)")
-("I qu = \(b)")
-("R = (%b)")
-("N  f E")
+print("sum =\(a+b)")
+print("difference = \(a-b)")
+print("product = \(a*b)")
+print("Integer quotient = \(a/b)")
+print("Remainder = (a%b)")
+print("No operator for Exponential")
 

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

@@ -1,19 +1,19 @@
-u "P  wo umb:"
+puts "Please enter two numbers:"
 
-  [ {([ ])}] # Fc  
-  [ {([ ])}] # Fc  
+set x [expr {int([gets stdin])}]; # Force integer interpretation
+set y [expr {int([gets stdin])}]; # Force integer interpretation
 
-u "$ + $ = [ {$ + $}]"
-u "$ - $ = [ {$ - $}]"
-u "$ * $ = [ {$ * $}]"
-u "$  $ = [ {$  $}]"
-u "$  $ = [ {$ % $}]"
-u "$ ' ' $ = [ {$ ** $}]"
+puts "$x + $y = [expr {$x + $y}]"
+puts "$x - $y = [expr {$x - $y}]"
+puts "$x * $y = [expr {$x * $y}]"
+puts "$x / $y = [expr {$x / $y}]"
+puts "$x mod $y = [expr {$x % $y}]"
+puts "$x 'to the' $y = [expr {$x ** $y}]"
 
-Sc Tc '   bu  "" f  b,  "" c  u  c  f   "". T     uc   " c"  c  u  ([b]).
+Since Tcl doesn't really know about the "type" of a variable, the "<tt>expr</tt>" command is used to declare whatever follows as an "expression". This means there is no such thing as "integer arithmetic" and hence the kludge with <tt>int([gets&amp;nbsp;stdin])</tt>.
 
-Of,   u b f   ff  f    . F ,  c  b "" b  u f  b "",  u 
+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
 
-c  $
+incr x $y
 
-A, '   uu  u   cc  bc, c   f   f      c.  Dcu f    [:.c.10225 T Tc' W].
+Also, it's important to surround the arguments to the <code>expr</code> in braces, especially when any of the parts of the expression are not literal constants.  Discussion of this is on [http://wiki.tcl.tk/10225 The Tcler's Wiki].

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

@@ -1,33 +1,33 @@
-HCL '          c     c, bu      uu b bc u  ff.......
+HCL doesn't have an exponentiation operator and even integer division is contrived as shown in the code, but at least it prints the output variables alphabetically without any effort.......
 
-#Au, 15 Auu 2022
+#Aamrun, 15th August 2022
 
-b "" {
-   = ub
+variable "a" {
+  type = number
 }
 
-b "b" {
-   = ub
+variable "b" {
+  type = number
 }
 
-uu "Su" {
-  u = . + .b
+output "Sum" {
+  value = var.a + var.b
 }
 
-uu "Dffc" {
-  u = . - .b
+output "Difference" {
+  value = var.a - var.b
 }
 
-uu "Puc" {
-  u = . * .b
+output "Product" {
+  value = var.a * var.b
 }
 
-uu "Qu" {
-  u = f(.  .b)
+output "Quotient" {
+  value = floor(var.a / var.b)
 }
 
-uu "R" {
-  u = . % .b
+output "Remainder" {
+  value = var.a % var.b
 }
 
-T f fuc u   c  . Ic  uu   b :
+The floor function rounds to the closest lowest integer. Invocation and output are as below :

data/zettacode.files/arithmetic.integer/ti-83_basic.txt

@@ -1,14 +1,14 @@
-Pu  u  TI-83' c f c z.
+Pauses added due to TI-83's lack of screen size.
 
-P A,B
-D "SUM"
-Pu A+B
-D "DIFFERENCE"
-Pu A-B
-D "PRODUCT"
-Pu AB
-D "INTEGER QUOTIENT"
-Pu (AB)
-D "REMAINDER"
-Pu A-B*(AB)
+Prompt A,B
+Disp "SUM"
+Pause A+B
+Disp "DIFFERENCE"
+Pause A-B
+Disp "PRODUCT"
+Pause AB
+Disp "INTEGER QUOTIENT"
+Pause int(A/B)
+Disp "REMAINDER"
+Pause A-B*int(A/B)
 

data/zettacode.files/arithmetic.integer/ti-89_basic.txt

@@ -1,8 +1,8 @@
 
-Loc , b
-P , b
-D "Su: "  ( + b)
-D "Dffc: "  ( - b)
-D "Puc: "  ( * b)
-D "I qu: "  (D(, b))
-D "R: "  ((, b))
+Local a, b
+Prompt a, b
+Disp "Sum: " & string(a + b)
+Disp "Difference: " & string(a - b)
+Disp "Product: " & string(a * b)
+Disp "Integer quotient: " & string(intDiv(a, b))
+Disp "Remainder: " & string(remain(a, b))

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

@@ -1,7 +1,7 @@
 
-[ (  b -- )
-  2u ." +b = " + . c  
-  2u ." -b = " - . c  
-  2u ." *b = " * . c  
-  2u ." b = "  . ."  "  . c  
-]  
+[ ( a b -- )
+  2dup ." a+b = " + . cr  
+  2dup ." a-b = " - . cr  
+  2dup ." a*b = " * . cr  
+  2dup ." a/b = " / . ." remainder " mod . cr  
+] is mathops

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

@@ -1,9 +1,9 @@
 
 $$ MODE TUSCRIPT
-=5
+a=5
 b=3
-c=+b
-c=-b
-c=*b
-c=b
-c=%b
+c=a+b
+c=a-b
+c=a*b
+c=a/b
+c=a%b

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

@@ -1,29 +1,29 @@
 
-T U    c u c ,   , uc  ''''  u  f c ccu  qu:
+The Unix shell does not directly support arithmetic operations, so external tools, such as ''expr'' are used to perform arithmetic calculations when required:
 
-{{ |Bu S}}
-{{ |Aqu SH}}
-#!b
-   b
-c "+b     = "  ` $  +  $b`
-c "-b     = "  ` $  -  $b`
-c "*b     = "  ` $ \*  $b`
-c "b     = "  ` $    $b` # uc  0
-c "  b = "  ` $  %  $b` #    f 
+{{works with|Bourne Shell}}
+{{works with|Almquist 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/b     = "  `expr $a  /  $b` # truncates towards 0
+echo "a mod b = "  `expr $a  %  $b` # same sign as first operand
 
-N: U  ` (bcc ,  b   Bu    ''$(...)'' )  u    u   b    ffc  b . T c u     '''' c  u  qu    qu u  qu  c  ''*'' cc  ,    b "bb" --- f  f  ''*''   c cc.
+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.
 
-W SUS3  :
+With SUSv3 parameter expansions:
 
-{{ |Bu A SH|3.2}}
-{{ ||5.2.14}}
-{{ |Z SH}}
-#!b
-   b
-c "+b     = $((+b))"
-c "-b     = $((-b))"
-c "*b     = $((*b))"
-c "b     = $((b))" # uc  0
-c "  b = $((%b))" #    f 
+{{works with|Bourne Again SHell|3.2}}
+{{works with|pdksh|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/b     = $((a/b))" # truncates towards 0
+echo "a mod b = $((a%b))" # same sign as first operand
 
-N: c   ''$((...))''     qu  ''$((...))'' c b   u  ub qu, bu  `...`  f  u  c  b   u  ub qu.
+Note: spaces inside the ''$((...))'' are optional and not required; the ''$((...))'' can be inside or outside the double quotes, but the `...` expressions from the previous example can also be inside or outside the double quotes.

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

@@ -1,27 +1,27 @@
 #
-#  c
+# integer arithmetic
 #
 
-c   
-u "ub 1: " c
-  (  c)
-u "ub 2: " c
-  (  c)
+decl int x y
+out "number 1: " console
+set x (in int console)
+out "number 2: " console
+set y (in int console)
 
-u "\u:\" ( (+  ))  c
-u "ff:\" ( (-  ))  c
-u ":\" ( (*  ))  c
-# qu ' u  , bu   fuc u u
-u "qu:\" ( (  ))  c
-#     f 
-u ":\" ( (  ))  c
+out "\nsum:\t" (int (+ x y)) endl console
+out "diff:\t" (int (- x y)) endl console
+out "prod:\t" (int (* x y)) endl console
+# quotient doesn't round at all, but the int function rounds up
+out "quot:\t" (int (/ x y)) endl console
+# mod takes the sign of x
+out "mod:\t" (int (mod x y)) endl console
 
-S :
-ub 1: 15
-ub 2: 7
+Sample session:
+number 1: 15
+number 2: 7
 
-u:	22
-ff:	8
-:	105
-qu:	2
-:	1
+sum:	22
+diff:	8
+prod:	105
+quot:	2
+mod:	1