ป.ร. ให้คำรักษาทุกตัวอักษรที่เป็นตัวเลขที่อยู่ในตัวอักษรภาษาอังกฤษ (เพื่อให้aเป็น 1 bกลายเป็น 2 zกลายเป็น 26 และอื่น ๆ ) และตรวจสอบว่าทั้งหมดของพวกเขารวมถึงรายการที่ซ้ำกันเป็นคู่coprime

การป้อนข้อมูลเป็นเพียงหนึ่งคำของตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก เอาท์พุทคือความจริงถ้าคำว่า coprime: ค่าความจริง / เท็จใด ๆ แต่เพียงสองรูปแบบของพวกเขา ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

กรณีทดสอบ:

• man: True
• day: True(ขอบคุณØrjan Johansen)
• led: False( l=12และd=4มีgcd=4)
• mana: True(แม้ว่าจะaเกิดขึ้นหลายครั้ง 1 และ 1 เป็น coprimes)
• mom: False( gcd(13,13)=13))
• of: False(ขอบคุณ xnor; แม้ว่า15∤6, gcd(15,6)=3)
• a: True(หากไม่มีตัวอักษรคู่ให้ถือว่าคำว่า coprime ด้วย)

นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

ภาษา Wolfram (Mathematica)ขนาด 36 ไบต์

CoprimeQ@@LetterNumber@Characters@#&

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 33 ไบต์

• ขอบคุณMisha Lavrovสำหรับรุ่นที่สั้นกว่าสามไบต์

CoprimeQ @@ (@ # ToCharacterCode - 96) และ

ลองออนไลน์!

เยลลี่ 10 ไบต์

ØaiⱮgþ`P$Ƒ

ลองออนไลน์!

มันทำงานอย่างไร

Ø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 ไบต์

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

ลองออนไลน์!

ตรงไปตรงมามาก: แปลงสตริงเป็นรายการตัวเลขแล้วตรวจสอบว่าผลิตภัณฑ์มีค่าเท่ากับ LCM หรือไม่

Pyth , 9 ไบต์

{Ism{PhxG

ชุดทดสอบ

{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 เพิ่งเอาชนะเจลลี่ได้หรือไม่}

Python 2 - 122 118 ไบต์

-4 ไบต์ขอบคุณ @JonathanAllan

นี่แย่จริงๆ แต่ฉันใช้เวลานานเกินไปกว่าจะไม่โพสต์สิ่งนี้

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)

ลองออนไลน์

05AB1E , 11 ไบต์

Ç96-2.Æ€¿PΘ

ลองออนไลน์!

คำอธิบาย

Ç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 ไบต์

ạ{-₉₆ḋd}ᵐc≠

ลองออนไลน์!

คำอธิบาย

ạ{-₉₆ḋ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 ไบต์

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

ลองออนไลน์!

โดยพื้นฐานแล้ว (บางคู่ในอินพุตไม่ได้เป็นแบบร่วมเฉพาะ) ถ้าหาก (มีตัวเลข i> 1 ซึ่งแบ่งมากกว่าหนึ่งอินพุต)

Python 3 , 61 59 ไบต์

ใช้ python bytes เป็นอาร์กิวเมนต์:

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

ตัวหารล่าสุดที่ตรวจสอบคือ 23 ซึ่งเป็นนายกที่ใหญ่ที่สุดต่ำกว่า 26

ลองออนไลน์!

ขอบคุณ @Dennis สำหรับการบันทึกสองไบต์

Perl 6 , 34 32 ไบต์

-2 ไบต์ต้องขอบคุณ nwellnhof

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

ลองออนไลน์!

codeblock ที่ไม่ระบุชื่อที่รับสตริงและส่งคืนค่าจริงหรือเท็จ หากตัวคูณสามัญที่ต่ำที่สุดของตัวอักษรเท่ากับผลคูณของตัวอักษรมากกว่าที่พวกเขาแบ่งปันไม่มีตัวหารร่วม

คำอธิบาย:

                     {.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 ไบต์

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

Ungolfed

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

คำอธิบาย

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

ลองออนไลน์!

JavaScript (Node.js) , 60 ไบต์

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

ลองออนไลน์!

• การใช้ความคิดของBufferจากShieru Asakoto 's โพสต์
• ขอบคุณArnauldบันทึก 5 ไบต์

เยลลี่ 11 ไบต์

ŒcO_96g/€ỊẠ

ลองออนไลน์!

• ขอบคุณเดนนิสสำหรับการสังเกตบูลีนของฉัน

Œ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 ไบต์

96-YF&fdA&

เอาต์พุต1สำหรับ coprime 0มิฉะนั้น

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

พิจารณาการป้อนข้อมูล'man'เช่น

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

อัลกอริทึมมาร์คอฟที่ตีความโดยeMain ( 474 484 463 ไบต์, 76 78 76 กฎ)

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 ข้อแรกใช้ปัจจัย "ตัวอักษรผสม" เป็นปัจจัย "ตัวอักษรตัวพิมพ์ใหญ่" โดยไม่สนใจหลายหลาก (เช่นtกลายเป็นbeเพราะ 20 ปัจจัยที่เป็นผลคูณของกำลังของ 2 และกำลังของ 5)

36 กฎถัดไป (เช่น cb->bc ) เรียงลำดับปัจจัยหลักที่เป็นผลลัพธ์

กฎ 9 ข้อถัดไป (เช่นbb->F) แทนที่ตัวประกอบนายกซ้ำด้วยFและอีก 9 กฎ (เช่นb->) กำจัดตัวอักษรเดี่ยวที่เหลือ

ณ จุดนี้เราอาจมีสตริงว่างหรือสตริงหนึ่งหรือมากกว่าFและกฎสุดท้าย->!Tจะเพิ่ม a !Tที่จุดเริ่มต้น แล้วกฎระเบียบFF->FและTF->Fลดความซับซ้อนของผลอย่างใดอย่างหนึ่งหรือ!T !Fณ จุดนี้!->.กฎใช้บังคับบอกให้เรากำจัด!และหยุด: กลับไปTหาคำที่มีปัญหาและFอื่น ๆ

(ขอบคุณ bodqhrohro สำหรับการชี้จุดบกพร่องในรุ่นก่อนหน้าซึ่งทำให้รหัสนี้เป็นสตริงว่างเปล่าในอินพุตa)

Python 3 , 90 89 ไบต์

-1 ไบต์โดย 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

ลองออนไลน์!

f(*'man')ใช้เป็น

เรติน่า 0.8.2 , 45 ไบต์

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

ลองออนไลน์! คำอธิบาย:

;

แทรกตัวคั่นระหว่างตัวอักษรแต่ละตัวและที่จุดเริ่มต้นและจุดสิ้นสุด

{`\w
#$&

เตรียม a #ถึงจดหมายแต่ละฉบับ

}T`l`_l

ย้ายตัวอักษรแต่ละตัวกลับไปที่ตัวอักษร 1 แล้วลบas จากนั้นทำซ้ำการดำเนินการด้านบนจนกระทั่งตัวอักษรทั้งหมดถูกลบ สิ่งนี้จะแปลงตัวอักษรแต่ละตัวให้เป็นดัชนีตัวอักษรแบบ 1 ตัวอักษร

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

ทดสอบว่าค่าสองค่าใดมีค่าร่วมกันมากกว่า 1 ตัว (ซึ่งสามารถค้นหาตัวอักษรมากกว่าหนึ่งคู่ที่มีปัจจัยร่วมเช่นในคำyearling)

^0

ตรวจสอบว่าไม่พบปัจจัยทั่วไป

ไลบรารี R + pracma ขนาด 75 ไบต์

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

ฉันใช้gcdฟังก์ชั่นในpracmaห้องสมุดเป็นความรู้ของฉัน R ไม่มีในตัวสำหรับสิ่งนั้น ฉันใช้วิธีการเปรียบเทียบผลิตภัณฑ์ของ gcds กับตัวเลขตัวเอง

65 ไบต์ (เครดิต: @ J.Doe)

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

Japt , 14 ไบต์

;à2 e_®nR+CÃrj

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ของอักขระ

มันทำงานอย่างไร

;à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 ไบต์

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

ลองออนไลน์!

Java 10, 86 ไบต์

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

ท่าเรือ@Vincentหลาม 3 คำตอบ

ลองออนไลน์

คำอธิบาย:

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 ไบต์

รับอินพุตเป็นอาร์เรย์อักขระ

®c uHÃà2 e_rj

ลองใช้หรือตรวจสอบกรณีทดสอบทั้งหมด

q, 121 111 bytes

{$[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 ไบต์

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

ลองออนไลน์!

วิธีดั้งเดิม (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))

ลองออนไลน์!

Stax , 16 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

คำอธิบาย

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

เอาต์พุต 1 สำหรับ True, 0 สำหรับเท็จ

อาจเป็นวิธีที่ดีกว่าในการแปลงเป็นตัวเลข

APL (NARS), 16 ตัวอักษร, 32 ไบต์

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

วิธีการใช้งานอื่น ๆ ที่ใช้นั้น LCM () = × / มันเร็ว แต่ล้นถ้าอาเรย์อินพุตมีความยาวเพียงพอ โซลูชันทางเลือกอื่น ๆ ช้าลงเล็กน้อย:

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

ด้านล่างนี้ดูเหมือนว่าจะเร็วกว่า 10 เท่า (หรือ +) มากกว่าฟังก์ชั่นด้านบน

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

ฉันชอบสิ่งนี้ครั้งสุดท้ายเพราะมันง่ายกว่าเร็วขึ้นเชื่อถือได้ (เพราะมีโอกาสล้นน้อยกว่า) เขียนง่ายกว่าและจะต้องเป็นอย่างไร (แม้ว่าจะมีจำนวนไบต์มากกว่า ... )