zettacode 0.1.0 → 0.1.1

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

@@ -1,9 +1,9 @@
 🏁🍇
-  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️  💭 G f ub
-  🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️  💭 G c ub
-  😀 🔤Su: 🧲➕🧲🔤 ❗
-  😀 🔤Dffc: 🧲➖🧲🔤 ❗
-  😀 🔤Puc: 🧲✖️🧲🔤 ❗
-  😀 🔤Qu: 🧲➗️🧲🔤 ❗ 💭 Ru  0
-  😀 🔤R: 🧲🚮️🧲🔤 ❗ 💭 Mc  f f 
+  🍺🔢🆕🔡▶️👂🏼❗ 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/zettacode.files/arithmetic.integer/erlang.txt

@@ -1,15 +1,15 @@
-% Immd b Aju Su
--u().
--([0]).
+% Implemented by Arjun Sunel
+-module(arith).
+-export([start/0]).
  
-() -
-   c :f("","~~") f
-       {, [A,B]} -
-           :f("Su = ~~",[A+B]),
-           :f("Dffc = ~~",[A-B]),
-           :f("Puc = ~~",[A*B]),
-           :f("Qu = ~~",[A  B]),      % uc  z
-           :f("R= ~~",[A  B]),    %     f 
-           ()
-   .
+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/zettacode.files/arithmetic.integer/erre.txt

@@ -2,19 +2,19 @@
 PROGRAM INTEGER_ARITHMETIC
 
 !
-! f c.
+! for rosettacode.org
 !
 
 !$INTEGER
 
 BEGIN
-  INPUT("E  ub ",A)
-  INPUT("E  ub ",B)
+  INPUT("Enter a number ",A)
+  INPUT("Enter another number ",B)
 
-  PRINT("A "A"+"B"="(A+B))
-  PRINT("Subc "A"-"B"="(A-B))
-  PRINT("Muc "A"*"B"="(A*B))
-  PRINT("I  "A""B"="(A DIV B))
-  PRINT("R  u "A""B"="(A MOD B))
-  PRINT("P "A"^"B"="(A^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/zettacode.files/arithmetic.integer/euphoria.txt

@@ -1,13 +1,13 @@
-cud .
+include get.e
 
- ,b
+integer a,b
 
- = f(_ub(" = ",{}))
-b = f(_ub("b = ",{}))
+a = floor(prompt_number("a = ",{}))
+b = floor(prompt_number("b = ",{}))
 
-f(1," + b = %\", +b)
-f(1," - b = %\", -b)
-f(1," * b = %\", *b)
-f(1,"  b = %\", b) --   uc
-f(1,"(,b) = %\", (,b)) --    f 
-f(1,"(,b) = %\", (,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/zettacode.files/arithmetic.integer/excel.txt

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

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

@@ -1,15 +1,15 @@
-A F#   fuc u,  c  c   f  f    f  fuc   fuc f          fuc  b  u:
+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)
 
-   , b =  S..[1],  S..[2]
-  f , f  ["+", ( + ) "-", ( - ) "*", ( * ) "", (  ) "%", ( % )] 
-    f "% % % = %\"   b (f  b)
-
-F ,  uu   u 4  3 :
+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
 4 % 3 = 1
 

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

@@ -1,17 +1,17 @@
-USING: combo o k m m.fuco m.od
-.  
+USING: combinators io kernel math math.functions math.order
+math.parser prettyprint ;
 
-"=" "b=" [   ub ] b@
+"a=" "b=" [ write readln string>number ] bi@
 {
-    [ + "u: "  . ]
-    [ - "ffc: "  . ] 
-    [ * "uc: "  . ]
-    [  "qu: "  . ]
-    [  " qu: "  . ]
-    [  ": "  . ]
-    [  "u: "  . ]
-    [  "u: "  . ]
-    [  "u: "  . ]
-    [ c "c: "  .  ]
-    [ c "c: "  . ]
-} 2c
+    [ + "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/zettacode.files/arithmetic.integer/false.txt

@@ -1,8 +1,8 @@
 12 7
-\$@$@$@$@$@$@$@$@$@$@\  { 6 c }
-"u = "+."
-ffc = "-."
-uc = "*."
-qu = "."
-uu = "*-."
+\$@$@$@$@$@$@$@$@$@$@\  { 6 copies }
+"sum = "+."
+difference = "-."
+product = "*."
+quotient = "/."
+modulus = "/*-."
 "

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

@@ -1,10 +1,10 @@
-I  u  z      f   f  ub.
+Integer division rounds towards zero; remainders are always positive regardless of the signs of the numbers.
 
-?
-?b
-!!('Su:              +b=',+b)
-!!('Dffc:       -b=',-b)
-!!('Puc:          *b=',*b)
-!!('I qu: \b=',\b)
-!!('R:        |b=',|b)
-!!('E:   ^b=',^b)
+?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/zettacode.files/arithmetic.integer/forth.txt

@@ -1,19 +1,19 @@
-T    ,      ub f  c.  '''''' u  u  c ffc  (  b -- %b b ).
-: mc (  b -- )
-  c ." ="  . ." b=" u .
-  c ." +b=" 2u + .
-  c ." -b=" 2u - .
-  c ." *b=" 2u * .
-  c ." b="  .
-  c ."   b = " . c 
+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 ;
 
-Dff    ff    b. ANS F f   ub-c   , f c    c   u    bc   (  ,  ,  , * ). T   u  ff cfc    u , F-79  F-83.
+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.
 
-FMMOD ( d  -- mod dv )   \ food
-SMREM (   --   )   \ c
-M* (   --  )
+FM/MOD ( d n -- mod div )   \ floored
+SM/REM ( d n -- rem div )   \ symmetric
+M* ( n n -- d )
 
-I ,   u .
+In addition, there are unsigned variants.
 
-UMMOD ( ud u -- umod udv )
-UM* ( u u -- u )
+UM/MOD ( ud u -- umod udiv )
+UM* ( u u -- ud )

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

@@ -1,15 +1,15 @@
-I ANSI FORTRAN 77  :
+In ANSI FORTRAN 77 or later:
  INTEGER A, B
- PRINT *, 'T    ub  b  c',
-+         '   ENTER'
+ 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 *, '   A / B = ', (A / B)
  PRINT *, 'MOD(A,B) = ', MOD(A,B)
  PRINT *
- PRINT *, 'E u u   , ',
-+         '   c   F, ...'
+ PRINT *, 'Even though you did not ask, ',
++         'exponentiation is an intrinsic op in Fortran, so...'
  PRINT *, '  A ** B = ', (A ** B)
  END

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

@@ -1,18 +1,18 @@
-' FB 1.05.0 W64
+' FB 1.05.0 Win64
 
-D A I , j
-Iu "E    b  c" , j
-P " + " j " = "  + j
-P " - " j " = "  - j
-P " * " j " = "  * j
-P "  " j " = "  \ j
-P " % " j " = "  M j 
-P " ^ " j " = "  ^ j
-S
+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
 
-' I  (f c FB u  '\' ) u  z
+' Integer division (for which FB uses the '\' operator) rounds towards zero
 
-' R (f c FB u  M ) , f -z, c  
-' f  f 
+' Remainder (for which FB uses the Mod operator) will, if non-zero, match the sign
+' of the first operand
 
-S u  uu:-
+Sample input and output:-

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

@@ -1,10 +1,10 @@
 
- 
- b
-c ' + b =' ( "$ + $b") # Su
-c ' - b =' ( "$ - $b") # Dffc
-c ' * b =' ( "$ * $b") # Puc
-c '  b =' ( "$  $b") # I qu
-c ' % b =' ( "$ % $b") # R
-c ' ^ b =' ( "$ ^ $b") # E
+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/zettacode.files/arithmetic.integer/frink.txt

@@ -1,10 +1,10 @@
-T    (c uc  ub  b), CODECODE,  CODECODE.  CODECODE u   f (f  CODEf[]CODE).  CODECODE u   f  c ub (f  CODE -  * f[]CODE).  A  uc uc b   c  ub  c.
+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.
 
-[,b] = u["E ub",["","b"]]
-=["+", "-", "*", "", "" ,"" ,"^"]
-f  = 
+[a,b] = input["Enter numbers",["a","b"]]
+ops=["+", "-", "*", "/", "div" ,"mod" ,"^"]
+for op = ops
 {
-    = "$ $ $b"
-   ["$ = " + []]
+   str = "$a $op $b"
+   println["$str = " + eval[str]]
 }