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

Вводится ровно одно слово из строчных английских букв. Выводом является тот факт, что слово взаимно простое: любые значения истины / фальши, но только два их варианта. Стандартные лазейки запрещены.

Тестовые случаи:

• man: True
• day: True(спасибо Эрджану Йохансену)
• 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(если нет пар букв, трактуйте слово как взаимно простое)

Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Wolfram Language (Mathematica) , 36 байт

CoprimeQ@@LetterNumber@Characters@#&

Попробуйте онлайн!

Wolfram Language (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 байт

Используя байты питона в качестве аргумента:

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.

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 пост .
• Благодаря Арно , сэкономлено 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 + 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?

Рубин , 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))

Попробуйте онлайн!

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 для 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:
∇

Я предпочитаю этот последний, потому что он проще, быстрее, надежнее (потому что меньше вероятность переполнения), легче писать и каким он должен быть (даже если у него больше байтов ...)