Add tasks for all the new languages
This commit is contained in:
Tina Müller
parent
9dc3c2bb62
commit
bba7bfd280
13208 changed files with 134745 additions and 0 deletions
14
Task/Greatest-common-divisor/8th/greatest-common-divisor.8th
Normal file
14
Task/Greatest-common-divisor/8th/greatest-common-divisor.8th
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
: gcd \ a b -- gcd
|
||||
dup 0 n:= if drop ;; then
|
||||
tuck \ b a b
|
||||
n:mod \ b a-mod-b
|
||||
recurse ;
|
||||
|
||||
: demo \ a b --
|
||||
2dup "GCD of " . . " and " . . " = " . gcd . ;
|
||||
|
||||
100 5 demo cr
|
||||
5 100 demo cr
|
||||
7 23 demo cr
|
||||
|
||||
bye
|
||||
|
|
@ -0,0 +1 @@
|
|||
gcd[33; 77]
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
/Unoptimized version
|
||||
gcd':{a:x;b:y;last[{(0 eq a mod x) min (0 eq b mod x)} hfilter {1 + x} map range[a max b]]}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
-- gcd :: Int -> Int -> Int
|
||||
on gcd(a, b)
|
||||
if b ≠ 0 then
|
||||
gcd(b, a mod b)
|
||||
else
|
||||
if a < 0 then
|
||||
-a
|
||||
else
|
||||
a
|
||||
end if
|
||||
end if
|
||||
end gcd
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
0 A = ABS(INT(A))
|
||||
1 B = ABS(INT(B))
|
||||
2 GCD = A * NOT NOT B
|
||||
3 FOR B = B + A * NOT B TO 0 STEP 0
|
||||
4 A = GCD
|
||||
5 GCD = B
|
||||
6 B = A - INT (A / GCD) * GCD
|
||||
7 NEXT B
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
Lbl GCD
|
||||
r₁→A
|
||||
r₂→B
|
||||
!If B
|
||||
A
|
||||
Return
|
||||
End
|
||||
GCD(B,A^B)
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
PROGRAM EUCLIDE
|
||||
! calculate G.C.D. between two integer numbers
|
||||
! using Euclidean algorithm
|
||||
|
||||
!VAR J%,K%,MCD%,A%,B%
|
||||
|
||||
BEGIN
|
||||
PRINT(CHR$(12);"Input two numbers : ";) !CHR$(147) in C-64 version
|
||||
INPUT(J%,K%)
|
||||
A%=J% B%=K%
|
||||
WHILE A%<>B% DO
|
||||
IF A%>B%
|
||||
THEN
|
||||
A%=A%-B%
|
||||
ELSE
|
||||
B%=B%-A%
|
||||
END IF
|
||||
END WHILE
|
||||
MCD%=A%
|
||||
PRINT("G.C.D. between";J%;"and";K%;"is";MCD%)
|
||||
END PROGRAM
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
## இந்த நிரல் இரு எண்களுக்கு இடையிலான மீச்சிறு பொது மடங்கு (LCM), மீப்பெரு பொது வகுத்தி (GCD) என்ன என்று கணக்கிடும்
|
||||
|
||||
நிரல்பாகம் மீபொவ(எண்1, எண்2)
|
||||
|
||||
@(எண்1 == எண்2) ஆனால்
|
||||
|
||||
## இரு எண்களும் சமம் என்பதால், அந்த எண்ணேதான் அதன் மீபொவ
|
||||
|
||||
பின்கொடு எண்1
|
||||
|
||||
@(எண்1 > எண்2) இல்லைஆனால்
|
||||
|
||||
சிறியது = எண்2
|
||||
பெரியது = எண்1
|
||||
|
||||
இல்லை
|
||||
|
||||
சிறியது = எண்1
|
||||
பெரியது = எண்2
|
||||
|
||||
முடி
|
||||
|
||||
மீதம் = பெரியது % சிறியது
|
||||
|
||||
@(மீதம் == 0) ஆனால்
|
||||
|
||||
## பெரிய எண்ணில் சிறிய எண் மீதமின்றி வகுபடுவதால், சிறிய எண்தான் மீப்பெரு பொதுவகுத்தியாக இருக்கமுடியும்
|
||||
|
||||
பின்கொடு சிறியது
|
||||
|
||||
இல்லை
|
||||
|
||||
தொடக்கம் = சிறியது - 1
|
||||
|
||||
நிறைவு = 1
|
||||
|
||||
@(எண் = தொடக்கம், எண் >= நிறைவு, எண் = எண் - 1) ஆக
|
||||
|
||||
மீதம்1 = சிறியது % எண்
|
||||
|
||||
மீதம்2 = பெரியது % எண்
|
||||
|
||||
## இரு எண்களையும் மீதமின்றி வகுக்கக்கூடிய பெரிய எண்ணைக் கண்டறிகிறோம்
|
||||
|
||||
@((மீதம்1 == 0) && (மீதம்2 == 0)) ஆனால்
|
||||
|
||||
பின்கொடு எண்
|
||||
|
||||
முடி
|
||||
|
||||
முடி
|
||||
|
||||
முடி
|
||||
|
||||
முடி
|
||||
|
||||
அ = int(உள்ளீடு("ஓர் எண்ணைத் தாருங்கள் "))
|
||||
ஆ = int(உள்ளீடு("இன்னோர் எண்ணைத் தாருங்கள் "))
|
||||
|
||||
பதிப்பி "நீங்கள் தந்த இரு எண்களின் மீபொவ (மீப்பெரு பொது வகுத்தி, GCD) = ", மீபொவ(அ, ஆ)
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
' version 17-06-2015
|
||||
' compile with: fbc -s console
|
||||
|
||||
Function gcd(x As ULongInt, y As ULongInt) As ULongInt
|
||||
|
||||
Dim As ULongInt t
|
||||
|
||||
While y
|
||||
t = y
|
||||
y = x Mod y
|
||||
x = t
|
||||
Wend
|
||||
|
||||
Return x
|
||||
|
||||
End Function
|
||||
|
||||
' ------=< MAIN >=------
|
||||
|
||||
Dim As ULongInt a = 111111111111111
|
||||
Dim As ULongInt b = 11111
|
||||
|
||||
Print : Print "GCD(";a;", ";b;") = "; gcd(a, b)
|
||||
Print : Print "GCD(";a;", 111) = "; gcd(a, 111)
|
||||
|
||||
' empty keyboard buffer
|
||||
While InKey <> "" : Wend
|
||||
Print : Print : Print "hit any key to end program"
|
||||
Sleep
|
||||
End
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
def
|
||||
gcd( 0, 0 ) = error( 'integers.gcd: gcd( 0, 0 ) is undefined' )
|
||||
gcd( a, b ) =
|
||||
def
|
||||
_gcd( a, 0 ) = a
|
||||
_gcd( a, b ) = _gcd( b, a%b )
|
||||
|
||||
_gcd( abs(a), abs(b) )
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
local fn gcd( a as long, b as long )
|
||||
dim as long result
|
||||
|
||||
if ( b != 0 )
|
||||
result = fn gcd( b, a mod b)
|
||||
else
|
||||
result = abs(a)
|
||||
end if
|
||||
end fn = result
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
# Built-in
|
||||
GcdInt(35, 42);
|
||||
# 7
|
||||
|
||||
# Euclidean algorithm
|
||||
GcdInteger := function(a, b)
|
||||
local c;
|
||||
a := AbsInt(a);
|
||||
b := AbsInt(b);
|
||||
while b > 0 do
|
||||
c := a;
|
||||
a := b;
|
||||
b := RemInt(c, b);
|
||||
od;
|
||||
return a;
|
||||
end;
|
||||
|
||||
GcdInteger(35, 42);
|
||||
# 7
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
'
|
||||
' Greatest Common Divisor
|
||||
'
|
||||
a%=24
|
||||
b%=112
|
||||
PRINT "GCD of ";a%;" and ";b%;" is ";@gcd(a%,b%)
|
||||
'
|
||||
' Function computes gcd
|
||||
'
|
||||
FUNCTION gcd(a%,b%)
|
||||
LOCAL t%
|
||||
'
|
||||
WHILE b%<>0
|
||||
t%=a%
|
||||
a%=b%
|
||||
b%=t% MOD b%
|
||||
WEND
|
||||
'
|
||||
RETURN ABS(a%)
|
||||
ENDFUNC
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
> (defun gcd
|
||||
"Get the greatest common divisor."
|
||||
((a 0) a)
|
||||
((a b) (gcd b (rem a b))))
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
function gcd x,y
|
||||
repeat until y = 0
|
||||
put x mod y into z
|
||||
put y into x
|
||||
put z into y
|
||||
end repeat
|
||||
return x
|
||||
end gcd
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
function gcd(a: int, b: int): int = (
|
||||
if a==0 then b
|
||||
else if b==0 then a
|
||||
else if a>b then gcd(b, a % b)
|
||||
else gcd(a, b % a)
|
||||
)
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
// Greatest common divisor
|
||||
00 0E GCD: ENT R0
|
||||
01 1E ENT R1
|
||||
02 21 Again: R2 = R1
|
||||
03 10 Loop: R1 = R0
|
||||
04 02 R0 = R2
|
||||
05 2D Minus: DEC R2
|
||||
06 8A JZ Stop
|
||||
07 1D DEC R1
|
||||
08 C5 JNZ Minus
|
||||
09 83 JZ Loop
|
||||
0A 1D Stop: DEC R1
|
||||
0B C2 JNZ Again
|
||||
0C 80 JZ GCD // Display GCD in R0
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
proc gcd_recursive(u, v: int64): int64 =
|
||||
if u %% v != 0:
|
||||
result = gcd_recursive(v, u %% v)
|
||||
else:
|
||||
result = v
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
proc gcd_iterative(u1, v1: int64): int64 =
|
||||
var t: int64 = 0
|
||||
var u = u1
|
||||
var v = v1
|
||||
while v != 0:
|
||||
t = u
|
||||
u = v
|
||||
v = t %% v
|
||||
result = abs(u)
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
proc gcd_binary(u1, v1: int64): int64 =
|
||||
var t, k: int64
|
||||
var u = u1
|
||||
var v = v1
|
||||
u = abs(u)
|
||||
v = abs(v)
|
||||
if u < v:
|
||||
t = u
|
||||
u = v
|
||||
v = t
|
||||
if v == 0:
|
||||
result = u
|
||||
else:
|
||||
k = 1
|
||||
while (u %% 2 == 0) and (v %% 2 == 0):
|
||||
u = u shl 1
|
||||
v = v shl 1
|
||||
k = k shr 1
|
||||
if (u %% 2) == 0:
|
||||
t = u
|
||||
else:
|
||||
t = -v
|
||||
while t != 0:
|
||||
while (t %% 2) == 0:
|
||||
t = t div 2
|
||||
if t > 0:
|
||||
u = t
|
||||
else:
|
||||
v = -t
|
||||
t = u - v
|
||||
result = u * k
|
||||
|
||||
echo ("GCD(", 49865, ", ", 69811, "): ", gcd_iterative(49865, 69811), " (iterative)")
|
||||
echo ("GCD(", 49865, ", ", 69811, "): ", gcd_recursive(49865, 69811), " (recursive)")
|
||||
echo ("GCD(", 49865, ", ", 69811, "): ", gcd_binary (49865, 69811), " (binary)")
|
||||
|
|
@ -0,0 +1 @@
|
|||
128 96 gcd
|
||||
|
|
@ -0,0 +1 @@
|
|||
Integer method: gcd self while ( dup ) [ tuck mod ] drop ;
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
function gcd(object u, atom v=0)
|
||||
atom t
|
||||
if sequence(u) then
|
||||
v = u[1] -- (for the typecheck)
|
||||
t = floor(abs(v))
|
||||
for i=2 to length(u) do
|
||||
v = u[i] -- (for the typecheck)
|
||||
t = gcd(t,v)
|
||||
end for
|
||||
return t
|
||||
end if
|
||||
u = floor(abs(u))
|
||||
v = floor(abs(v))
|
||||
while v do
|
||||
t = u
|
||||
u = v
|
||||
v = remainder(t, v)
|
||||
end while
|
||||
return u
|
||||
end function
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
see gcd (24, 32)
|
||||
func gcd gcd, b
|
||||
while b
|
||||
c = gcd
|
||||
gcd = b
|
||||
b = c % b
|
||||
end
|
||||
return gcd
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
gcd(a, b) :=
|
||||
a when b = 0
|
||||
else
|
||||
gcd(b, a mod b);
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
var arr = [100, 1_000, 10_000, 20];
|
||||
say Math.gcd(arr...);
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
func gcd(a, b) {
|
||||
b.is_zero ? a.abs : gcd(b, a % b);
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
// Iterative
|
||||
|
||||
func gcd(var a: Int, var b: Int) -> Int {
|
||||
|
||||
a = abs(a); b = abs(b)
|
||||
|
||||
if (b > a) { swap(&a, &b) }
|
||||
|
||||
while (b > 0) { (a, b) = (b, a % b) }
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
// Recursive
|
||||
|
||||
func gcdr (var a: Int, var b: Int) -> Int {
|
||||
|
||||
a = abs(a); b = abs(b)
|
||||
|
||||
if (b > a) { swap(&a, &b) }
|
||||
|
||||
return gcd_rec(a,b)
|
||||
}
|
||||
|
||||
|
||||
private func gcd_rec(a: Int, b: Int) -> Int {
|
||||
|
||||
return b == 0 ? a : gcd_rec(b, a % b)
|
||||
}
|
||||
|
||||
|
||||
for (a,b) in [(1,1), (100, -10), (10, -100), (-36, -17), (27, 18), (30, -42)] {
|
||||
|
||||
println("Iterative: GCD of \(a) and \(b) is \(gcd(a, b))")
|
||||
println("Recursive: GCD of \(a) and \(b) is \(gcdr(a, b))")
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
function gcd(a: number, b: number) {
|
||||
a = Math.abs(a);
|
||||
b = Math.abs(b);
|
||||
|
||||
if (b > a) {
|
||||
let temp = a;
|
||||
a = b;
|
||||
b = temp;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
a %= b;
|
||||
if (a === 0) { return b; }
|
||||
b %= a;
|
||||
if (b === 0) { return a; }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
function gcd_rec(a: number, b: number) {
|
||||
return b ? gcd_rec(b, a % b) : Math.abs(a);
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
import "math"
|
||||
out (gcd 40902 24140) endl console
|
||||
|
|
@ -0,0 +1 @@
|
|||
@gcd a b
|
||||
|
|
@ -0,0 +1 @@
|
|||
!#~kg a b
|
||||
|
|
@ -0,0 +1 @@
|
|||
&[a b] [@vars[t] @while b @:{t b b %a b a t} a]
|
||||
|
|
@ -0,0 +1 @@
|
|||
&{gcd a b} ?{b !!gcd b %a b @abs a}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
def recursive_gcd(a; b):
|
||||
if b == 0 then a
|
||||
else recursive_gcd(b; a % b)
|
||||
end ;
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
def gcd(a; b):
|
||||
# The subfunction expects [a,b] as input
|
||||
# i.e. a ~ .[0] and b ~ .[1]
|
||||
def rgcd: if .[1] == 0 then .[0]
|
||||
else [.[1], .[0] % .[1]] | rgcd
|
||||
end;
|
||||
[a,b] | rgcd ;
|
||||
Loading…
Add table
Add a link
Reference in a new issue