Dato una parola, tratta ogni lettera come il suo numero in alfabeto inglese (quindi adiventa 1, bdiventa 2, zdiventa 26 e così via) e controlla se tutti, inclusi i duplicati, sono coprimi a coppie .

L'input è esattamente una parola di lettere inglesi minuscole. L'output è il fatto se la parola è coprime: qualsiasi valore di verità / falsità, ma solo due varianti di essi. Sono vietate le scappatoie standard.

Casi test:

• man: True
• day: True(grazie a Ørjan Johansen)
• led: False( l=12e d=4avere gcd=4)
• mana: True(sebbene si averifichi più volte, 1 e 1 sono coprimi)
• mom: False( gcd(13,13)=13))
• of: False(grazie a xnor; però 15∤6, gcd(15,6)=3)
• a: True(se non ci sono coppie di lettere, tratta anche la parola come coprime)

Questo è un codice-golf , quindi vince il codice più corto in byte!

Wolfram Language (Mathematica) , 36 byte

CoprimeQ@@LetterNumber@Characters@#&

Provalo online!

Wolfram Language (Mathematica) , 33 byte

• Grazie a Misha Lavrov per questa versione più breve di tre byte.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Provalo online!

Gelatina , 10 byte

ØaiⱮgþ`P$Ƒ

Provalo online!

Come funziona

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

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

Provalo online!

Molto semplice: converte la stringa in un elenco di numeri e quindi controlla se il prodotto è uguale all'LCM.

Pyth , 9 byte

{Ism{PhxG

Suite di test

{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 ha appena superato la gelatina di Jelly?}

Python 2 - 122 118 byte

-4 byte grazie a @JonathanAllan

È davvero terribile, ma ho passato troppo tempo a non pubblicarlo.

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)

Provalo online

05AB1E , 11 byte

Ç96-2.Æ€¿PΘ

Provalo online!

Spiegazione

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

ạ{-₉₆ḋd}ᵐc≠

Provalo online!

Spiegazione

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

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

Provalo online!

Fondamentalmente, (alcune coppie nell'ingresso non sono co-prime) se e solo se (c'è un numero i> 1 che divide più di uno degli ingressi).

Python 3 , 61 59 byte

Utilizzando byte Python come argomento:

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

L'ultimo divisore da controllare è 23, il massimo primo sotto 26.

Provalo online!

Grazie a @Dennis per aver salvato due byte.

Perl 6 , 34 32 byte

-2 byte grazie a nwellnhof

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

Provalo online!

Un blocco di codice anonimo che accetta una stringa e restituisce True o False. Se il minimo comune multiplo delle lettere è uguale al prodotto delle lettere di quanto non condividano divisori comuni.

Spiegazione:

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

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

Ungolfed

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

Spiegazione

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

Provalo online!

JavaScript (Node.js) , 60 byte

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

Provalo online!

• Utilizzando l'idea di Bufferda Shieru Asakoto s' posta .
• Grazie ad Arnauld , salvato 5 byte.

Gelatina , 11 byte

ŒcO_96g/€ỊẠ

Provalo online!

• Grazie a Dennis per aver notato i miei booleani

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

96-YF&fdA&

Uscite 1per coprime, 0altrimenti.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considerare input 'man'per esempio.

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

Algoritmo di Markov, come interpretato da eMain ( 474 484 463 byte, 76 78 76 regole)

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

Le prime 17 regole inseriscono le "lettere composte" nei loro fattori "prime letter", ignorando la molteplicità. (Ad esempio, tdiventa beperché 20 fattori come prodotto di una potenza di 2 e una potenza di 5.)

Le successive 36 regole (come cb->bc) ordinano i fattori primi risultanti.

Le successive 9 regole (come bb->F) sostituiscono un fattore primo ripetuto con F, quindi altre 9 regole (come b->) eliminano le singole lettere rimanenti.

A questo punto, abbiamo una stringa vuota o una stringa di una o più Fs, e l'ultima regola ->!Taggiunge una !Tall'inizio. Quindi le regole FF->Fe TF->Fsemplificano il risultato su !To !F. A questo punto, !->.si applica la regola, che ci dice di sbarazzarci !e fermarci: tornare Tper una parola coprime, e Faltrimenti.

(Grazie a bodqhrohro per aver segnalato un bug nella versione precedente che ha causato questo codice per dare una stringa vuota sull'input a.)

Python 3 , 90 89 byte

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

Provalo online!

Usa come f(*'man').

Retina 0.8.2 , 45 byte

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

Provalo online! Spiegazione:

;

Inserisci separatori tra ogni lettera e all'inizio e alla fine.

{`\w
#$&

Prepara #a ogni lettera.

}T`l`_l

Sposta ogni lettera 1 indietro nell'alfabeto, eliminando la as. Quindi ripetere le operazioni precedenti fino a quando tutte le lettere non sono state eliminate. Questo converte ogni lettera nel suo indice alfabetico in base 1 in unario.

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

Verifica se due valori qualsiasi condividono un fattore comune maggiore di 1. (Questo può trovare più di una coppia di lettere con un fattore comune, ad esempio nella parola yearling).

^0

Verificare che non siano stati trovati fattori comuni.

Libreria R + pracma, 75 byte

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

Sto usando la gcdfunzione nella pracmalibreria per quanto ne so R non ha un built-in per quello. Sto usando l'approccio di confrontare il prodotto dei gcds con i numeri stessi.

65 byte (credito: @ J.Doe)

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

Japt , 14 byte

;à2 e_®nR+CÃrj

Provalo online!

Accetta input come una matrice di caratteri.

Come funziona

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

Rubino , 56 byte

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

Provalo online!

Java 10, 86 byte

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

Porta della risposta Python 3 di @Vincent .

Provalo online.

Spiegazione:

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 byte

Accetta input come una matrice di caratteri.

®c uHÃà2 e_rj

Provalo o verifica tutti i casi di test

q, 121 111 byte

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

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

Provalo online!

Approccio 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))

Provalo online!

Stax , 16 byte

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

Esegui ed esegui il debug

Spiegazione

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

Uscite 1 per True, 0 Per false.

Probabilmente esiste un modo migliore per eseguire la conversione in parte numerica, ma funziona.

APL (NARS), 16 caratteri, 32 byte

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

Questo metodo utilizzava altro che LCM () = × /, è veloce ma trabocca se l'array di input è abbastanza lungo; altre soluzioni alternative un po 'più lente:

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

questo sotto sembra 10 volte più veloce (o +) rispetto alle funzioni appena sopra

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

preferisco quest'ultima perché è più facile, più veloce, affidabile (perché meno possibilità di overflow), più facile da scrivere e come deve essere (anche se ha qualche byte in più ...)