Wenn Sie ein Wort haben, behandeln Sie jeden Buchstaben als seine Nummer im englischen Alphabet (wird also azu 1, bwird zu 2, zwird zu 26 usw.), und überprüfen Sie, ob alle Buchstaben , einschließlich der Duplikate, paarweise koprimiert sind .

Die Eingabe ist genau ein Wort aus englischen Kleinbuchstaben. Die Ausgabe ist die Tatsache, dass das Wort Koprime ist: Alle Wahrheiten / Falschheitswerte, aber nur zwei Varianten davon. Standardlücken sind verboten.

Testfälle:

• man: True
• day: True(danke an Ørjan Johansen)
• led: False( l=12und d=4haben gcd=4)
• mana: True(obwohl amehrfach vorkommt, 1 und 1 sind Koprime)
• mom: False( gcd(13,13)=13))
• of: False(danke an xnor; obwohl 15∤6, gcd(15,6)=3)
• a: True(Wenn keine Buchstabenpaare vorhanden sind, wird das Wort auch als Koprime behandelt.)

Dies ist ein Code-Golf , also gewinnt der kürzeste Code in Bytes!

Wolfram Language (Mathematica) , 36 Byte

CoprimeQ@@LetterNumber@Characters@#&

Probieren Sie es online!

Wolfram Language (Mathematica) , 33 Byte

• Vielen Dank an Misha Lavrov für diese drei Bytes kürzere Version.

CoprimeQ @@ (ToCharacterCode @ # - 96) &

Probieren Sie es online!

Gelee , 10 Bytes

ØaiⱮgþ`P$Ƒ

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Sehr einfach: Konvertiert den String in eine Liste von Zahlen und prüft dann, ob das Produkt dem LCM entspricht.

Pyth , 9 Bytes

{Ism{PhxG

Testsuite

{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

_{hat Pyth gerade Jelly übertroffen?}

Python 2 - 122 118 Bytes

-4 Bytes dank @JonathanAllan

Das ist ehrlich gesagt schrecklich, aber ich habe viel zu lange gebraucht, um das nicht zu posten.

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)

Probieren Sie es online

05AB1E , 11 Bytes

Ç96-2.Æ€¿PΘ

Probieren Sie es online!

Erläuterung

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

ạ{-₉₆ḋd}ᵐc≠

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Grundsätzlich (einige Paare in der Eingabe sind nicht gleich primitiv), wenn und nur wenn (es gibt eine Zahl i> 1, die mehr als eine der Eingaben teilt).

Python 3 , 61 59 Bytes

Verwenden von Python-Bytes als Argument:

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

Der letzte zu überprüfende Divisor ist 23, der größte unter 26.

Probieren Sie es online!

Vielen Dank an @Dennis für das Speichern von zwei Bytes.

Perl 6 , 34 32 Bytes

-2 Bytes dank nwellnhof

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

Probieren Sie es online!

Ein anonymer Codeblock, der eine Zeichenfolge akzeptiert und True oder False zurückgibt. Wenn das niedrigste gemeinsame Vielfache der Buchstaben gleich dem Produkt der Buchstaben ist, teilen sie keine gemeinsamen Teiler.

Erläuterung:

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

Erläuterung

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

Probieren Sie es 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--)

Probieren Sie es online!

• Mit der Idee Buffervon Shieru Asakoto ‚s Beitrag .
• Dank Arnauld 5 Bytes gespart.

Jelly , 11 Bytes

ŒcO_96g/€ỊẠ

Probieren Sie es online!

• Vielen Dank an Dennis, dass er meine Booleschen notiert hat

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

Ansonsten Ausgaben 1für Coprime 0.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie 'man'zum Beispiel die Eingabe .

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-Algorithmus, wie von eMain interpretiert ( 474 484 463 Bytes, 76 78 76 Regeln)

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

Die ersten 17 Regeln zerlegen die "zusammengesetzten Buchstaben" in ihre "Hauptbuchstaben" -Faktoren, wobei die Multiplizität ignoriert wird. (Eg, twird , beweil 20 Faktoren als Produkt einer Potenz von 2 und einer Leistung von 5)

Die nächsten 36 Regeln (wie cb->bc) sortieren die resultierenden Primfaktoren.

Die nächsten 9 Regeln (wie bb->F) ersetzen einen wiederholten Primfaktor durch F, dann werden 9 weitere Regeln (wie b->) die verbleibenden einzelnen Buchstaben los.

Zu diesem Zeitpunkt haben wir entweder eine leere Zeichenfolge oder eine Zeichenfolge mit einem oder mehreren Fs, und die letzte Regel ->!Tfügt !Tam Anfang ein hinzu. Dann die Regeln FF->Fund TF->Fvereinfache das Ergebnis entweder auf !Toder !F. An diesem Punkt gilt die !->.Regel, die uns auffordert, das Wort loszuwerden !und Tanzuhalten F.

(Danke an bodqhrohro für den Hinweis auf einen Fehler in der früheren Version, der dazu führte, dass dieser Code bei der Eingabe eine leere Zeichenfolge ergab a.)

Python 3 , 90 89 Bytes

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

Probieren Sie es online!

Verwenden Sie als f(*'man').

Retina 0,8,2 , 45 Bytes

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

Probieren Sie es online! Erläuterung:

;

Fügen Sie zwischen jedem Buchstaben und am Anfang und Ende Trennzeichen ein.

{`\w
#$&

Stellen Sie #jedem Buchstaben ein voran .

}T`l`_l

Bewegen Sie jeden Buchstaben 1 zurück in das Alphabet und löschen Sie das as. Wiederholen Sie dann die obigen Vorgänge, bis alle Buchstaben gelöscht wurden. Dies konvertiert jeden Buchstaben in seinen 1-basierten Alphabetindex in Unary.

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

Testen Sie, ob zwei Werte einen gemeinsamen Faktor größer als 1 haben. (Dies kann mehr als ein Buchstabenpaar mit einem gemeinsamen Faktor finden, z yearling. B. im Wort .)

^0

Stellen Sie sicher, dass keine gemeinsamen Faktoren gefunden wurden.

R + pracma-Bibliothek, 75 Bytes

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

Ich benutze die gcdFunktion in der pracmaBibliothek, da meines Wissens R dafür nicht eingebaut ist. Ich benutze den Ansatz, das Produkt der GCDs mit den Zahlen selbst zu vergleichen.

65 Bytes (Kredit: @ J.Doe)

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

Japt , 14 Bytes

;à2 e_®nR+CÃrj

Probieren Sie es online!

Nimmt die Eingabe als Array von Zeichen.

Wie es funktioniert

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

Probieren Sie es 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;}

Port von @Vincents Python 3 Antwort .

Probieren Sie es online aus.

Erläuterung:

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 Bytes

Übernimmt die Eingabe als Zeichenarray.

®c uHÃà2 e_rj

Probieren Sie es aus oder überprüfen Sie alle Testfälle

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)

Probieren Sie es online!

Ursprünglicher Ansatz (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))

Probieren Sie es online!

Stax , 16 Bytes

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

Führen Sie es aus und debuggen Sie es

Erläuterung

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

Ausgänge 1 für Wahr, 0 für Falsch.

Es gibt wahrscheinlich einen besseren Weg, den Teil in eine Zahl umzuwandeln, aber es funktioniert.

APL (NARS), 16 Zeichen, 32 Byte

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

Diese andere Verwendungsmethode verwendet LCM () = × /. Sie ist schnell, läuft jedoch über, wenn das Eingabearray lang genug ist. andere alternative Lösungen etwas langsamer:

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

Dies scheint unter 10 mal schneller (oder +) als nur über Funktionen

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

Ich bevorzuge letzteres, weil es einfacher, schneller, vertrauenswürdiger (da weniger Überlauf möglich ist), einfacher zu schreiben ist und wie es sein muss (auch wenn es einige Bytes mehr hat ...)