Coprimes: Difference between revisions

Line 10:

<~~lang~~ 11l>F coprime(a, b)

<syntaxhighlight lang="11l">F coprime(a, b)

R gcd(a, b) == 1

Line 17:

(36, 12),

(18, 29),

(60, 15)].filter((x, y) -> coprime(x, y)))</~~lang~~>

(60, 15)].filter((x, y) -> coprime(x, y)))</syntaxhighlight>

Line 25:

=={{header|8080 Assembly}}==

<~~lang~~ 8080asm>puts: equ 9

<syntaxhighlight lang="8080asm">puts: equ 9

org 100h

lxi h,pairs

Line 87:

db '***' ; Number output buffer

nbuf: db ' $'

nl: db 13,10,'$'</~~lang~~>

nl: db 13,10,'$'</syntaxhighlight>

<pre>17 23

Line 93:

=={{header|8086 Assembly}}==

<~~lang~~ asm>puts: equ 9 ; MS-DOS syscall to print a string

<syntaxhighlight lang="asm">puts: equ 9 ; MS-DOS syscall to print a string

cpu 8086

org 100h

Line 143:

db 18,29

db 60,15

dw 0</~~lang~~>

dw 0</syntaxhighlight>

<pre>17 23

18 29</pre>

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>INT FUNC Gcd(INT a,b)

<syntaxhighlight lang="action!">INT FUNC Gcd(INT a,b)

INT tmp

Line 179:

Test(18,29)

Test(60,15)

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Coprimes.png Screenshot from Atari 8-bit computer]

Line 191:

=={{header|ALGOL 68}}==

<~~lang~~ algol68>BEGIN # test the coprime-ness of some number pairs #

<syntaxhighlight lang="algol68">BEGIN # test the coprime-ness of some number pairs #

# iterative Greatest Common Divisor routine, returns the gcd of m and n #

PROC gcd = ( INT m, n )INT:

Line 214:

FI

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 223:

=={{header|ALGOL W}}==

<~~lang~~ algolw>BEGIN % check whether sme numbers are coPrime (their gcd is 1) or not %

<syntaxhighlight lang="algolw">BEGIN % check whether sme numbers are coPrime (their gcd is 1) or not %

LOGICAL PROCEDURE COPRM ( INTEGER VALUE X, Y ) ; GCD( X, Y ) = 1;

INTEGER PROCEDURE GCD ( INTEGER VALUE A, B ) ;

Line 247:

IF COPRM( PP, QQ ) THEN WRITE( I_W := 4, S_W := 0, PP, QQ )

END FOR_I

END.</~~lang~~>

END.</syntaxhighlight>

<pre>

Line 257:

=={{header|APL}}==

<~~lang~~ apl>(⊢(/⍨)1=∨/¨) (21 15)(17 23)(36 12)(18 29)(60 15)</~~lang~~>

<pre>┌─────┬─────┐

Line 264:

=={{header|AppleScript}}==

<~~lang~~ applescript>on hcf(a, b)

<syntaxhighlight lang="applescript">on hcf(a, b)

repeat until (b = 0)

set x to a

Line 282:

if (hcf(p, q) is 1) then set end of coprimes to thisPair's contents

end repeat

return coprimes</~~lang~~>

return coprimes</syntaxhighlight>

<~~lang~~ applescript>{{17, 23}, {18, 29}}</~~lang~~>

or, composing a definition and test from more general functions:

<~~lang~~ applescript>------------------------- COPRIME ------------------------

<syntaxhighlight lang="applescript">------------------------- COPRIME ------------------------

-- coprime :: Int -> Int -> Bool

Line 365:

end script

end if

end mReturn</~~lang~~>

end mReturn</syntaxhighlight>

=={{header|Arturo}}==

<~~lang~~ rebol>coprimes?: function [a b] -> 1 = gcd @[a b]

<syntaxhighlight lang="rebol">coprimes?: function [a b] -> 1 = gcd @[a b]

loop [[21 15] [17 23] [36 12] [18 29] [60 15]] 'pair [

print [pair\0 "and" pair\1 "ara" (coprimes? pair\0 pair\1)? -> "coprimes." -> "not coprimes."]

]</~~lang~~>

]</syntaxhighlight>

Line 385:

=={{header|AWK}}==

# syntax: GAWK -f COPRIMES.AWK

BEGIN {

Line 402:

return(q?gcd(q,(p%q)):p)

}

</syntaxhighlight>

</lang>

<pre>

Line 410:

=={{header|BASIC}}==

<~~lang~~ basic>10 DEFINT A-Z

<syntaxhighlight lang="basic">10 DEFINT A-Z

20 READ N

30 FOR I=1 TO N

Line 424:

130 DATA 36,12

140 DATA 18,29

150 DATA 60,15</~~lang~~>

150 DATA 60,15</syntaxhighlight>

<pre> 17 23

Line 430:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

let gcd(a,b) = b=0 -> a, gcd(b, a rem b)

Line 442:

for i=0 to n-1

if coprime(ps!i, qs!i) do writef("%N %N*N", ps!i, qs!i)

$)</~~lang~~>

$)</syntaxhighlight>

<pre>17 23

Line 448:

=={{header|BQN}}==

<~~lang~~ bqn>GCD ← {𝕨(|𝕊⍟(>⟜0)⊣)𝕩}

<syntaxhighlight lang="bqn">GCD ← {𝕨(|𝕊⍟(>⟜0)⊣)𝕩}

SelectCoprimes ← (1=GCD´¨)⊸/

SelectCoprimes ⟨21‿15,17‿23,36‿12,18‿29,60‿15⟩</~~lang~~>

SelectCoprimes ⟨21‿15,17‿23,36‿12,18‿29,60‿15⟩</syntaxhighlight>

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

int gcd(int a, int b) {

Line 487:

}

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre>{17, 23}

Line 493:

=={{header|C++}}==

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

#include <algorithm>

#include <vector>

Line 532:

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre>{17, 23}

Line 538:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub gcd(a: uint8, b: uint8): (r: uint8) is

Line 571:

end if;

i := i + 1;

end loop;</~~lang~~>

end loop;</syntaxhighlight>

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>

// Coprimes. Nigel Galloway: May 4th., 2021

let rec fN g=function 0->g=1 |n->fN n (g%n)

[(21,15);(17,23);(36,12);(18,29);(60,15)] |> List.filter(fun(n,g)->fN n g)|>List.iter(fun(n,g)->printfn "%d and %d are coprime" n g)

</syntaxhighlight>

</lang>

<pre>

Line 586:

=={{header|Factor}}==

<~~lang~~ factor>USING: io kernel math prettyprint sequences ;

<syntaxhighlight lang="factor">USING: io kernel math prettyprint sequences ;

: coprime? ( seq -- ? ) [ ] [ simple-gcd ] map-reduce 1 = ;

Line 598:

{ 21 22 25 31 143 }

}

[ dup pprint coprime? [ " Coprime" write ] when nl ] each</~~lang~~>

[ dup pprint coprime? [ " Coprime" write ] when nl ] each</syntaxhighlight>

<pre>

Line 610:

=={{header|Fermat}}==

<~~lang~~ fermat>Func Is_coprime(a, b) = if GCD(a,b)=1 then 1 else 0 fi.</~~lang~~>

<syntaxhighlight lang="fermat">Func Is_coprime(a, b) = if GCD(a,b)=1 then 1 else 0 fi.</syntaxhighlight>

=={{header|FOCAL}}==

<~~lang~~ focal>01.10 S P(1)=21; S Q(1)=15

<syntaxhighlight lang="focal">01.10 S P(1)=21; S Q(1)=15

01.20 S P(2)=17; S Q(2)=23

01.30 S P(3)=36; S Q(3)=12

Line 633:

03.40 I (A-1)3.6,3.5,3.6

03.50 T %4,P(N),Q(N),!

03.60 R</~~lang~~>

03.60 R</syntaxhighlight>

<pre>= 17= 23

Line 639:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>function gcdp( a as uinteger, b as uinteger ) as uinteger

<syntaxhighlight lang="freebasic">function gcdp( a as uinteger, b as uinteger ) as uinteger

'returns the gcd of two positive integers

if b = 0 then return a

Line 659:

print is_coprime(18,29)

print is_coprime(60,15)

</syntaxhighlight>

</lang>

{{out}}<pre>

false

Line 669:

=={{header|Frink}}==

<~~lang~~ frink>pairs = [ [21,15],[17,23],[36,12],[18,29],[60,15] ]

<syntaxhighlight lang="frink">pairs = [ [21,15],[17,23],[36,12],[18,29],[60,15] ]

for [a,b] = pairs

println["[$a, $b] are " + (gcd[a,b] == 1 ? "" : "not ") + "coprime"]</~~lang~~>

println["[$a, $b] are " + (gcd[a,b] == 1 ? "" : "not ") + "coprime"]</syntaxhighlight>

<pre>

Line 684:

Uses the same observation as the Wren entry.

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 699:

}

}</~~lang~~>

}</syntaxhighlight>

Line 709:

=={{header|Haskell}}==

<~~lang~~ haskell>------------------------- COPRIMES -----------------------

<syntaxhighlight lang="haskell">------------------------- COPRIMES -----------------------

coprime :: Integral a => a -> a -> Bool

Line 726:

(18, 29),

(60, 15)

]</~~lang~~>

]</syntaxhighlight>

Line 732:

=={{header|J}}==

<~~lang~~ J>([#~1=+./"1) >21 15;17 23;36 12;18 29;60 15</~~lang~~>

<pre>17 23

Line 740:

'''Works with gojq, the Go implementation of jq'''

# Note that jq optimizes the recursive call of _gcd in the following:

def gcd(a;b):

Line 749:

# Input: an array

def coprime: gcd(.[0]; .[1]) == 1;

</syntaxhighlight>

</lang>

'''The task'''

<~~lang~~ jq>"The following pairs of numbers are coprime:",

<syntaxhighlight lang="jq">"The following pairs of numbers are coprime:",

([[21,15],[17,23],[36,12],[18,29],[60,15]][]

| select(coprime))

</syntaxhighlight>

</lang>

<pre>

Line 763:

=={{header|Julia}}==

<~~lang~~ julia>filter(p -> gcd(p...) == 1, [[21,15],[17,23],[36,12],[18,29],[60,15],[21,22,25,31,143]])

<syntaxhighlight lang="julia">filter(p -> gcd(p...) == 1, [[21,15],[17,23],[36,12],[18,29],[60,15],[21,22,25,31,143]])

</~~lang~~>{{out}}<pre>

</syntaxhighlight>{{out}}<pre>

3-element Vector{Vector{Int64}}:

[17, 23]

Line 772:

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

INTERNAL FUNCTION COPRM.(X,Y) = GCD.(X,Y).E.1

Line 797:

VECTOR VALUES FMT = $I4,I4*$

END OF PROGRAM </~~lang~~>

END OF PROGRAM </syntaxhighlight>

<pre>COPRIMES

Line 804:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>CoprimeQ @@@ {{21, 15}, {17, 23}, {36, 12}, {18, 29}, {60, 15}}</~~lang~~>

<syntaxhighlight lang="mathematica">CoprimeQ @@@ {{21, 15}, {17, 23}, {36, 12}, {18, 29}, {60, 15}}</syntaxhighlight>

<pre>{False, True, False, True, False}</pre>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import math

<syntaxhighlight lang="nim">import math

for (a, b) in [(21, 15), (17, 23), (36, 12), (18, 29), (60, 15)]:

echo a, " and ", b, " are ", if gcd(a, b) == 1: "coprimes." else: "not coprimes."</~~lang~~>

echo a, " and ", b, " are ", if gcd(a, b) == 1: "coprimes." else: "not coprimes."</syntaxhighlight>

Line 823:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use ntheory 'gcd';

Line 829:

printf "%7s %s\n", (gcd(@$_) == 1 ? 'Coprime' : ''), join ', ', @$_

for [21,15], [17,23], [36,12], [18,29], [60,15], [21,22,25,31,143];

</syntaxhighlight>

</lang>

<pre> 21, 15

Line 839:

=={{header|Phix}}==

function gcd1(sequence s) return gcd(s)=1 end function

?filter({{21,15},{17,23},{36,12},{18,29},{60,15}},gcd1)

<pre>

Line 848:

</pre>

A longer set/element such as {21,22,25,30,143} would also be shown as coprime, since it is, albeit not pairwise coprime - for the latter you would need something like:

function pairwise_coprime(sequence s)

for i=1 to length(s)-1 do

Line 858:

end function

?filter({{21,15},{17,23},{36,12},{18,29},{60,15},{21, 22, 25, 31, 143}},pairwise_coprime)

Output is the same as the above, because this excludes the {21, 22, 25, 31, 143}, since both 22 and 143 are divisible by 11.

=={{header|PL/M}}==

<~~lang~~ plm>100H:

<syntaxhighlight lang="plm">100H:

BDOS: PROCEDURE (FN, ARG);

DECLARE FN BYTE, ARG ADDRESS;

Line 911:

END;

CALL BDOS(0,0);

EOF</~~lang~~>

EOF</syntaxhighlight>

<pre>17 23

Line 917:

=={{header|Python}}==

<~~lang~~ python>'''Coprimes'''

<syntaxhighlight lang="python">'''Coprimes'''

from math import gcd

Line 945:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

Line 954:

<code>gcd</code> is defined at [[Greatest common divisor#Quackery]].

<~~lang~~ ~~Quackery~~> [ gcd 1 = ] is coprime ( n n --> b )

<syntaxhighlight lang="quackery"> [ gcd 1 = ] is coprime ( n n --> b )

' [ [ 21 15 ]

Line 968:

coprime not if

[ say " not" ]

say " coprime." cr ]</~~lang~~>

say " coprime." cr ]</syntaxhighlight>

Line 980:

=={{header|R}}==

<~~lang~~ rsplus>factors <- function(n) c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)

<syntaxhighlight lang="rsplus">factors <- function(n) c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)

isCoprime <- function(p, q) all(intersect(factors(p), factors(q)) == 1)

output <- data.frame(p = c(21, 17, 36, 18, 60), q = c(15, 23, 12, 29, 15))

print(transform(output, "Coprime" = ifelse(mapply(isCoprime, p, q), "Yes", "No")))</~~lang~~>

print(transform(output, "Coprime" = ifelse(mapply(isCoprime, p, q), "Yes", "No")))</syntaxhighlight>

<pre> p q Coprime

Line 996:

There is a coprime? function in the math/number-theory library to show off (more useful if you're using typed racket).

<~~lang~~ racket>#lang racket/base

<syntaxhighlight lang="racket">#lang racket/base

;; Rename only necessary so we can distinguish it

Line 1,015:

(list number-theory/coprime?

gcd/coprime?

(λ ns (= 1 (apply gcd ns))))))</~~lang~~>

(λ ns (= 1 (apply gcd ns))))))</syntaxhighlight>

Line 1,044:

How do you determine if numbers are co-prime? Check to see if the [[Greatest common divisor]] is equal to one. Since we're duplicating tasks willy-nilly, lift code from [[Greatest_common_divisor#Raku|that task]], (or in this case, just use the builtin).

<lang ~~perl6~~>say .raku, ( [gcd] |$_ ) == 1 ?? ' Coprime' !! '' for [21,15],[17,23],[36,12],[18,29],[60,15],[21,22,25,31,143]</~~lang~~>

<syntaxhighlight lang="raku" line>say .raku, ( [gcd] |$_ ) == 1 ?? ' Coprime' !! '' for [21,15],[17,23],[36,12],[18,29],[60,15],[21,22,25,31,143]</syntaxhighlight>

<pre>[21, 15]

[17, 23] Coprime

Line 1,053:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX prgm tests number sequences (min. of two #'s, separated by a commas) if comprime.*/

<syntaxhighlight lang="rexx">/*REXX prgm tests number sequences (min. of two #'s, separated by a commas) if comprime.*/

parse arg @ /*obtain optional arguments from the CL*/

if @='' | @=="," then @= '21,15 17,23 36,12 18,29 60,15 21,22,25,143 -2,0 0,-3'

Line 1,074:

end /*until*/

end /*j*/

return x</~~lang~~>

return x</syntaxhighlight>

<pre>

Line 1,095:

=={{header|Ring}}==

<~~lang~~ ring>

see "working..." + nl

row = 0

Line 1,125:

see "Found " + row + " coprimes" + nl

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 1,138:

=={{header|Ruby}}==

<~~lang~~ ruby>pairs = [[21,15],[17,23],[36,12],[18,29],[60,15]]

<syntaxhighlight lang="ruby">pairs = [[21,15],[17,23],[36,12],[18,29],[60,15]]

pairs.select{|p, q| p.gcd(q) == 1}.each{|pair| p pair}

</syntaxhighlight>

</lang>

<pre>[17, 23]

Line 1,147:

=={{header|Sidef}}==

<~~lang~~ ruby>var pairs = [[21,15],[17,23],[36,12],[18,29],[60,15]]

<syntaxhighlight lang="ruby">var pairs = [[21,15],[17,23],[36,12],[18,29],[60,15]]

say "The following pairs of numbers are coprime:"

pairs.grep { .gcd == 1 }.each { .say }</~~lang~~>

pairs.grep { .gcd == 1 }.each { .say }</syntaxhighlight>

<pre>

Line 1,160:

Two numbers are coprime if their GCD is 1.

<~~lang~~ ecmascript>import "/math" for Int

<syntaxhighlight lang="ecmascript">import "/math" for Int

var pairs = [[21,15],[17,23],[36,12],[18,29],[60,15]]

System.print("The following pairs of numbers are coprime:")

for (pair in pairs) if (Int.gcd(pair[0], pair[1]) == 1) System.print(pair)</~~lang~~>

for (pair in pairs) if (Int.gcd(pair[0], pair[1]) == 1) System.print(pair)</syntaxhighlight>

Line 1,174:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func GCD(A, B); \Return greatest common divisor of A and B

<syntaxhighlight lang="xpl0">func GCD(A, B); \Return greatest common divisor of A and B

int A, B;

[while A#B do

Line 1,189:

[IntOut(0, A); ChOut(0, ^,); IntOut(0, B); CrLf(0)];

];

]</~~lang~~>

]</syntaxhighlight>