Давши слово, поводьтеся з кожною буквою як з цифрою в англійському алфавіті (так вона aстає 1, bстає 2, zстає 26 тощо) і перевірте, чи всі вони, включаючи дублікати, є парними одночасними .

Введено рівно одне слово з малих англійських букв. Вихідним є факт, якщо слово є одночасним: будь-які значення truthy / falsey, але лише два їх варіанти. Стандартні лазівки заборонені.

Тестові приклади:

• man: True
• day: True(спасибі Ørjan Johansen)
• led: False( l=12і d=4є gcd=4)
• mana: True(хоча aтрапляється декілька разів, 1 і 1 є копримами)
• mom: False( gcd(13,13)=13))
• of: False(завдяки xnor; хоча 15∤6, gcd(15,6)=3)
• a: True(якщо немає пар букв, трактуйте це слово також як копрієм)

Це код-гольф , тому найкоротший код у байтах виграє!

Мова Вольфрама (Mathematica) , 36 байт

CoprimeQ@@LetterNumber@Characters@#&

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 33 байти

• Дякую Міші Лаврову за цю трибайтову коротку версію.

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

_{Піт просто перевершив Джеллі?}

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

Брахілог , 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 в якості аргументу:

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}

Спробуйте в Інтернеті!

Анонімний кодовий блок, який бере рядок і повертає значення True або False. Якщо найменший загальний кратний з літер дорівнює добутку літер, то вони не мають спільних дільників.

Пояснення:

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

Безумовно

[: (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 пост .
• Завдяки Арнольду зберегли 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для копрімусу, в 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->) позбудуться решти однієї літери.

На даний момент у нас або є порожній рядок, або рядок одного або декількох Fs, і останнє правило ->!Tдодає a !Tна початку. Потім правила FF->Fі TF->Fспростіть результат до !Tабо !F. У цей момент діє !->.правило, яке говорить нам позбутися !та зупинитись: повертаючись Tза словосполученням та Fінше.

(Дякуємо bodqhrohro за вказівку на помилку в попередній версії, яка спричинила, що цей код дасть порожній рядок на вході a.)

Python 3 , 90 89 байт

-1 байт за числом маніяка

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
#$&

Додайте #до кожної літери а.

}T`l`_l

Перемістіть кожну букву 1 назад в алфавіті, видаливши as. Потім повторіть описані вище операції, поки всі букви не будуть видалені. Це перетворює кожну букву в її 1-індекс алфавіту в одинаковий.

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

Перевірте, чи мають два значення спільний коефіцієнт, більший за 1. (Тут можна знайти більше однієї пари літер із загальним фактором, наприклад у слові yearling.)

^0

Перевірте, чи не знайдено загальних факторів.

R + пракма бібліотека, 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?

Рубін , 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 's Python 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 байт

{$[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))

Спробуйте в Інтернеті!

Стакс , 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 для false.

Мабуть, є кращий спосіб зробити перетворення на числову частину, але це працює.

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

я вважаю за краще це останнє, тому що це легше, швидше, довіряється (бо менше менше можливостей переповнення), простіше писати і як це має бути (навіть якщо у нього є кілька байт більше ...)