Euclidean algorithm: Output standardization

contents/euclidean_algorithm/code/asm-x64/euclidean_example.s

@@ -1,7 +1,8 @@
 .intel_syntax noprefix
 
 .section .rodata
-  fmt:  .string "%d\n"
+  euclid_mod_fmt: .string "[#]\nModulus-based euclidean algorithm result:\n%d\n"
+  euclid_sub_fmt: .string "[#]\nSubtraction-based euclidean algorithm result:\n%d\n"
 
 .section .text
   .global main
@@ -59,14 +60,14 @@ main:
   mov    rdi, 4288          # Call euclid_mod
   mov    rsi, 5184
   call   euclid_mod
-  mov    rdi, OFFSET fmt    # Print output
+  mov    rdi, OFFSET euclid_mod_fmt    # Print output
   mov    rsi, rax
   xor    rax, rax
   call   printf
   mov    rdi, 1536          # Call euclid_sub
   mov    rsi, 9856
   call   euclid_sub
-  mov    rdi, OFFSET fmt    # Print output
+  mov    rdi, OFFSET euclid_sub_fmt    # Print output
   mov    rsi, rax
   xor    rax, rax
   call   printf

contents/euclidean_algorithm/code/bash/euclid.bash

@@ -38,6 +38,6 @@ euclid_sub() {
 }
 
 result=$(euclid_mod $((64 * 67)) $((64 * 81)))
-echo "$result"
+echo -e "[#]\nModulus-based euclidean algorithm result:\n$result"
 result=$(euclid_sub $((128 * 12)) $((128 * 77)))
-echo "$result"
+echo -e "[#]\nSubtraction-based euclidean algorithm result:\n$result"

contents/euclidean_algorithm/code/c/euclidean_example.c

@@ -33,8 +33,8 @@ int main() {
   int check1 = euclid_mod(64 * 67, 64 * 81);
   int check2 = euclid_sub(128 * 12, 128 * 77);
 
-  printf("%d\n", check1);
-  printf("%d\n", check2);
+  printf("[#]\nModulus-based euclidean algorithm result:\n%d\n", check1);
+  printf("[#]\nSubtraction-based euclidean algorithm result:\n%d\n", check2);
 
   return 0;
 }

contents/euclidean_algorithm/code/clisp/euclidean.lisp

@@ -17,8 +17,10 @@
       (abs a)
       (euclid-mod b (mod a b))))
 
-(print (euclid-sub (* 64 67) (* 64 81)))
-(print (euclid-mod (* 128 12) (* 128 77)))
+(format T "[#]~%Modulus-based euclidean algorithm result:~%")
+(format T "~d~%" (euclid-sub (* 64 67) (* 64 81)))
+(format T "[#]~%Subtraction-based euclidean algorithm result:~%")
+(format T "~d~%" (euclid-mod (* 128 12) (* 128 77)))
 
 ;; Quick test
 (assert

contents/euclidean_algorithm/code/coconut/euclidean.coco

@@ -15,5 +15,7 @@ addpattern def euclid_mod(0, b is int) = b
 addpattern def euclid_mod(a is int, b is int) = euclid_mod(b, a % b)
 
 if __name__ == '__main__':
-    print('Euclidean mod:', euclid_mod(64 * 67, 64 * 81))
-    print('Euclidean sub:', euclid_sub(128 * 12, 128 * 77))
+    print('[#]\nModulus-based euclidean algorithm result:')
+    print(euclid_mod(64 * 67, 64 * 81))
+    print('[#]\nSubtraction-based euclidean algorithm result:')
+    print(euclid_sub(128 * 12, 128 * 77))

contents/euclidean_algorithm/code/cpp/euclidean.cpp

@@ -34,6 +34,6 @@ int main() {
   auto check1 = euclid_mod(64 * 67, 64 * 81);
   auto check2 = euclid_sub(128 * 12, 128 * 77);
 
-  std::cout << check1 << '\n';
-  std::cout << check2 << '\n';
+  std::cout << "[#]\nModulus-based euclidean algorithm result:\n" << check1 << '\n';
+  std::cout << "[#]\nSubtraction-based euclidean algorithm result:\n" << check2 << '\n';
 }

contents/euclidean_algorithm/code/csharp/Program.cs

@@ -7,12 +7,13 @@ class Program
     {
         static void Main(string[] args)
         {
-            Console.WriteLine("EuclideanAlgorithm");
             var euclideanAlgorithm = new EuclideanAlgorithm();
             int check = euclideanAlgorithm.EuclidMod(64 * 67, 64 * 81);
             int check2 = euclideanAlgorithm.EuclidSub(128 * 12, 128 * 77);
 
+            Console.WriteLine("[#]\nModulus-based euclidean algorithm result:");
             Console.WriteLine(check);
+            Console.WriteLine("[#]\nSubtraction-based euclidean algorithm result:");
             Console.WriteLine(check2);
         }
     }

contents/euclidean_algorithm/code/d/euclidean_algorithm.d

@@ -37,6 +37,6 @@ void main()
     auto check1 = euclid_mod(64 * 67, 64 * 81);
     auto check2 = euclid_sub(128 * 12, 128 * 77);
 
-    writeln("Modulus-based euclidean algorithm result: ", check1);
-    writeln("Subtraction-based euclidean algorithm result: ", check2);
+    writeln("[#]\nModulus-based euclidean algorithm result:\n", check1);
+    writeln("[#]\nSubtraction-based euclidean algorithm result:\n", check2);
 }

contents/euclidean_algorithm/code/expected.json

@@ -0,0 +1,8 @@
+{
+    "Description": "euclidean algorithm",
+    "Delta" : 0.0,
+    "OutputValues" : [
+        "64",
+        "128"
+    ]
+}

contents/euclidean_algorithm/code/fortran/euclidean.f90

@@ -38,12 +38,18 @@ PROGRAM euclidean
     IMPLICIT NONE
     INTEGER :: a, b, euclid_sub, euclid_mod
 
-    a = 24
-    b = 27
-    WRITE(*,*) 'Subtraction method: GCD is: ', euclid_sub(a, b)
+    a = 64 * 67
+    b = 64 * 81
 
-    a = 24
-    b = 27
-    WRITE(*,*) 'Modulus method:     GCD is: ', euclid_mod(a, b)
+    WRITE(*,'(a)') '[#]'
+    WRITE(*,'(a)') 'Modulus-based euclidean algorithm result:'
+    WRITE(*, '(g0)') euclid_mod(a, b)
+
+    a = 128 * 12
+    b = 128 * 77
+
+    WRITE(*,'(a)') '[#]'
+    WRITE(*,'(a)') 'Subtraction-based euclidean algorithm result:'
+    WRITE(*, '(g0)') euclid_sub(a, b)
 
 END PROGRAM euclidean 

contents/euclidean_algorithm/code/go/euclidean.go

@@ -41,6 +41,8 @@ func main() {
 	check1 := euclidMod(64*67, 64*81)
 	check2 := euclidSub(128*12, 128*77)
 
+	fmt.Println("[#]\nModulus-based euclidean algorithm result:")
 	fmt.Println(check1)
+	fmt.Println("[#]\nSubtraction-based euclidean algorithm result:")
 	fmt.Println(check2)
 }

contents/euclidean_algorithm/code/haskell/euclidean_algorithm.hs

@@ -31,5 +31,7 @@ main :: IO ()
 main = do
   let chk1 = euclidMod (64 * 67) (64 * 81)
       chk2 = euclidSub (128 * 12) (128 * 77)
+  putStrLn "[#]\nModulus-based euclidean algorithm result:"
   print chk1
+  putStrLn "[#]\nSubtraction-based euclidean algorithm result:"
   print chk2

contents/euclidean_algorithm/code/java/EuclideanAlgo.java

@@ -26,7 +26,9 @@ public static int euclidMod(int a, int b) {
     }
 
     public static void main(String[] args) {
+        System.out.println("[#]\nModulus-based euclidean algorithm result:");
         System.out.println(euclidMod(64 * 67, 64 * 81));
+        System.out.println("[#]\nSubtraction-based euclidean algorithm result:");
         System.out.println(euclidSub(128 * 12, 128 * 77));
     }
 }

contents/euclidean_algorithm/code/javascript/euclidean_example.js

@@ -18,14 +18,16 @@ function euclidSub(a, b) {
 
   while (a !== b) {
     if (a > b) {
-      a -= a - b;
+      a -= b;
     } else {
-      b = b - a;
+      b -= a;
     }
   }
 
   return a;
 }
 
+console.log('[#]\nModulus-based euclidean algorithm result:')
 console.log(euclidMod(64 * 67, 64 * 81));
+console.log('[#]\nSubtraction-based euclidean algorithm result:')
 console.log(euclidSub(128 * 12, 128 * 77));

contents/euclidean_algorithm/code/julia/euclidean.jl

@@ -28,8 +28,8 @@ function main()
     check1 = euclid_mod(64 * 67, 64 * 81);
     check2 = euclid_sub(128 * 12, 128 * 77);
 
-    println("Modulus-based euclidean algorithm result: $(check1)")
-    println("subtraction-based euclidean algorithm result: $(check2)")
+    println("[#]\nModulus-based euclidean algorithm result:\n$(check1)")
+    println("[#]\nSubtraction-based euclidean algorithm result:\n$(check2)")
 
 end
 

contents/euclidean_algorithm/code/kotlin/Euclidean.kt

@@ -26,6 +26,8 @@ fun euclidMod(a: Int, b: Int): Int {
 }
 
 fun main(args: Array<String>) {
-    println(euclidSub(128 * 12, 128 * 77))
+    println("[#]\nModulus-based euclidean algorithm result:")
     println(euclidMod(64 * 67, 64 * 81))
-}
+    println("[#]\nSubtraction-based euclidean algorithm result:")
+    println(euclidSub(128 * 12, 128 * 77))
+}

contents/euclidean_algorithm/code/lua/euclidean.lua

@@ -25,8 +25,10 @@ local function euclid_mod(a, b)
 end
 
 local function main()
-  print(euclid_sub(128 * 12, 128 * 77))
+  print("[#]\nModulus-based euclidean algorithm result:")
   print(euclid_mod(64 * 67, 64 * 81))
+  print("[#]\nSubtraction-based euclidean algorithm result:")
+  print(euclid_sub(128 * 12, 128 * 77))
 end
 
 main()

contents/euclidean_algorithm/code/matlab/euclidean.m

@@ -31,6 +31,7 @@
 end
 
 function euclid()
-    ['gcd(520,420) via euclidSub: ',num2str(euclidSub(520,420))]
-    ['gcd(183,244) via euclidMod: ',num2str(euclidMod(183,244))]
+    ['[#] Modulus-based euclidean algorithm result: ',num2str(euclidMod(64 * 67, 64 * 81))]
+
+    ['[#] Subtraction-based euclidean algorithm result: ',num2str(euclidSub(128 * 12, 128 * 77))]
 end

contents/euclidean_algorithm/code/nim/euclid_algorithm.nim

@@ -24,5 +24,7 @@ func euclid_sub(in1, in2: int): int =
   result = a
 
 when isMainModule:
+  echo "[#]\nModulus-based euclidean algorithm result:"
   echo euclid_sub(64 * 67, 64 * 81)
+  echo "[#]\nSubtraction-based euclidean algorithm result:"
   echo euclid_mod(128 * 12, 128 * 77)

contents/euclidean_algorithm/code/ocaml/euclidean_example.ml

@@ -19,6 +19,7 @@ let euclid_sub a b =
 let chk1 = euclid_mod (64 * 67) (64 * 81)
 let chk2 = euclid_sub (128 * 12) (128 * 77)
 let () =
+  Printf.printf "[#]\nModulus-based euclidean algorithm result:\n";
   chk1 |> print_int |> print_newline;
-  chk2 |> print_int |> print_newline
-
+  Printf.printf "[#]\nSubtraction-based euclidean algorithm result:\n";
+  chk2 |> print_int |> print_newline

contents/euclidean_algorithm/code/php/euclidean.php

@@ -29,7 +29,7 @@ function euclid_mod(int $a, int $b): int
     return $a;
 }
 
-printf('Euclidean mod: %s', euclid_mod(64 * 67, 64 * 81));
+printf('[#]'.PHP_EOL.'Modulus-based euclidean algorithm result:'.PHP_EOL.'%s', euclid_mod(64 * 67, 64 * 81));
 echo PHP_EOL;
-printf('Euclidean sub: %s', euclid_sub(128 * 12, 128 * 77));
+printf('[#]'.PHP_EOL.'Subtraction-based euclidean algorithm result:'.PHP_EOL.'%s', euclid_sub(128 * 12, 128 * 77));
 echo PHP_EOL;

contents/euclidean_algorithm/code/powershell/euclidean_algorithm.ps1

@@ -26,5 +26,5 @@ function Mod-Euclid($a, $b) {
     return $a
 }
 
-Write-Host "Subtraction-based euclidean algorithm result: $(Mod-Euclid $(64 * 67) $(64 * 81))"
-Write-Host "Modulus-based euclidean algorithm result: $(Sub-Euclid $(128 * 12) $(128 * 77))"
+Write-Host "[#]`nSubtraction-based euclidean algorithm result:`n$(Mod-Euclid $(64 * 67) $(64 * 81))"
+Write-Host "[#]`nModulus-based euclidean algorithm result:`n$(Sub-Euclid $(128 * 12) $(128 * 77))"

contents/euclidean_algorithm/code/python/euclidean_example.py

@@ -27,5 +27,7 @@ def euclid_sub(a, b):
     return a
 
 if __name__=="__main__":
-    print('Euclidean mod: ', euclid_mod(64 * 67, 64 * 81))
-    print('Euclidean sub: ', euclid_sub(128 * 12, 128 * 77))
+    print('[#]\nModulus-based euclidean algorithm result:'),
+    print(euclid_mod(64 * 67, 64 * 81))
+    print('[#]\nSubtraction-based euclidean algorithm result:')
+    print(euclid_sub(128 * 12, 128 * 77))

contents/euclidean_algorithm/code/racket/euclidean_algorithm.rkt

@@ -23,5 +23,7 @@
     )
   )
 
+(displayln "[#]\nModulus-based euclidean algorithm result:")
 (displayln (euclid_sub (* 64 67) (* 64 81)))
+(displayln "[#]\nSubtraction-based euclidean algorithm result:")
 (displayln (euclid_mod (* 128 12) (* 128 77)))

contents/euclidean_algorithm/code/ruby/euclidean.rb

@@ -17,9 +17,8 @@ def gcd_minus(a, b)
 	end
 	a
 end
-
-p gcd_mod(12 * 6, 12 * 4) #=> 12
-p gcd_mod(9 * 667, 9 * 104) #=> 9
 
-p gcd_minus(12 * 6, 12 * 4) #=> 12
-p gcd_minus(9 * 667, 9 * 104) #=> 9
+print "[#]\nModulus-based euclidean algorithm result:\n"
+p gcd_mod(64 * 67, 64 * 81)
+print "[#]\nSubtraction-based euclidean algorithm result:\n"
+p gcd_minus(128 * 12, 128 * 77)

contents/euclidean_algorithm/code/rust/euclidean_example.rs

@@ -29,6 +29,6 @@ fn euclid_rem(mut a: i64, mut b: i64) -> i64 {
 fn main() {
     let chk1 = euclid_rem(64 * 67, 64 * 81);
     let chk2 = euclid_sub(128 * 12, 128 * 77);
-    println!("{}", chk1);
-    println!("{}", chk2);
+    println!("[#]\nModulus-based euclidean algorithm result:\n{}", chk1);
+    println!("[#]\nSubtraction-based euclidean algorithm result:\n{}", chk2);
 }

contents/euclidean_algorithm/code/scala/euclidean.scala

@@ -3,8 +3,8 @@ object Euclid {
   def euclid_sub(a: Int, b: Int): Int =
     (Math.abs(a), Math.abs(b)) match {
       case (0, _) | (_, 0) => 0
-      case (x, y) if x < y => euclid(x, y - x)
-      case (x, y) if x > y => euclid(x - y, y)
+      case (x, y) if x < y => euclid_sub(x, y - x)
+      case (x, y) if x > y => euclid_sub(x - y, y)
       case _ => a
     }
 
@@ -15,8 +15,10 @@ object Euclid {
     }
 
   def main(args: Array[String]): Unit = {
-    println(euclid_sub(151 * 899, 151 * 182))
-    println(euclid_mod(151 * 899, 151 * 182))
+    println("[#]\nModulus-based euclidean algorithm result:")
+    println(euclid_mod(64 * 67, 64 * 81))
+    println("[#]\nSubtraction-based euclidean algorithm result:")
+    println(euclid_sub(128 * 12, 128 * 77))
   }
 
 }

contents/euclidean_algorithm/code/scheme/euclidalg.ss

@@ -11,6 +11,8 @@
         a
         (euclid-mod b (modulo a b))))
 
+(display "[#]\nModulus-based euclidean algorithm result:") (newline)
 (display (euclid-mod (* 64 67) (* 64 81))) (newline)
-(display (euclid-sub (* 128 12) (* 128 77))) (newline)
 
+(display "[#]\nSubtraction-based euclidean algorithm result:") (newline)
+(display (euclid-sub (* 128 12) (* 128 77))) (newline)

contents/euclidean_algorithm/code/swift/euclidean_algorithm.swift

@@ -27,7 +27,9 @@ func euclidMod(a: Int, b: Int) -> Int {
 }
 
 func main() {
+    print("[#]\nModulus-based euclidean algorithm result:")
     print(euclidMod(a: 64 * 67, b: 64 * 81))
+    print("[#]\nSubtraction-based euclidean algorithm result:")
     print(euclidSub(a: 128 * 12, b: 128 * 77))
 }