@@ -65,25 +65,16 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout
65
65
# Example Code
66
66
### C++
67
67
``` cpp
68
- /* -------------euclidean.cpp--------------------------------------------------//
69
- *
70
- * Purpose: To implement euclidean algorithm to find the greatest common divisor
71
- *
72
- * Notes: Compile with g++ euclidean.cpp
73
- *
74
- *-----------------------------------------------------------------------------*/
75
-
76
68
#include < iostream>
77
69
#include < cmath>
78
70
79
- // Euclidean algorithm with mod
80
- int euclid_mod (int a, int b){
71
+ // Euclidean algorithm using modulus
72
+ int euclid_mod (int a, int b)
73
+ {
81
74
a = std::abs(a);
82
75
b = std::abs(b);
83
-
84
- int temp;
85
- while (b != 0){
86
- temp = b;
76
+ while (b != 0) {
77
+ int temp = b;
87
78
b = a%b;
88
79
a = temp;
89
80
}
@@ -92,28 +83,28 @@ int euclid_mod(int a, int b){
92
83
}
93
84
94
85
// Euclidean algorithm with subtraction
95
- int euclid_sub(int a, int b){
86
+ int euclid_sub(int a, int b)
87
+ {
96
88
a = std::abs(a);
97
89
b = std::abs(b);
98
-
99
- while (a != b){
100
- if (a > b){
101
- a = a - b;
90
+ while (a != b) {
91
+ if (a > b) {
92
+ a -= b;
102
93
}
103
- else{
104
- b = b - a;
94
+ else {
95
+ b -= a;
105
96
}
106
97
}
107
98
108
99
return a;
109
100
}
110
101
111
- int main(){
112
-
113
- int check = euclid_mod(64*67, 64*81);
114
- int check2 = euclid_sub(128*12, 128*77);
102
+ int main()
103
+ {
104
+ auto check1 = euclid_mod(64* 67, 64* 81);
105
+ auto check2 = euclid_sub(128* 12, 128* 77);
115
106
116
- std::cout << check << '\n';
107
+ std::cout << check1 << '\n';
117
108
std::cout << check2 << '\n';
118
109
}
119
110
@@ -122,44 +113,45 @@ int main(){
122
113
### C
123
114
```c
124
115
#include <stdio.h>
125
- #include <stdlib .h>
116
+ #include <math .h>
126
117
127
- int euclid_mod(int a, int b){
118
+ int euclid_mod(int a, int b)
119
+ {
128
120
a = abs(a);
129
121
b = abs(b);
130
122
131
- int temp;
132
123
while (b != 0){
133
- temp = b;
124
+ int temp = b;
134
125
b = a%b;
135
126
a = temp;
136
127
}
137
128
138
129
return a;
139
130
}
140
131
141
- int euclid_sub(int a, int b){
132
+ int euclid_sub(int a, int b)
133
+ {
142
134
a = abs(a);
143
135
b = abs(b);
144
136
145
- while (a != b){
146
- if (a > b){
147
- a = a - b;
137
+ while (a != b) {
138
+ if (a > b) {
139
+ a -= b;
148
140
}
149
- else{
150
- b = b - a;
141
+ else {
142
+ b -= a;
151
143
}
152
144
}
153
145
154
146
return a;
155
147
}
156
148
157
- int main(){
158
-
159
- int check = euclid_mod(64*67, 64*81);
149
+ int main()
150
+ {
151
+ int check1 = euclid_mod(64*67, 64*81);
160
152
int check2 = euclid_sub(128*12, 128*77);
161
153
162
- printf("%d\n", check );
154
+ printf("%d\n", check1 );
163
155
printf("%d\n", check2);
164
156
}
165
157
@@ -248,7 +240,7 @@ print euclid_sub(128 * 12, 128 * 77)
248
240
### C#
249
241
250
242
``` cs
251
- // submitted by Julian Schacher
243
+ // submitted by Julian Schacher
252
244
using System ;
253
245
254
246
namespace Euclidean_Algorithm
@@ -307,17 +299,19 @@ namespace Euclidean_Algorithm
307
299
308
300
``` haskell
309
301
euclidSub :: Integer -> Integer -> Integer
310
- euclidSub a b =
311
- if a == b then
312
- a
313
- else if a < b then
314
- euclidSub a (b - a)
315
- else
316
- euclidSub (a - b) b
302
+ euclidSub a b = inner (abs a) (abs b) where
303
+ inner a b =
304
+ if a == b then
305
+ a
306
+ else if a < b then
307
+ euclidSub a (b - a)
308
+ else
309
+ euclidSub (a - b) b
317
310
318
311
euclidMod :: Integer -> Integer -> Integer
319
- euclidMod a 0 = a
320
- euclidMod a b = euclidMod b (a `mod` b)
312
+ euclidMod a b = inner (abs a) (abs b) where
313
+ inner a 0 = a
314
+ inner a b = inner b (a `mod` b)
321
315
322
316
main :: IO ()
323
317
main = do
@@ -331,55 +325,64 @@ main = do
331
325
### Rust
332
326
333
327
``` rust
334
- fn euclid_sub (mut a : u64 , mut b : u64 ) -> u64 {
335
- while a != b {
336
- if a < b {
337
- b = b - a ;
338
- } else {
339
- a = a - b ;
328
+ fn euclid_sub (mut a : i64 , mut b : i64 ) -> i64 {
329
+ a = a . abs ();
330
+ b = b . abs ();
331
+ while a != b {
332
+ if a < b {
333
+ b -= a ;
334
+ } else {
335
+ a -= b ;
336
+ }
340
337
}
341
- }
342
- a
338
+
339
+ a
343
340
}
344
341
345
- fn euclid_rem (mut a : u64 , mut b : u64 ) -> u64 {
346
- while b != 0 {
347
- let tmp = b ;
348
- b = a % b ;
349
- a = tmp ;
350
- }
351
- a
342
+ fn euclid_rem (mut a : i64 , mut b : i64 ) -> i64 {
343
+ a = a . abs ();
344
+ b = b . abs ();
345
+ while b != 0 {
346
+ let tmp = b ;
347
+ b = a % b ;
348
+ a = tmp ;
349
+ }
350
+
351
+ a
352
352
}
353
353
354
354
fn main () {
355
- let chk1 = euclid_rem (64 * 67 , 64 * 81 );
356
- let chk2 = euclid_sub (128 * 12 , 128 * 77 );
357
- println! (" {}" , chk1 );
358
- println! (" {}" , chk2 );
355
+ let chk1 = euclid_rem (64 * 67 , 64 * 81 );
356
+ let chk2 = euclid_sub (128 * 12 , 128 * 77 );
357
+ println! (" {}" , chk1 );
358
+ println! (" {}" , chk2 );
359
359
}
360
360
```
361
361
362
362
### OCaml
363
363
364
364
``` ocaml
365
- let rec euclid_mod a b =
366
- if b = 0 then
367
- a
368
- else
369
- euclid_mod b (a mod b)
370
-
371
- let rec euclid_sub a b =
372
- if a = b then
373
- a
374
- else if a < b then
375
- euclid_sub a (b - a)
376
- else
377
- euclid_sub (a - b) b
365
+ let euclid_mod a b =
366
+ let rec inner a = function
367
+ | 0 -> a
368
+ | b -> inner b (a mod b)
369
+ in (inner (abs a) (abs b))
370
+
371
+ let euclid_sub a b =
372
+ let rec inner a b =
373
+ if a = b then
374
+ a
375
+ else if a < b then
376
+ inner a (b - a)
377
+ else
378
+ inner (a - b) b
379
+ in (inner (abs a) (abs b))
378
380
379
381
let chk1 = euclid_mod (64 * 67) (64 * 81)
380
382
let chk2 = euclid_sub (128 * 12) (128 * 77)
381
- let () = print_string ((int_of_string chk1) ^ "\n")
382
- let () = print_string ((int_of_string chk2) ^ "\n")
383
+ let () =
384
+ chk1 |> print_int |> print_newline;
385
+ chk2 |> print_int |> print_newline
383
386
```
384
387
385
388
### Java
@@ -393,8 +396,8 @@ public static void main(String[] args) {
393
396
}
394
397
395
398
public static int euclidSub(int a, int b) {
396
- a = Math . abs(a);
397
- b = Math . abs(b);
399
+ a = Math . abs(a);
400
+ b = Math . abs(b);
398
401
399
402
while (a != b) {
400
403
if (a > b) {
@@ -408,8 +411,8 @@ public static int euclidSub(int a, int b) {
408
411
}
409
412
410
413
public static int euclidMod(int a, int b) {
411
- a = Math . abs(a);
412
- b = Math . abs(b);
414
+ a = Math . abs(a);
415
+ b = Math . abs(b);
413
416
414
417
while (b != 0 ){
415
418
int temp = b;
@@ -418,5 +421,5 @@ public static int euclidMod(int a, int b) {
418
421
}
419
422
420
423
return a;
421
- }
424
+ }
422
425
```
0 commit comments