Étant donné un mot, traitez chaque lettre comme son numéro dans l'alphabet anglais ( adevient ainsi 1, bdevient 2, zdevient 26 et ainsi de suite), et vérifiez si toutes, y compris les doublons, sont des nombres premiers par paire .

L'entrée est exactement un mot de lettres anglaises minuscules. La sortie est le fait si le mot est coprime: toutes les valeurs truey / falsey, mais seulement deux variantes d'entre elles. Les failles standard sont interdites.

Cas de test:

• man: True
• day: True(merci à Ørjan Johansen)
• led: False( l=12et d=4avoir gcd=4)
• mana: True(mais ase produit plusieurs fois, 1 et 1 sont des nombres premiers)
• mom: False( gcd(13,13)=13))
• of: False(merci à xnor; cependant 15∤6, gcd(15,6)=3)
• a: True(s'il n'y a pas de paires de lettres, traitez aussi le mot comme un premier)

C'est un code-golf , donc le code le plus court en octets gagne!

Wolfram Language (Mathematica) , 36 octets

CoprimeQ@@LetterNumber@Characters@#&

Essayez-le en ligne!

Wolfram Language (Mathematica) , 33 octets

• Merci à Misha Lavrov pour cette version plus courte de trois octets.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Essayez-le en ligne!

Gelée , 10 octets

ØaiⱮgþ`P$Ƒ

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Très simple: convertit la chaîne en une liste de nombres, puis vérifie si le produit est égal au LCM.

Pyth , 9 octets

{Ism{PhxG

Suite de tests

{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 vient-il de déjouer Jelly?}

Python 2 - 122 118 octets

-4 octets grâce à @JonathanAllan

C'est vraiment horrible, mais j'ai passé beaucoup trop de temps à ne pas poster ceci.

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)

Essayez-le en ligne

05AB1E , 11 octets

Ç96-2.Æ€¿PΘ

Essayez-le en ligne!

Explication

Ç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 octets

ạ{-₉₆ḋd}ᵐc≠

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Fondamentalement, (une paire dans l'entrée n'est pas co-amorcée) si et seulement si (il y a un nombre i> 1 qui divise plus d'une des entrées).

Python 3 , 61 59 octets

Utiliser des octets python comme argument:

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

Le dernier diviseur à vérifier est 23, le plus grand nombre premier inférieur à 26.

Essayez-le en ligne!

Merci à @Dennis d'avoir économisé deux octets.

Perl 6 , 34 32 octets

-2 octets grâce à nwellnhof

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

Essayez-le en ligne!

Un bloc de code anonyme qui prend une chaîne et renvoie True ou False. Si le plus petit commun multiple des lettres est égal au produit des lettres, alors elles ne partagent aucun diviseur commun.

Explication:

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

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

Non golfé

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

Explication

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

Essayez-le en ligne!

JavaScript (Node.js) , 60 octets

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

Essayez-le en ligne!

• En utilisant l'idée de Bufferpartir Shieru Asakoto de poste .
• Merci à Arnauld , économisé 5 octets.

Gelée , 11 octets

ŒcO_96g/€ỊẠ

Essayez-le en ligne!

• Merci à Dennis d'avoir noté mes booléens

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

96-YF&fdA&

Sorties 1pour coprime, 0sinon.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Prenons l' 'man'exemple de la saisie .

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

Algorithme de Markov, tel qu'interprété par eMain ( 474 484 463 octets, 76 78 76 règles)

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

Les 17 premières règles factorisent les «lettres composites» dans leurs facteurs «lettres principales», ignorant la multiplicité. (Par exemple, tdevient beparce que 20 facteurs sont le produit d'une puissance de 2 et d'une puissance de 5.)

Les 36 règles suivantes (telles que cb->bc) trient les facteurs premiers résultants.

Les 9 règles suivantes (telles que bb->F) remplacent un facteur premier répété par F, puis 9 autres règles (telles que b->) suppriment les lettres simples restantes.

À ce stade, nous avons soit une chaîne vide, soit une chaîne d'un ou plusieurs Fs, et la dernière règle ->!Tajoute un !Tau début. Ensuite, les règles FF->Fet TF->Fsimplifier le résultat à !Tou !F. À ce stade, la !->.règle s'applique, nous disant de nous débarrasser de !et de nous arrêter: revenir Tpour un mot premier, etF autrement.

(Merci à bodqhrohro d'avoir signalé un bogue dans la version précédente qui faisait que ce code donnait une chaîne vide en entrée a.)

Python 3 , 90 89 octets

-1 octet par 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

Essayez-le en ligne!

Utiliser comme f(*'man').

Retina 0.8.2 , 45 octets

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

Essayez-le en ligne! Explication:

;

Insérez des séparateurs entre chaque lettre et au début et à la fin.

{`\w
#$&

Ajoutez un #à chaque lettre.

}T`l`_l

Déplacez chaque lettre 1 dans l'alphabet, en supprimant le as. Répétez ensuite les opérations ci-dessus jusqu'à ce que toutes les lettres aient été supprimées. Cela convertit chaque lettre en son index alphabétique basé sur 1 en unaire.

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

Testez si deux valeurs partagent un facteur commun supérieur à 1. (Cela peut trouver plus d'une paire de lettres avec un facteur commun, par exemple dans le mot yearling.)

^0

Vérifiez qu'aucun facteur commun n'a été trouvé.

Bibliothèque R + pracma, 75 octets

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

J'utilise le gcd fonction dans la pracmabibliothèque car à ma connaissance, R n'a pas de fonction intégrée pour cela. J'utilise l'approche consistant à comparer le produit des gcds aux chiffres eux-mêmes.

65 octets (crédit: @ J.Doe)

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

Japt , 14 octets

;à2 e_®nR+CÃrj

Essayez-le en ligne!

Prend l'entrée comme un tableau de caractères.

Comment ça fonctionne

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

Rubis , 56 octets

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

Essayez-le en ligne!

Java 10, 86 octets

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 de la réponse Python 3 de @Vincent .

Essayez-le en ligne.

Explication:

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 octets

Prend l'entrée comme un tableau de caractères.

®c uHÃà2 e_rj

Essayez-le ou vérifiez tous les cas de test

q, 121 111 octets

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

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

Essayez-le en ligne!

Approche originale (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))

Essayez-le en ligne!

Stax , 16 octets

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

Exécuter et déboguer

Explication

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

Sorties 1 pour True, 0 pour false.

Il y a probablement une meilleure façon de faire la conversion en partie numérique, mais cela fonctionne.

APL (NARS), 16 caractères, 32 octets

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

Cette méthode d'utilisation autre que LCM () = × /, est rapide mais déborde si le tableau d'entrée est assez long; autres solutions alternatives un peu plus lentes:

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

ci-dessous, il semble 10 fois plus rapide (ou +) que juste au-dessus des fonctions

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

Je préfère ce dernier parce qu'il est plus facile, plus rapide, fiable (car il y a moins de débordement possible), plus facile à écrire et comment il doit être (même s'il a quelques octets de plus ...)