Dada uma palavra, trate cada letra como seu número no alfabeto inglês ( ase torna 1, bse torna 2, zse torna 26 e assim por diante) e verifique se todas elas, incluindo duplicatas, são coprime em pares .

A entrada é exatamente uma palavra de letras minúsculas em inglês. A saída é o fato de a palavra ser coprime: quaisquer valores de verdade / falsey, mas apenas duas variantes deles. As brechas padrão são proibidas.

Casos de teste:

• man: True
• day: True(graças a Ørjan Johansen)
• led: False( l=12e d=4tem gcd=4)
• mana: True(embora aocorra várias vezes, 1 e 1 são coprimes)
• mom: False( gcd(13,13)=13))
• of: False(graças a xnor; porém 15∤6, gcd(15,6)=3)
• a: True(se não houver pares de letras, trate a palavra como coprime também)

Este é um código-golfe , então o código mais curto em bytes vence!

Wolfram Language (Mathematica) , 36 bytes

CoprimeQ@@LetterNumber@Characters@#&

Experimente online!

Wolfram Language (Mathematica) , 33 bytes

• Obrigado a Misha Lavrov por esta versão mais curta de três bytes.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Experimente online!

Gelatina , 10 bytes

ØaiⱮgþ`P$Ƒ

Experimente online!

Como funciona

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

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

Experimente online!

Muito simples: converte a string em uma lista de números e depois verifica se o produto é igual ao LCM.

Pitão , 9 bytes

{Ism{PhxG

Suíte de teste

{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 acabou de superar Jelly?}

Python 2 - 122 118 bytes

-4 bytes graças a @JonathanAllan

Isso é honestamente terrível, mas eu gastei muito tempo para não postar isso.

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)

Experimente Online

05AB1E , 11 bytes

Ç96-2.Æ€¿PΘ

Experimente online!

Explicação

Ç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

Braquilog , 11 bytes

ạ{-₉₆ḋd}ᵐc≠

Experimente online!

Explicação

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

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

Experimente online!

Basicamente, (algum par na entrada não é co-prime) se e somente se (existe um número i> 1 que divide mais de uma das entradas).

Python 3 , 61 59 bytes

Usando bytes python como argumento:

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

O último divisor a verificar é 23, o maior número primo abaixo de 26.

Experimente online!

Obrigado a @Dennis por salvar dois bytes.

Perl 6 , 34 32 bytes

-2 bytes graças a nwellnhof

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

Experimente online!

Um código codificado anônimo que pega uma string e retorna True ou False. Se o menor múltiplo comum das letras for igual ao produto das letras, eles não compartilharão divisores comuns.

Explicação:

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

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

Ungolfed

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

Explicação

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

Experimente online!

JavaScript (Node.js) , 60 bytes

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

Experimente online!

• Usando a idéia de Bufferpartir Shieru Asakoto de pós .
• Graças a Arnauld , economizamos 5 bytes.

Geléia , 11 bytes

ŒcO_96g/€ỊẠ

Experimente online!

• Obrigado a Dennis por anotar meus booleanos

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

96-YF&fdA&

Saídas 1por coprime, 0caso contrário.

Experimente online! Ou verifique todos os casos de teste .

Explicação

Considere entrada, 'man'por exemplo.

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 algoritmo, tal como é interpretado pelos emain ( 474 484 463 bytes, 76 78 76 regras)

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

As 17 primeiras regras fatoram as "letras compostas" em seus fatores de "letra principal", ignorando a multiplicidade. (Por exemplo, ttorna-se beporque 20 fatores são um produto de uma potência de 2 e uma potência de 5.)

As próximas 36 regras (como cb->bc) classificam os principais fatores resultantes.

As próximas 9 regras (como bb->F) substituem um fator primo repetido por F, e mais 9 regras (comob-> ) se livram das restantes letras únicas.

Nesse ponto, temos uma sequência vazia ou uma sequência de um ou mais Fs, e a última regra ->!Tadiciona a !Tno início. Em seguida, regras FF->Fe TF->Fsimplifique o resultado para um !Tou outro !F. Nesse ponto, a !->.regra se aplica, dizendo-nos para nos livrarmos !e pararmos: retornar Tpara uma palavra de coprime e Fassim por diante .

(Agradecemos a bodqhrohro por apontar um bug na versão anterior que causou esse código fornecer uma string vazia na entrada a.)

Python 3 , 90 89 bytes

-1 byte por 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

Experimente online!

Use como f(*'man').

Retina 0.8.2 , 45 bytes

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

Experimente online! Explicação:

;

Insira separadores entre cada letra e no início e no final.

{`\w
#$&

Anexe um #a cada letra.

}T`l`_l

Mova cada letra 1 de volta no alfabeto, excluindo os a. Repita as operações acima até que todas as letras tenham sido excluídas. Isso converte cada letra em seu índice de alfabeto baseado em 1 em unário.

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

Teste se dois valores compartilham um fator comum maior que 1. (Isso pode encontrar mais de um par de letras com um fator comum, por exemplo, na palavra yearling).

^0

Verifique se não foram encontrados fatores comuns.

Biblioteca R + pracma, 75 bytes

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

Estou usando a gcdfunção na pracmabiblioteca quanto ao meu conhecimento R não tem um built-in para isso. Estou usando a abordagem de comparar o produto dos gcds com os próprios números.

65 bytes (crédito: @ J.Doe)

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

Japonês , 14 bytes

;à2 e_®nR+CÃrj

Experimente online!

Recebe a entrada como uma matriz de caracteres.

Como funciona

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

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

Experimente online!

Java 10, 86 bytes

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

Porto da resposta Python 3 do @Vincent .

Experimente online.

Explicação:

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

Japonês, 13 bytes

Recebe entrada como uma matriz de caracteres.

®c uHÃà2 e_rj

Experimente ou verifique todos os casos de teste

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 bytes

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

Experimente online!

Abordagem original (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))

Experimente online!

Stax , 16 bytes

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

Execute e depure

Explicação

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

Saídas 1 para Verdadeiro, 0 Para falso.

Provavelmente existe uma maneira melhor de converter a parte numérica, mas funciona.

APL (NARS), 16 caracteres, 32 bytes

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

Este método de uso utilizado foi o LCM () = × /, que é rápido, mas transborda, se a matriz de entrada for suficientemente longa; outras soluções alternativas um pouco mais lentas:

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

abaixo, parece 10 vezes mais rápido (ou +) do que as funções acima

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

Eu prefiro esse último porque é mais fácil, mais rápido, confiável (menos possibilidade de transbordamento), mais fácil de escrever e como deve ser (mesmo que tenha alguns bytes a mais ...)