Cho một từ, coi mỗi chữ cái là số trong bảng chữ cái tiếng Anh (vì vậy atrở thành 1, btrở thành 2,z trở thành 26 và vân vân), và kiểm tra xem tất cả trong số họ, trong đó có bản sao, là cặp nguyên tố cùng nhau .

Đầu vào chính xác là một từ của chữ cái tiếng Anh viết thường. Đầu ra là thực tế nếu từ này là nguyên tố: bất kỳ giá trị trung thực / falsey nào, nhưng chỉ có hai biến thể của chúng. Sơ hở tiêu chuẩn bị cấm.

Các trường hợp thử nghiệm:

• man: True
• day: True (cảm ơn Ørjan Johansen)
• led: False( l=12và d=4cógcd=4 )
• mana: True(mặc dùa xảy ra nhiều lần, 1 và 1 là các phần tử)
• mom: False( gcd(13,13)=13))
• of: False(cảm ơn xnor; mặc dù 15∤6, gcd(15,6)=3)
• a: True (nếu không có cặp chữ nào, hãy coi từ này là đồng thời)

Đây là một môn đánh gôn , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Ngôn ngữ Wolfram (Mathicala) , 36 byte

CoprimeQ@@LetterNumber@Characters@#&

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 33 byte

• Cảm ơn Misha Lavrov cho phiên bản ngắn hơn ba byte này.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Hãy thử trực tuyến!

Thạch , 10 byte

ØaiⱮgþ`P$Ƒ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ø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)

Hãy thử trực tuyến!

Rất đơn giản: chuyển đổi chuỗi thành danh sách các số và sau đó kiểm tra xem sản phẩm có bằng LCM hay không.

Bình thường , 9 byte

{Ism{PhxG

Bộ kiểm tra

{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

_{Pyth vừa outgolf Jelly?}

Python 2 - 122 118 byte

-4 byte nhờ @Jonathan ALLan

Điều này thực sự khủng khiếp, nhưng tôi đã dành quá nhiều thời gian để không đăng bài này.

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)

Dùng thử trực tuyến

05AB1E , 11 byte

Ç96-2.Æ€¿PΘ

Hãy thử trực tuyến!

Giải trình

Ç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≠

Hãy thử trực tuyến!

Giải trình

ạ{-₉₆ḋ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))

Hãy thử trực tuyến!

Về cơ bản, (một số cặp trong đầu vào không phải là số nguyên tố) khi và chỉ khi (có một số i> 1 chia cho nhiều hơn một trong các đầu vào).

Python 3 , 61 59 byte

Sử dụng byte python làm đối số:

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

Số chia cuối cùng để kiểm tra là 23, số nguyên tố lớn nhất dưới 26.

Hãy thử trực tuyến!

Cảm ơn @Dennis vì đã lưu hai byte.

Perl 6 , 34 32 byte

-2 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Một codeblock ẩn danh nhận một chuỗi và trả về Đúng hoặc Sai. Nếu bội số chung thấp nhất của các chữ cái bằng với tích của các chữ cái thì chúng không chia sẻ chung.

Giải trình:

                     {.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.

Ung dung

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

Giải trình

[: (                            ) _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.

Hãy thử trực tuyến!

JavaScript (Node.js) , 60 byte

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

Hãy thử trực tuyến!

• Sử dụng ý tưởng Buffertừ bài viết của Shieru Asakoto .
• Nhờ Arnauld , đã lưu 5 byte.

Thạch , 11 byte

ŒcO_96g/€ỊẠ

Hãy thử trực tuyến!

• Cảm ơn Dennis vì đã không chú ý đến booleans của tôi

Œ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&

Đầu ra 1cho coprime,0 nếu không.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào 'man'chẳng hạn.

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

Markov thuật toán, như giải thích bởi eMain ( 474 484 463 byte, 76 78 76 quy tắc)

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 quy tắc đầu tiên đưa "các chữ cái tổng hợp" vào các yếu tố "chữ cái chính" của chúng, bỏ qua tính đa bội. (Ví dụ,t trở thành bebởi vì 20 yếu tố là sản phẩm có sức mạnh bằng 2 và sức mạnh là 5.)

36 quy tắc tiếp theo (như cb->bc ) sắp xếp các thừa số nguyên tố.

9 quy tắc tiếp theo (như bb->F) thay thế một thừa số nguyên tố lặp lại bằngF , sau đó thêm 9 quy tắc (chẳng hạn nhưb-> ) loại bỏ các chữ cái đơn còn lại.

Tại thời điểm này, chúng ta có một chuỗi rỗng hoặc một chuỗi gồm một hoặc nhiều Fs và quy tắc cuối cùng ->!Tthêm một !Tở đầu. Sau đó, các quy tắc FF->Fvà TF->Fđơn giản hóa kết quả để !Thoặc !F. Tại thời điểm này, !->.quy tắc được áp dụng, bảo chúng tôi thoát khỏi !và dừng lại: trở vềT cho một từ đồng nghĩa, và Fnếu không.

(Cảm ơn bodqhrohro đã chỉ ra một lỗi trong phiên bản trước đó khiến mã này đưa ra một chuỗi trống trên đầu vào a.)

Python 3 , 90 89 byte

-1 byte theo số lượng

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

Hãy thử trực tuyến!

Sử dụng như f(*'man').

Võng mạc 0.8.2 , 45 byte

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

Hãy thử trực tuyến!Giải trình:

;

Chèn dấu phân cách giữa mỗi chữ cái và ở đầu và cuối.

{`\w
#$&

Chuẩn bị một #cho mỗi chữ cái.

}T`l`_l

Di chuyển mỗi chữ cái 1 trở lại trong bảng chữ cái, xóa as. Sau đó lặp lại các thao tác trên cho đến khi tất cả các chữ cái đã bị xóa. Điều này chuyển đổi mỗi chữ cái thành chỉ mục bảng chữ cái dựa trên 1 của nó trong unary.

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

Kiểm tra xem hai giá trị có chia sẻ một yếu tố chung lớn hơn 1. (Điều này có thể tìm thấy nhiều hơn một cặp chữ cái có một yếu tố chung, ví dụ như trong từ yearling.)

^0

Kiểm tra rằng không có yếu tố chung được tìm thấy.

Thư viện R + pracma, 75 byte

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

Tôi đang sử dụng gcd chức năng trongpracma thư viện vì kiến ​​thức của tôi R không được tích hợp sẵn cho việc đó. Tôi đang sử dụng phương pháp so sánh sản phẩm của các gcd với các con số.

65 byte (tín dụng: @ J.Doe)

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

Japt , 14 byte

;à2 e_®nR+CÃrj

Hãy thử trực tuyến!

Đưa đầu vào như một mảng các ký tự.

Làm thế nào nó hoạt động

;à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)}}

Hãy thử trực tuyến!

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;}

Cổng câu trả lời Python 3 của @Vincent .

Hãy thử trực tuyến.

Giải trình:

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

Đưa đầu vào như một mảng ký tự.

®c uHÃà2 e_rj

Hãy thử hoặc xác minh tất cả các trường hợp thử nghiệm

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)

Hãy thử trực tuyến!

Cách tiếp cận ban đầu (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))

Hãy thử trực tuyến!

Stax , 16 byte

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

Chạy và gỡ lỗi nó

Giải trình

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

Đầu ra 1 cho True, 0 cho false.

Có lẽ có một cách tốt hơn để thực hiện chuyển đổi thành phần số, nhưng nó hoạt động.

APL (NARS), 16 ký tự, 32 byte

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

Phương thức sử dụng này được sử dụng khác mà LCM () = × /, nó nhanh nhưng tràn nếu mảng đầu vào đủ dài; giải pháp thay thế khác chậm hơn một chút:

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

cái này bên dưới dường như nhanh hơn 10 lần (hoặc +) so với chỉ các chức năng trên

∇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:
∇

Tôi thích cái cuối cùng này vì nó dễ hơn, nhanh hơn, đáng tin cậy (vì khả năng chiếm hữu ít tràn hơn), dễ viết hơn và nó phải như thế nào (ngay cả khi nó có nhiều byte hơn ...)