Add tasks for all the new languages

Task/Least-common-multiple/8th/least-common-multiple.8th

@@ -0,0 +1,25 @@
+: gcd \ a b -- gcd
+	dup 0 n:= if drop ;; then
+	tuck \ b a b
+	n:mod \ b a-mod-b
+	recurse ; 	
+
+: lcm \ m n
+	2dup \ m n m n
+	n:* \ m n m*n
+	n:abs \ m n abs(m*n)
+	-rot \ abs(m*n) m n
+	gcd \ abs(m*n) gcd(m.n)
+	n:/mod \ abs / gcd
+	nip \ abs div gcd
+;
+
+: demo \ n m --
+	2dup "LCM of " . . " and " . . " = " . lcm . ;	
+
+12 18 demo cr
+-6 14 demo cr
+35  0 demo cr
+
+
+bye

Task/Least-common-multiple/ERRE/least-common-multiple.erre

@@ -0,0 +1,30 @@
+PROGRAM LCM
+
+PROCEDURE GCD(A,B->GCD)
+    LOCAL C
+    WHILE B DO
+        C=A
+        A=B
+        B=C MOD B
+    END WHILE
+    GCD=ABS(A)
+END PROCEDURE
+
+PROCEDURE LCM(M,N->LCM)
+    IF M=0 OR N=0 THEN
+        LCM=0
+        EXIT PROCEDURE
+      ELSE
+        GCD(M,N->GCD)
+        LCM=ABS(M*N)/GCD
+    END IF
+END PROCEDURE
+
+BEGIN
+    LCM(18,12->LCM)
+    PRINT("LCM of 18 AND 12 =";LCM)
+    LCM(14,-6->LCM)
+    PRINT("LCM of 14 AND -6 =";LCM)
+    LCM(0,35->LCM)
+    PRINT("LCM of 0 AND 35 =";LCM)
+END PROGRAM

Task/Least-common-multiple/EchoLisp/least-common-multiple.echolisp

@@ -0,0 +1,6 @@
+(lcm 0 9) → 0
+(lcm 444 888)→ 888
+(lcm 888 999) → 7992
+
+(define (lcm* list) (foldl lcm (first list) list)) → lcm*
+(lcm* '(444 888 999)) → 7992

Task/Least-common-multiple/Ezhil/least-common-multiple.ezhil

@@ -0,0 +1,56 @@
+## இந்த நிரல் இரு எண்களுக்கு இடையிலான மீச்சிறு பொது மடங்கு (LCM), மீப்பெரு பொது வகுத்தி (GCD) என்ன என்று கணக்கிடும்
+
+நிரல்பாகம் மீபொம(எண்1, எண்2)
+
+	@(எண்1 == எண்2) ஆனால்
+
+  ## இரு எண்களும் சமம் என்பதால், மீபொம அந்த எண்ணேதான்
+
+		பின்கொடு எண்1
+
+	@(எண்1 > எண்2) இல்லைஆனால்
+
+		சிறியது = எண்2
+		பெரியது = எண்1
+
+	இல்லை
+	
+		சிறியது = எண்1
+		பெரியது = எண்2
+
+	முடி
+
+	மீதம் = பெரியது % சிறியது
+
+	@(மீதம் == 0) ஆனால்
+
+  ## பெரிய எண்ணில் சிறிய எண் மீதமின்றி வகுபடுவதால், பெரிய எண்தான் மீபொம
+
+		பின்கொடு பெரியது
+
+	இல்லை
+
+		தொடக்கம் = பெரியது + 1
+		நிறைவு = சிறியது * பெரியது
+
+		@(எண் = தொடக்கம், எண் <= நிறைவு, எண் = எண் + 1) ஆக
+
+    ## ஒவ்வோர் எண்ணாக எடுத்துக்கொண்டு தரப்பட்ட இரு எண்களாலும் வகுத்துப் பார்க்கின்றோம். முதலாவதாக இரண்டாலும் மீதமின்றி வகுபடும் எண்தான் மீபொம
+
+			மீதம்1 = எண் % சிறியது
+			மீதம்2 = எண் % பெரியது
+
+			@((மீதம்1 == 0) && (மீதம்2 == 0)) ஆனால்
+				பின்கொடு எண்
+			முடி
+
+		முடி
+
+	முடி	
+
+முடி
+
+அ = int(உள்ளீடு("ஓர் எண்ணைத் தாருங்கள் "))
+ஆ = int(உள்ளீடு("இன்னோர் எண்ணைத் தாருங்கள் "))
+
+பதிப்பி "நீங்கள் தந்த இரு எண்களின் மீபொம (மீச்சிறு பொது மடங்கு, LCM) = ", மீபொம(அ, ஆ)

Task/Least-common-multiple/FreeBASIC/least-common-multiple.freebasic

@@ -0,0 +1,18 @@
+' FB 1.05.0 Win64
+
+Function lcm (m As Integer, n As Integer) As Integer
+  If m = 0 OrElse n = 0 Then Return 0
+  If m < n Then Swap m, n '' to minimize iterations needed
+  Var count = 0
+  Do
+    count +=1
+  Loop Until (m * count) Mod n  = 0
+  Return m * count
+End Function
+
+Print "lcm(12, 18) ="; lcm(12, 18)
+Print "lcm(15, 12) ="; lcm(15, 12)
+Print "lcm(10, 14) ="; lcm(10, 14)
+Print
+Print "Press any key to quit"
+Sleep

Task/Least-common-multiple/FunL/least-common-multiple.funl

@@ -0,0 +1,4 @@
+def
+  lcm( _, 0 ) =  0
+  lcm( 0, _ ) =  0
+  lcm( x, y ) =  abs( (x\gcd(x, y)) y )

Task/Least-common-multiple/Lasso/least-common-multiple.lasso

@@ -0,0 +1,19 @@
+define gcd(a,b) => {
+	while(#b != 0) => {
+		local(t = #b)
+		#b = #a % #b
+		#a = #t
+	}
+	return #a
+}
+define lcm(m,n) => {
+	 #m == 0 || #n == 0 ? return 0
+	 local(r = (#m * #n) / decimal(gcd(#m, #n)))
+	 return integer(#r)->abs
+}
+
+lcm(-6, 14)
+lcm(2, 0)
+lcm(12, 18)
+lcm(12, 22)
+lcm(7, 31)

Task/Least-common-multiple/Nim/least-common-multiple.nim

@@ -0,0 +1,15 @@
+proc gcd(u, v): auto =
+  var
+    t = 0
+    u = u
+    v = v
+  while v != 0:
+    t = u
+    u = v
+    v = t %% v
+  abs(u)
+
+proc lcm(a, b): auto = abs(a * b) div gcd(a, b)
+
+echo lcm(12, 18)
+echo lcm(-6, 14)

Task/Least-common-multiple/Oforth/least-common-multiple.oforth

@@ -0,0 +1 @@
+12 18 lcm

Task/Least-common-multiple/Phix/least-common-multiple.phix

@@ -0,0 +1,3 @@
+function lcm(integer m, integer n)
+    return m / gcd(m, n) * n
+end function

Task/Least-common-multiple/Ring/least-common-multiple.ring

@@ -0,0 +1,13 @@
+see lcm(24,36)
+
+func lcm m,n
+     lcm = m*n / gcd(m,n)
+     return lcm
+
+func gcd gcd, b
+     while b
+           c   = gcd
+           gcd = b
+           b   = c % b
+     end
+     return gcd

Task/Least-common-multiple/Sidef/least-common-multiple-1.sidef

@@ -0,0 +1 @@
+say Math.lcm(1001, 221)

Task/Least-common-multiple/Sidef/least-common-multiple-2.sidef

@@ -0,0 +1,10 @@
+func gcd(a, b) {
+    while (a) { (a, b) = (b % a, a) }
+    return b
+}
+
+func lcm(a, b) {
+    (a && b) ? (a / gcd(a, b) * b) : 0
+}
+
+say lcm(1001, 221)

Task/Least-common-multiple/Sparkling/least-common-multiple.sparkling

@@ -0,0 +1,33 @@
+function factors(n) {
+	var f = {};
+
+	for var i = 2; n > 1; i++ {
+		while n % i == 0 {
+			n /= i;
+			f[i] = f[i] != nil ? f[i] + 1 : 1;
+		}
+	}
+
+	return f;
+}
+
+function GCD(n, k) {
+	let f1 = factors(n);
+	let f2 = factors(k);
+
+	let fs = map(f1, function(factor, multiplicity) {
+		let m = f2[factor];
+		return m == nil ? 0 : min(m, multiplicity);
+	});
+
+	let rfs = {};
+	foreach(fs, function(k, v) {
+		rfs[sizeof rfs] = pow(k, v);
+	});
+
+	return reduce(rfs, 1, function(x, y) { return x * y; });
+}
+
+function LCM(n, k) {
+	return n * k / GCD(n, k);
+}

Task/Least-common-multiple/Swift/least-common-multiple.swift

@@ -0,0 +1,3 @@
+func lcm(a:Int, b:Int) -> Int {
+    return abs(a * b) / gcd_rec(a, b)
+}

Task/Least-common-multiple/Ursa/least-common-multiple.ursa

@@ -0,0 +1,2 @@
+import "math"
+out (lcm 12 18) endl console

Task/Least-common-multiple/Wortel/least-common-multiple-1.wortel

@@ -0,0 +1 @@
+@lcm a b

Task/Least-common-multiple/Wortel/least-common-multiple-2.wortel

@@ -0,0 +1 @@
+!#~km a b

Task/Least-common-multiple/Wortel/least-common-multiple-3.wortel

@@ -0,0 +1 @@
+&[a b] *b /a @gcd a b

Task/Least-common-multiple/jq/least-common-multiple.jq

@@ -0,0 +1,6 @@
+# Define the helper function to take advantage of jq's tail-recursion optimization
+def lcm(m; n):
+  def _lcm:
+    # state is [m, n, i]
+    if (.[2] % .[1]) == 0 then .[2] else (.[0:2] + [.[2] + m]) | _lcm end;
+  [m, n, m] | _lcm;