Mengingat kata, memperlakukan setiap surat nomor itu dalam alfabet bahasa Inggris (jadi amenjadi 1, bmenjadi 2, zmenjadi 26 dan seterusnya), dan periksa apakah semua dari mereka, termasuk duplikat, yang berpasangan coprime .

Inputnya persis satu kata huruf Inggris kecil. Keluarannya adalah fakta jika kata itu coprime: nilai kebenaran / falsey apa pun, tetapi hanya dua varian di antaranya. Celah standar dilarang.

Kasus uji:

• man: True
• day: True(terima kasih kepada Ørjan Johansen)
• led: False( l=12dan d=4sudah gcd=4)
• mana: True(meskipun aterjadi beberapa kali, 1 dan 1 adalah koprimes)
• mom: False( gcd(13,13)=13))
• of: False(terima kasih kepada xnor; meskipun 15∤6, gcd(15,6)=3)
• a: True(jika tidak ada pasangan huruf, perlakukan kata itu sebagai koprime juga)

Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Bahasa Wolfram (Mathematica) , 36 byte

CoprimeQ@@LetterNumber@Characters@#&

Cobalah online!

Bahasa Wolfram (Mathematica) , 33 byte

• Terima kasih kepada Misha Lavrov untuk versi yang lebih pendek tiga byte ini.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Cobalah online!

Jelly , 10 byte

ØaiⱮgþ`P$Ƒ

Cobalah online!

Bagaimana itu bekerja

ØaiⱮgþ`P$Ƒ  Main link. Argument: s (string)

Øa          Yield "abc...xyz".
  iⱮ        Find the 1-based index of each c of s in "abc...xyz".
        $Ƒ  Call the monadic chain to the left.
            Yield 1 if the result is equal to the argument, 0 if not.
    gþ`       Take the GCDs of all pairs of indices, yielding a matrix.
       P      Take the columnwise product.
            For coprimes, the column corresponding to each index will contain the
            index itself (GCD with itself) and several 1's (GCD with other indices),
            so the product is equal to the index.

Haskell , 48 byte

((==).product<*>foldr1 lcm).map((-96+).fromEnum)

Cobalah online!

Sangat mudah: mengubah string ke daftar angka dan kemudian memeriksa apakah produk tersebut sama dengan LCM.

Pyth , 9 byte

{Ism{PhxG

Suite uji

{Ism{PhxG   | Full code
{Ism{PhxGdQ | With implicit variables filled
------------+------------------------------------------
   m      Q | For each char d in the input:
    {P      |  list the unique prime factors of
      hx d  |  the 1-based index of d in
        G   |  the lowercase alphabet
  s         | Group all prime factors into one list
{I          | Output whether the list has no duplicates

_{apakah Pyth baru saja mengalahkan Jelly?}

Python 2 - 122 118 byte

-4 byte terima kasih kepada @JonathanAllan

Ini benar-benar mengerikan, tetapi saya telah menghabiskan waktu terlalu lama untuk tidak memposting ini.

from fractions import*
def f(n):r=reduce;n=[ord(i)-96for i in n];return r(lambda x,y:x*y/gcd(x,y),n)==r(int.__mul__,n)

Cobalah secara Online

05AB1E , 11 byte

Ç96-2.Æ€¿PΘ

Cobalah online!

Penjelasan

Ç96-         # convert to character codes and subtract 96
    2.Æ      # get all combinations of size 2
       €¿    # gcd of each pair
         P   # product of gcds
          Θ  # is true

Brachylog , 11 byte

ạ{-₉₆ḋd}ᵐc≠

Cobalah online!

Penjelasan

ạ{-₉₆ḋd}ᵐc≠
ạ              Split the input into its character codes
 {     }ᵐ      For each one
  -₉₆          Subtract 96 (a -> 1, b -> 2 etc.)
     ḋd        And find the unique (d) prime factors (ḋ)
         c     Combine them into one list
          ≠    And assert they are all different

Python 2 , 77 68 64 byte

lambda a:all(sum(ord(v)%96%i<1for v in a)<2for i in range(2,26))

Cobalah online!

Pada dasarnya, (beberapa pasangan dalam input tidak co-prime) jika dan hanya jika (ada angka i> 1 yang membagi lebih dari satu input).

Python 3 , 61 59 byte

Menggunakan byte python sebagai argumen:

lambda s:all(sum(c%96%x<1for c in s)<2for x in range(2,24))

Pembagi terakhir untuk memeriksa adalah 23, prime terbesar di bawah 26.

Cobalah online!

Terima kasih kepada @Dennis karena telah menghemat dua byte.

Perl 6 , 34 32 byte

-2 byte terima kasih kepada nwellnhof

{[lcm](@_)==[*] @_}o{.ords X-96}

Cobalah online!

Kode kunci anonim yang mengambil string dan mengembalikan Benar atau Salah. Jika kelipatan umum terendah dari surat-surat tersebut sama dengan produk dari surat-surat itu daripada mereka tidak berbagi pembagi umum.

Penjelasan:

                     {.ords X-96}  # Convert the letters to a list of numbers
 {                 }o              # Pass result to the next codeblock
  [lcm](@_)           # The list reduced by the lcm
           ==         # Is equal to?
             [*] @_   # The list reduced by multiplication

J, 36 byte

[:(1 =[:*/-.@=@i.@##&,+./~)_96+a.&i.

Tidak disatukan

[: (1 = [: */ -.@=@i.@# #&, +./~) _96 + a.&i.

Penjelasan

[: (                            ) _96 + a.&i.  NB. apply fn in parens to result of right
                                  _96 + a.&i.  NB. index within J's ascii alphabet, minus 96.
                                               NB. gives index within english alphabet
   (1 =                         )              NB. does 1 equal...
   (    [: */                   )              NB. the product of...
   (                    #&,     )              NB. Flatten the left and right args, and then copy
   (                        +./~)              NB. right arg = a table of cross product GCDs
   (          -.@=@i.@#         )              NB. the complement of the identity matrix.
                                               NB. this removes the diagonal.

Cobalah online!

JavaScript (Node.js) , 60 byte

f=(s,v=23)=>n=v<2||f(s,v-1)&&Buffer(s).every(c=>c%32%v||n--)

Cobalah online!

• Menggunakan ide Bufferdari Shieru Asakoto 's posting .
• Berkat Arnauld , tersimpan 5 byte.

Jelly , 11 byte

ŒcO_96g/€ỊẠ

Cobalah online!

• Terima kasih pada Dennis karena telah mencatat boolean saya

ŒcO_96g/€ỊẠ
Œc           All pairs of characters without replacement
  O          Code point of each character
   _96       Subtract 96. a->1, b->2, etc.
        €    For each pair:
      g/       Get the greatest common denominator
         Ị   abs(z)<=1? If they are all 1 then this will give a list of 1s
          Ạ  "All". Gives 1 if they are coprime, 0 if not.

MATL , 10 byte

96-YF&fdA&

Keluaran 1untuk koprime, 0jika tidak.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Pertimbangkan input 'man'misalnya.

96-  % Implicit input: string. Subtract 96 from (the codepoint of) each element
     % STACK: [13 1 14] 
YF   % Exponents of prime factoriation. Each number produces a row in the result
     % STACK: [0 0 0 0 0 1;
               0 0 0 0 0 0;
               1 0 0 1 0 0]
&f   % Two-output find: pushes row and column indices of nonzeros
     % STACK: [3; 3; 1], [1; 4; 6]
d    % Consecutive differences
     % STACK: [3; 3; 1], [3; 2]
A    % All: gives true if the array doesn't contain zeros
     % STACK: [3; 3; 1], 1
&    % Alternative in/out specification: the next function, which is implicit
     % display, will only take 1 input. So only the top of the stack is shown

Algoritma Markov, sebagaimana ditafsirkan oleh eMain ( 474 484 463 bytes, 76 78 76 aturan)

a->
d->b
f->bc
h->b
i->c
j->be
l->bc
n->bg
o->ce
p->b
q->q
r->bc
t->be
u->cg
v->bk
x->bc
y->e
z->bm
cb->bc
eb->be
gb->bg
kb->bk
mb->bm
qb->bq
sb->bs
wb->bw
ec->ce
gc->cg
kc->ck
mc->cm
qc->cq
sc->cs
wc->cw
ge->eg
ke->ek
me->em
qe->eq
se->es
we->ew
kg->gk
mg->gm
qg->gq
sg->gs
wg->gw
mk->km
qk->kq
sk->ks
wk->kw
qm->mq
sm->ms
wm->mw
sq->qs
wq->qw
ws->sw
bb->F
cc->F
ee->F
gg->F
kk->F
mm->F
qq->F
ss->F
ww->F
b->
c->
e->
g->
k->
m->
q->
s->
w->
FF->F
TF->F
!->.
->!T

17 aturan pertama memasukkan faktor "huruf gabungan" menjadi faktor "huruf utama" mereka, mengabaikan keberagaman. (Misalnya, tmenjadi bekarena 20 faktor sebagai produk dari kekuatan 2 dan kekuatan 5.)

36 aturan berikutnya (seperti cb->bc ) mengurutkan faktor utama yang dihasilkan.

9 aturan berikutnya (seperti bb->F) menggantikan faktor prima yang diulangi F, kemudian 9 aturan lainnya (seperti b->) menyingkirkan huruf tunggal yang tersisa.

Pada titik ini, kami memiliki string kosong, atau string satu atau lebih F, dan aturan terakhir ->!Tmenambahkan a !Tdi awal. Kemudian aturan FF->Fdan TF->Fsederhanakan hasilnya ke salah satu !Tatau !F. Pada titik ini, !->.aturan berlaku, memberitahu kita untuk menyingkirkan !dan berhenti: kembali Tuntuk kata coprime, dan Fsebaliknya.

(Terima kasih kepada bodqhrohro untuk menunjukkan bug di versi sebelumnya yang menyebabkan kode ini memberikan string kosong pada input a.)

Python 3 , 90 89 byte

-1 byte oleh numbermaniac

f=lambda q,*s:s==()or all(math.gcd(ord(q)-96,ord(w)-96)<2for w in s)and f(*s)
import math

Cobalah online!

Gunakan sebagai f(*'man').

Retina 0.8.2 , 45 byte

;
{`\w
#$&
}T`l`_l
M`;(##+)\1*;(#*;)*\1+;
^0

Cobalah online! Penjelasan:

;

Masukkan pemisah antara setiap huruf dan pada awal dan akhir.

{`\w
#$&

Berlaku a # ke setiap huruf.

}T`l`_l

Pindahkan setiap huruf 1 ke belakang dalam alfabet, hapus huruf a s. Kemudian ulangi operasi di atas sampai semua huruf telah dihapus. Ini mengubah setiap huruf menjadi indeks alfabet berbasis 1 di unary.

M`;(##+)\1*;(#*;)*\1+;

Uji apakah ada dua nilai yang memiliki faktor umum lebih besar dari 1. (Ini dapat menemukan lebih dari satu pasang huruf dengan faktor umum, misalnya dalam kata yearling .)

^0

Pastikan tidak ada faktor umum yang ditemukan.

Pustaka R + pracma, 75 byte

function(w){s=utf8ToInt(w)-96;all(apply(outer(s,s,pracma::gcd),1,prod)==s)}

Saya menggunakan gcdfungsi dipracma perpustakaan untuk pengetahuan saya R tidak memiliki built-in untuk itu. Saya menggunakan pendekatan membandingkan produk gcds dengan angka itu sendiri.

65 byte (kredit: @ Joe)

function(w)prod(outer(s<-utf8ToInt(w)-96,s,pracma::gcd))==prod(s)

Japt , 14 byte

;à2 e_®nR+CÃrj

Cobalah online!

Mengambil input sebagai array karakter.

Bagaimana itu bekerja

;à2 e_m_nR+C} rj
;                 Use alternative predefined variables (in this case, C = "a-z")
 à2               Get all pairs
    e_            Does all pairs satisfy that...
      m_            when the character pair is mapped over...
        nR+C}         conversion from "a-z" to [1..26]
              rj    then the two numbers are coprime?

Ruby , 56 byte

->s{s.bytes.combination(2).all?{|a,b|2>(a-96).gcd(a-b)}}

Cobalah online!

Java 10, 86 byte

a->{var r=1>0;for(int i=1,s=0;++i<24;r&=s<2,s=0)for(var c:a)s+=c%96%i<1?1:0;return r;}

Port of @Vincent 's Python 3 menjawab .

Cobalah online.

Penjelasan:

a->{                 // Method with character-array parameter and boolean return-type
  var r=1>0;         //  Result-boolean, starting at true
  for(int s=0,       //  Sum integer, starting at 0
      i=1;++i<24     //  Loop `i` in the range (1, 24)
      ;              //    After every iteration:
       r&=s<2,       //     If the sum is >= 2: change the result to false
       s=0)          //     And reset the sum to 0
     for(var c:a)    //   Inner loop over the input-characters
       s+=c%96%i<1?  //    If the current character modulo-96 is divisible by `i`
           1         //     Increase the sum by 1
          :          //    Else
           0;        //     Leave the sum the same
  return r;}         //  Return the result-boolean

Japt, 13 byte

Mengambil input sebagai array karakter.

®c uHÃà2 e_rj

Cobalah atau verifikasi semua kasus uji

q, 121 111 byte

{$[1=count x;1b;1b=distinct{r:{l:{$[0~y;:x;.z.s[y;x mod y]]}[y;]'[x];2>count l where l<>1}[x;]'[x]}[1+.Q.a?x]]}

JavaScript (Node.js) , 87 82 byte

a=>!/\b(11+)\1* (1+ )*\1+\b/.exec(Buffer(a).map(x=>w+=" ".padEnd(x-95,1),w="")&&w)

Cobalah online!

Pendekatan asli (87B)

a=>!(b=Buffer(a)).some((x,i)=>b.some((y,j)=>i-j&&(g=(p,q)=>q?g(q,p%q):p)(x-96,y-96)>1))

Cobalah online!

Stax , 16 byte

è'B╕i4à!ùà╫æor4Z

Jalankan dan debug itu

Penjelasan

2S{M{$e96-mm{E:!m|A     #Full program, unpacked, implicit input
2S                      #Generate all combinations of size 2
  {       m             #Map for each element
   M                    #Split into size of 1 element
    {       m           #Map for each element
     $e                 #Convert to number
       96-              #Subtract 96
           {    m       #Map for each element
            E:!         #Explode array onto stack, are they coprime
                 |A     #Are all elements of array truthy

Output 1 untuk Benar, 0 Untuk salah.

Mungkin ada cara yang lebih baik untuk melakukan konversi ke nomor bagian, tetapi berhasil.

APL (NARS), 16 karakter, 32 byte

{(×/p)=∧/p←⎕a⍳⍵}

Ini menggunakan metode lain yang digunakan bahwa LCM () = × /, itu cepat tetapi meluap jika input array cukup panjang; solusi alternatif lain sedikit lebih lambat:

{1=×/y∨y÷⍨×/y←⎕a⍳⍵} 
{1=≢,⍵:1⋄1=×/{(2⌷⍵)∨1⌷⍵}¨{x←97-⍨⎕AV⍳⍵⋄(,x∘.,x)∼⍦x,¨x}⍵}

ini di bawah ini tampaknya 10 kali lebih cepat (atau +) daripada fungsi di atas

∇r←h m;i;j;k;v
   r←i←1⋄k←≢v←97-⍨⎕AV⍳m
A: →F×⍳i>k⋄j←i+1⋄→C
B:   →E×⍳1≠(j⌷v)∨i⌷v⋄j←j+1
C:   →B×⍳j≤k
D: i←i+1⋄→A
E: r←0
F:
∇

saya lebih suka yang terakhir ini karena lebih mudah, lebih cepat, dapat dipercaya (karena possiblity kurang melimpah), lebih mudah untuk menulis, dan bagaimana itu harus (bahkan jika memiliki beberapa byte lebih ...)