zettacode 0.1.0 → 0.1.1

data/zettacode.files/arithmetic.integer/v_(vlang).txt

@@ -1,29 +1,29 @@
- Amc-  V (V)
- Tcc:  u c-.
-u 
- 
- 
+// Arithmetic-integer in V (Vlang)
+// Tectonics: v run arithmetic-integer.v
+module main
+import math
+import os
 
-  
-ub f () {
-    u  := 0
-    u b := 0
+// starts here
+pub fn main() {
+    mut a := 0
+    mut b := 0
 
-      ub f c
-    ("E   ub,  b  c: ")
-     := .__()
-    u := .(' ')
-     = u[0].()
-    b = u[1].()
+    // get numbers from console
+    print("Enter two integer numbers, separated by a space: ")
+    text := os.get_raw_line()
+    values := text.split(' ')
+    a = values[0].int()
+    b = values[1].int()
 
-     4 bc, ,   
-    ("u:            $, b $b")
-    ("u:               + b = ${ + b}")
-    ("ffc:        - b = ${ - b}")
-    ("uc:           * b = ${ * b}")
-    (" qu:   b = ${  b}, uc")
-    (":         % b = ${ % b},  f ")
+    // 4 basics, remainder, no exponentiation operator
+    println("values:           a $a, b $b")
+    println("sum:              a + b = ${a + b}")
+    println("difference:       a - b = ${a - b}")
+    println("product:          a * b = ${a * b}")
+    println("integer quotient: a / b = ${a / b}, truncation")
+    println("remainder:        a % b = ${a % b}, sign follows dividend")
 
-    ("  ")
-    ("  .:    (,b) = ${.(,b)}")
+    println("no exponentiation operator")
+    println("  math.pow:    pow(a,b) = ${math.pow(a,b)}")
 }

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

@@ -1,19 +1,19 @@
 
-'Ac - I
-Sub RAcI()
-D  A V,  A I, b A I
-O E Ru N
+'Arithmetic - Integer
+Sub RosettaArithmeticInt()
+Dim opr As Variant, a As Integer, b As Integer
+On Error Resume Next
 
- = CI(IuB("E f ", "XLSM | Ac"))
-b = CI(IuB("E c ", "XLSM | Ac"))
+a = CInt(InputBox("Enter first integer", "XLSM | Arithmetic"))
+b = CInt(InputBox("Enter second integer", "XLSM | Arithmetic"))
 
-Dbu.P " =" , "b=" b, bC
-F Ec  I S("+ - *  \  ^", " ")
-    Sc C 
-        C "":     Dbu.P "  b",  "" b,  M b
-        C "\":       Dbu.P " \ b",  "\" b,  \ b
-        C E:      Dbu.P " "  " b",   b, Eu(    b)
-    E Sc
-N 
-E Sub
+Debug.Print "a ="; a, "b="; b, vbCr
+For Each opr In Split("+ - * / \ mod ^", " ")
+    Select Case opr
+        Case "mod":     Debug.Print "a mod b", a; "mod"; b, a Mod b
+        Case "\":       Debug.Print "a \ b", a; "\"; b, a \ b
+        Case Else:      Debug.Print "a "; opr; " b", a; opr; b, Evaluate(a & opr & b)
+    End Select
+Next opr
+End Sub
 

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

@@ -1,51 +1,51 @@
-VBSc' b   V. W  u     b c    f   .
-
-===I===
-oo c
- , b
-c.u. "A? "
- = c..
-c.u. "B? "
-b = c..
-
- = (  )
-b = ( b )
-
-c.c " + b=",  + b
-c.c " - b=",  - b
-c.c " * b=",  * b
-c.c "  b=",   b
-c.c " \ b=",  \ b
-c.c "  b=",   b
-c.c " ^ b=",  ^ b
-
-===A I===
-G   uu f   u. I b P .
-oo c
- , b
-c.u. "A? "
- = c..
-c.u. "B? "
-b = c..
-
- = (  )
-b = ( b )
-
- 
-f c   ("+ - *  \  ^", " ")
-	c.c "",,"b=",( " "    " b")
-
-
-===Ic===
-
-C:\fc.b
+VBScript's variables are all Variants. What starts out as an integer may be converted to something else if the need arises.
+
+===Implementation===
+option explicit
+dim a, b
+wscript.stdout.write "A? "
+a = wscript.stdin.readline
+wscript.stdout.write "B? "
+b = wscript.stdin.readline
+
+a = int( a )
+b = int( b )
+
+wscript.echo "a + b=", a + b
+wscript.echo "a - b=", a - b
+wscript.echo "a * b=", a * b
+wscript.echo "a / b=", a / b
+wscript.echo "a \ b=", a \ b
+wscript.echo "a mod b=", a mod b
+wscript.echo "a ^ b=", a ^ b
+
+===Another Implementation===
+Gives the same output for the same input. Inspired by Python version.
+option explicit
+dim a, b
+wscript.stdout.write "A? "
+a = wscript.stdin.readline
+wscript.stdout.write "B? "
+b = wscript.stdin.readline
+
+a = int( a )
+b = int( b )
+
+dim op
+for each op in split("+ - * / \ mod ^", " ")
+	wscript.echo "a",op,"b=",eval( "a " & op & " b")
+next
+
+===Invocation===
+
+C:\foo>arithmetic.vbs
 A? 45
 B? 11
- + b= 4511
- - b= 34
- * b= 495
-  b= 4.09090909090909
- \ b= 4
-  b= 1
- ^ b= 1.5322783012207E+18
+a + b= 4511
+a - b= 34
+a * b= 495
+a / b= 4.09090909090909
+a \ b= 4
+a mod b= 1
+a ^ b= 1.5322783012207E+18
 

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

@@ -1,8 +1,8 @@
-#1 = G_Num("Gv umb : ")
-#2 = G_Nu("G ub b: ")
-M(" + b = ") Nu_T(#1 + #2)
-M(" - b = ") Nu_T(#1 - #2)
-M(" * b = ") Nu_T(#1 * #2)
-M("  b = ") Nu_T(#1  #2)
-M(" % b = ") Nu_T(#1 % #2)
+#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)
 

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

@@ -1,26 +1,26 @@
-modu m
-   , b
-   u, , uc
-   , , 
+module main;
+  integer a, b;
+  integer suma, resta, producto;
+  integer division, resto, expo;
   
-   b
-     = -12
-    b = 7
+  initial begin
+    a = -12;
+    b = 7;
     
-    u =  + b
-     =  - b
-    uc =  * b
-     =   b
-     =  % b
-     =  ** b
+    suma = a + b;
+    resta = a - b;
+    producto = a * b;
+    division = a / b;
+    resto = a % b;
+    expo = a ** b;
     
-    $("S    = -12  b = 7")
-    $("       u   + b = ", u)
-    $("         - b = ", )
-    $("   uc   * b = ", uc)
-    $("   ó    b = ", )
-    $("        b = ", )
-    $("ccó  ^ b = ", )
-    $f 
-  
-u
+    $display("Siendo dos enteros a = -12 y b = 7");
+    $display("       suma de a + b = ", suma);
+    $display("      resta de a - b = ", resta);
+    $display("   producto de a * b = ", producto);
+    $display("   división de a / b = ", division);
+    $display("   resto de a mod  b = ", resto);
+    $display("exponenciación a ^ b = ", expo);
+    $finish ;
+  end
+endmodule

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

@@ -1,10 +1,10 @@
-  = fo2(u("Numb 1: ") + 0)
- b = f2(u("Nub 2: ") + 0)
-c "\Su: " . ( + b)
-c "Dffc: " . ( - b)
-c "Puc: " . ( * b)
-" T u f     uc
-c "Qu: " . (  b)
-" T  f  u f    c   f 
-"  f  
-c "R: " . ( % b)
+let a = float2nr(input("Number 1: ") + 0)
+let b = float2nr(input("Number 2: ") + 0)
+echo "\nSum: " . (a + b)
+echo "Difference: " . (a - b)
+echo "Product: " . (a * b)
+" The result of an integer division is truncated
+echo "Quotient: " . (a / b)
+" The sign of the result of the remainder operation matches the sign of 
+" the first operand 
+echo "Remainder: " . (a % b)

data/zettacode.files/arithmetic.integer/visual_basic_.net.txt

@@ -1,14 +1,14 @@
-Imo Sm.Coo
-Mu Mu1
-  Sub M
-    D  = CI(RL)
-    D b = CI(RL)
-    WL("Su "   + b)
-    WL("Dffc "   - b)
-    WL("Puc "   - b)
-    WL("Qu "    b)
-    WL("I Qu "   \ b)
-    WL("R "   M b)
-    WL("E "   ^ b)
-  E Sub
-E Mu
+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)
+    WriteLine("Exponent " & a ^ b)
+  End Sub
+End Module

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

@@ -1,9 +1,9 @@
- - (d)
-b - ()
- "u: " +b
- "ffc: " -b
- "uc: " *b
- "qu: " b
- " qu: " ( b)
- ": " %b
- ": " ^b
+a <- (read)
+b <- (read)
+prn "sum: " a+b
+prn "difference: " a-b
+prn "product: " a*b
+prn "quotient: " a/b
+prn "integer quotient: " (int a/b)
+prn "remainder: " a%b
+prn "exponent: " a^b

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

@@ -1,16 +1,16 @@
-I W  qu  ''   u bu,   ''f''      u,  u    .
+In Wren the quotient operator '/' does not round but, when the ''floor'' method is applied to the result, it rounds to the lower integer.
 
-T  f    '%' c   f  f .
-mo "o" fo Sd, Sdou
-S.("f ub:     ")
-Su.fu()
-  = Nu.fS(S.L())
-S.("c ub:    ")
-Su.fu()
- b = Nu.fS(S.L())
-S.("u:              %( + b)")
-S.("ffc:       %( - b)")
-S.("uc:          %( * b)")
-S.(" qu: %((  b).f)")
-S.(":        %( % b)")
-S.(":   %(.(b))")
+The sign of the remainder operator '%' matches the sign of the first operand.
+import "io" for Stdin, Stdout
+System.write("first number:     ")
+Stdout.flush()
+var a = Num.fromString(Stdin.readLine())
+System.write("second number:    ")
+Stdout.flush()
+var b = Num.fromString(Stdin.readLine())
+System.print("sum:              %(a + b)")
+System.print("difference:       %(a - b)")
+System.print("product:          %(a * b)")
+System.print("integer quotient: %((a / b).floor)")
+System.print("remainder:        %(a % b)")
+System.print("exponentiation:   %(a.pow(b))")

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

@@ -1,23 +1,23 @@
-Iu  uu u b OS-cfc    . T u    16-b 8086,      32-b  64-b ucc:  cu b  f  f 32-b  64-b c  c    u. T qu  uc  z      f  f .
-m: mov      c,          
-              b,          b
-              ,          
+Input and output would be OS-specific and are not implemented. This routine works on the 16-bit 8086, as well as on its 32-bit and 64-bit successors: it could be trivially modified to perform 32-bit or 64-bit arithmetic on machines where those are supported. The quotient is truncated towards zero; the remainder takes its sign from the first operand.
+arithm: mov      cx,          a
+        mov      bx,          b
+        xor      dx,          dx
         
-              ,          c
-              ,          b
-              u,         
+        mov      ax,          cx
+        add      ax,          bx
+        mov      sum,         ax
         
-              ,          c
-        u     b
-              uc,     
+        mov      ax,          cx
+        imul     bx
+        mov      product,     ax
         
-              ,          c
-        ub      ,          b
-              ffc,  
+        mov      ax,          cx
+        sub      ax,          bx
+        mov      difference,  ax
         
-              ,          c
-             b
-              qu,    
-              ,   
+        mov      ax,          cx
+        idiv     bx
+        mov      quotient,    ax
+        mov      remainder,   dx
 
-        
+        ret

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

@@ -1,7 +1,7 @@
 (DEFUN INTEGER-ARITHMETIC ()
-    (DISPLAY "E    b  c.")
+    (DISPLAY "Enter two integers separated by a space.")
     (NEWLINE)
-    (DISPLAY " ")
+    (DISPLAY "> ")
     (DEFINE A (READ))
     (DEFINE B (READ))
     (DISPLAY `(SUM ,(+ A B)))
@@ -10,8 +10,8 @@
     (NEWLINE)
     (DISPLAY `(PRODUCT ,(* A B)))
     (NEWLINE)
-    (DISPLAY `(QUOTIENT ,(QUOTIENT A B)))  uc  z
+    (DISPLAY `(QUOTIENT ,(QUOTIENT A B))) ; truncates towards zero
     (NEWLINE)
-    (DISPLAY `(REMAINDER ,(REM A B)))    f f 
+    (DISPLAY `(REMAINDER ,(REM A B))) ; takes sign of first operand
     (NEWLINE)
     (DISPLAY `(EXPONENTIATION ,(EXPT A B))))

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

@@ -1,10 +1,10 @@
-cud c:\c\cod
- A, B
-[A:= II(0)
- B:= II(0)
-IOu(0, A+B) CLf(0)
-IOu(0, A-B) CLf(0)
-IOu(0, A*B) CLf(0)
-IOu(0, AB) CLf(0)        \uc  z
-IOu(0, (0)) CLf(0)     \'  c f  (A)
+include c:\cxpl\codes;
+int A, B;
+[A:= IntIn(0);
+ B:= IntIn(0);
+IntOut(0, A+B); CrLf(0);
+IntOut(0, A-B); CrLf(0);
+IntOut(0, A*B); CrLf(0);
+IntOut(0, A/B); CrLf(0);        \truncates toward zero
+IntOut(0, rem(0)); CrLf(0);     \remainder's sign matches first operand (A)
 ]

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

@@ -1,10 +1,10 @@
-:m m="mc"
-  : =""5:
-  : ="b"2:
-  f:bc + b = :u-f c="$ + $b"f:bc
-  f:bc - b = :u-f c="$ - $b"f:bc
-  f:bc * b = :u-f c="$ * $b"f:bc
-  f:bc  b = :u-f c="u($  $b)"f:bc
-  f:bc  b = :u-f c="$  $b"f:bc
- :
+<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>
 

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

@@ -1,11 +1,11 @@
-u " u umo? " 
-u "  u? " b
-
- "u      ", , " + ", b, " = ", ( + b)
- "     ", , " - ", b, " = ", ( - b)
- "uc  ", , " * ", b, " = ", ( * b)
- "  ", , " \ ", b, " = ", (  b)
- "u    ", , " % ", b, " = ", (, b)
- "c  ", , " ^ ", b, " = ", ( ^ b)
+input "ingrese un numero? " a
+input "ingrese otro numero? " b
 
+print "suma      ", a, " + ", b, " = ", (a + b)
+print "resta     ", a, " - ", b, " = ", (a - b)
+print "producto  ", a, " * ", b, " = ", (a * b)
+print "division  ", a, " \ ", b, " = ", int(a / b)
+print "modulo    ", a, " % ", b, " = ", mod(a, b)
+print "potencia  ", a, " ^ ", b, " = ", (a ^ b)
+end
 

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

@@ -1,8 +1,8 @@
- =  = 0
-, , 
-, " +  =",  + 
-, " -  =",  - 
-, " *  =",  * 
-, "   =",     u  z
-, " %  =",  %    c  f f   '  ff
-, " ^  =",  ^   
+x = y = 0;
+read, x, y;
+write, "x + y =", x + y;
+write, "x - y =", x - y;
+write, "x * y =", x * y;
+write, "x / y =", x / y; // rounds toward zero
+write, "x % y =", x % y; // remainder; matches sign of first operand when operands' signs differ
+write, "x ^ y =", x ^ y; // exponentiation

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

@@ -1,7 +1,7 @@
-,:=k("Two : ").(" ").("oI")
-("+ = ", + )
-("- = ", - )
-("* = ", * )
-(" = ",  )  u  z
-("% = ", % )   c  f f   '  ff
-(".() = ",.())  (,)   b
+x,y:=ask("Two ints: ").split(" ").apply("toInt");
+println("x+y = ",x + y);
+println("x-y = ",x - y);
+println("x*y = ",x * y);
+println("x/y = ",x / y); // rounds toward zero
+println("x%y = ",x % y); // remainder; matches sign of first operand when operands' signs differ
+println("x.divr(y) = ",x.divr(y)); // (x/y,remainder); sign as above

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

@@ -1,13 +1,13 @@
 
-u M
-
-	,j: 
-b
-	("A ?:")()
-	("?: ")(j)
-	("u: ", + j)
-	("ffc: ",  - j)
-	("uc: ",  * j)
-	("qu: ",   j)
-	(": ",   j)
- M.
+module Main;
+var
+	i,j: integer;
+begin
+	write("A integer?:");readln(i);
+	write("another?: ");readln(j);
+	writeln("sum: ",i + j);
+	writeln("difference: ", i - j);
+	writeln("product: ", i * j);
+	writeln("quotient: ", i div j);
+	writeln("remainder: ", i mod j);
+end Main.

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

@@ -1,11 +1,11 @@
-5 LET =5: LET b=3
-10 PRINT " + "b" = "+b
-20 PRINT " - "b" = "-b
-30 PRINT " * "b" = "*b
-40 PRINT "  "b" = "INT (b)
-50 PRINT "  "b" = "-INT (b)*b
-60 PRINT "    f "b" = "^b
+5 LET a=5: LET b=3
+10 PRINT a;" + ";b;" = ";a+b
+20 PRINT a;" - ";b;" = ";a-b
+30 PRINT a;" * ";b;" = ";a*b
+40 PRINT a;" / ";b;" = ";INT (a/b)
+50 PRINT a;" mod ";b;" = ";a-INT (a/b)*b
+60 PRINT a;" to the power of ";b;" = ";a^b
 
-      1ju20012b49596cj51
+      <sha1>jmu2t0w01l2tasbm4sraa95rv96cj5t</sha1>
     
   

data/zettacode.files/arithmetic.integer//320/274/320/272-61-52.txt

@@ -1,7 +1,7 @@
-П1	-	П0
-+	СП
-ИП0	ИП1	-	СП
-ИП0	ИП1	*	СП
-ИП0	ИП1		[]	СП
-ИП0	^	ИП1		[]	ИП1	*	-	СП
-ИП1	ИП0	^	СП
+П1	<->	П0
++	С/П
+ИП0	ИП1	-	С/П
+ИП0	ИП1	*	С/П
+ИП0	ИП1	/	[x]	С/П
+ИП0	^	ИП1	/	[x]	ИП1	*	-	С/П
+ИП1	ИП0	x^y	С/П

data/zettacode.files/hello_world.text/0815.txt

@@ -1,7 +1,7 @@
 
-:48::65:=:6C:$=$=$$~:03:+
-$~:ffffffffffffffb1:+$:77:~$
-~:fffffffffffff8:+$~:03:+$~
-:06:-$:0:-$=:43:-$
+<:48:x<:65:=<:6C:$=$=$$~<:03:+
+$~<:ffffffffffffffb1:+$<:77:~$
+~<:fffffffffffff8:x+$~<:03:+$~
+<:06:x-$x<:0e:x-$=x<:43:x-$
 
 

data/zettacode.files/hello_world.text/11l.txt

@@ -1 +1 @@
-(‘Ho wod!’)
+print(‘Hello world!’)