Biorąc pod uwagę słowo, każdą literę traktuj jako cyfrę alfabetu angielskiego (czyli a1, b2, z26 itd.) I sprawdź, czy wszystkie, łącznie z duplikatami, są chronione parami .

Dane wejściowe to dokładnie jedno słowo małych angielskich liter. Wynikiem jest fakt, że słowo to coprime: dowolne wartości truey / falsey, ale tylko dwa warianty. Standardowe luki są zabronione.

Przypadki testowe:

• man: True
• day: True(dzięki Ørjan Johansen)
• led: False( l=12i d=4mieć gcd=4)
• mana: True(choć awystępuje wiele razy, 1 i 1 są pierwszymi kopiami)
• mom: False( gcd(13,13)=13))
• of: False(Dzięki XNOR; chociaż 15∤6, gcd(15,6)=3)
• a: True(jeśli nie ma par liter, traktuj to słowo również jako coprime)

To jest golfowy kod , więc wygrywa najkrótszy kod w bajtach!

Wolfram Language (Mathematica) , 36 bajtów

CoprimeQ@@LetterNumber@Characters@#&

Wypróbuj online!

Wolfram Language (Mathematica) , 33 bajty

• Podziękowania dla Miszy Ławrow za tę trzy bajtową krótszą wersję.

CoprimeQ @@ (ToCharacterCode @ # - 96) i

Wypróbuj online!

Galaretka , 10 bajtów

ØaiⱮgþ`P$Ƒ

Wypróbuj online!

Jak to działa

Ø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 bajtów

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

Wypróbuj online!

Bardzo proste: konwertuje ciąg na listę liczb, a następnie sprawdza, czy produkt jest równy LCM.

Pyth , 9 bajtów

{Ism{PhxG

Zestaw testowy

{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

_{czy Pyth wyprzedził galaretkę?}

Python 2 - 122 118 bajtów

-4 bajty dzięki @JonathanAllan

To jest naprawdę okropne, ale spędziłem zbyt długo, aby tego nie opublikować.

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)

Wypróbuj online

05AB1E , 11 bajtów

Ç96-2.Æ€¿PΘ

Wypróbuj online!

Wyjaśnienie

Ç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 bajtów

ạ{-₉₆ḋd}ᵐc≠

Wypróbuj online!

Wyjaśnienie

ạ{-₉₆ḋ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 bajtów

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

Wypróbuj online!

Zasadniczo (niektóre pary na wejściu nie są współużytkowane) wtedy i tylko wtedy, gdy (istnieje liczba i> 1, która dzieli więcej niż jedno wejście).

Python 3 , 61 59 bajtów

Używanie bajtów python jako argumentu:

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

Ostatni dzielnik do sprawdzenia to 23, największa liczba pierwsza poniżej 26.

Wypróbuj online!

Dzięki @Dennis za zapisanie dwóch bajtów.

Perl 6 , 34 32 bajty

-2 bajty dzięki nwellnhof

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

Wypróbuj online!

Anonimowy blok kodu, który pobiera ciąg znaków i zwraca wartość True lub False. Jeśli najniższa wspólna wielokrotność liter jest równa iloczynowi liter, to nie dzielą one wspólnych dzielników.

Wyjaśnienie:

                     {.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 bajtów

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

Nie golfił

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

Wyjaśnienie

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

Wypróbuj online!

JavaScript (Node.js) , 60 bajtów

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

Wypróbuj online!

• Korzystanie pomysł Bufferz Shieru Asakoto „s postu .
• Dzięki Arnauldowi udało się zaoszczędzić 5 bajtów.

Galaretka , 11 bajtów

ŒcO_96g/€ỊẠ

Wypróbuj online!

• Dziękuję Dennisowi za ZNACZENIE moich booleanów

Œ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 bajtów

96-YF&fdA&

Wyjścia 1dla coprime, w 0przeciwnym razie.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Rozważmy 'man'na przykład dane wejściowe .

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

Algorytm Markowa zgodnie z interpretacją eMaina ( 474 484 463 bajtów, 76 78 76 reguł)

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

Pierwsze 17 reguł uwzględnia czynniki „litery złożone” w czynniki „litery pierwsze”, ignorując wielokrotność. (Np. tStaje się, beponieważ 20 czynników jest iloczynem potęgi 2 i potęgi 5).

Następne 36 zasad (takich jak cb->bc) sortuje wynikowe czynniki pierwsze.

Następne 9 reguł (takich jak bb->F) zastępuje powtarzający się czynnik pierwszy przez F, a następnie 9 kolejnych reguł (takich jak b->) pozbywa się pozostałych pojedynczych liter.

W tym momencie albo mamy pusty ciąg, albo ciąg jednego lub więcej Fs, a ostatnia reguła ->!Tdodaje !Tna początku. Następnie reguły FF->Fi TF->Fuprość wynik do jednego !Tlub !F. W tym momencie obowiązuje !->.zasada, która nakazuje nam się pozbyć !i zatrzymać: powrót Tdo słowa coprime i Finaczej.

(Podziękowania dla bodqhrohro za wskazanie błędu we wcześniejszej wersji, który spowodował, że ten kod podał pusty ciąg wejściowy a.)

Python 3 , 90 89 bajtów

-1 bajt przez 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

Wypróbuj online!

Użyj jako f(*'man').

Retina 0.8.2 , 45 bajtów

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

Wypróbuj online! Wyjaśnienie:

;

Wstaw separatory między każdą literą oraz na początku i na końcu.

{`\w
#$&

Przygotuj a #do każdej litery.

}T`l`_l

Przenieś każdą literę 1 z powrotem w alfabecie, usuwając as. Następnie powtarzaj powyższe operacje, aż wszystkie litery zostaną usunięte. Konwertuje każdą literę na indeks alfabetu oparty na 1 jednostronnie.

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

Sprawdź, czy dowolne dwie wartości mają wspólny czynnik większy niż 1. (Może znaleźć więcej niż jedną parę liter ze wspólnym czynnikiem, np. W słowie yearling).

^0

Sprawdź, czy nie znaleziono wspólnych czynników.

Biblioteka R + pracma, 75 bajtów

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

Korzystam z gcdfunkcji wpracma bibliotece, ponieważ według mojej wiedzy R nie ma do tego wbudowanej funkcji. Używam podejścia polegającego na porównaniu produktu gcds z samymi liczbami.

65 bajtów (kredyt: @ J.Doe)

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

Japt , 14 bajtów

;à2 e_®nR+CÃrj

Wypróbuj online!

Pobiera dane wejściowe jako tablicę znaków.

Jak to działa

;à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?

Rubinowy , 56 bajtów

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

Wypróbuj online!

Java 10, 86 bajtów

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 odpowiedzi Python 3 na @ Vincent .

Wypróbuj online.

Wyjaśnienie:

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 bajtów

Pobiera dane wejściowe jako tablicę znaków.

®c uHÃà2 e_rj

Wypróbuj lub sprawdź wszystkie przypadki testowe

q, 121 111 bajtów

{$[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 bajtów

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

Wypróbuj online!

Oryginalne podejście (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))

Wypróbuj online!

Stax , 16 bajtów

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

Uruchom i debuguj

Wyjaśnienie

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

Wyjścia 1 dla wartości True, 0 dla wartości false.

Prawdopodobnie jest lepszy sposób na konwersję na część liczbową, ale działa.

APL (NARS), 16 znaków, 32 bajty

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

W tej innej metodzie użyto LCM () = × /, jest szybki, ale przepełnia się, jeśli tablica wejściowa jest wystarczająco długa; inne alternatywne rozwiązania nieco wolniej:

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

to poniżej wydaje się 10 razy szybsze (lub +) niż tylko powyżej funkcji

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

Wolę to ostatnie, ponieważ jest łatwiejsze, szybsze, godne zaufania (ponieważ mniej możliwości przepełnienia), łatwiejsze do napisania i jak to musi być (nawet jeśli ma więcej bajtów więcej ...)