Ist das Wort Koprime?

18

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!

code-golf  decision-problem  number-theory  primes 
— bodqhrohro
quelle
1
Können wir ausgeben, 0wenn es sich um Coprime handelt und 1wenn nicht?
— Dylnan
2
Vorgeschlagener Testfall, der eine fehlerhafte Antwort gefunden hätte:day: True
— Ørjan Johansen
1
Ich würde auch vorschlagen of: False, ein falsches Beispiel zu haben, bei dem kein Wert ein Vielfaches eines anderen ist.
— Xnor
@ dylnan nein, es ist nicht intuitiv. Wie auch immer, Dennis 'Antwort ist besser ;-)
— Bodqhrohro
@ LuisMendo jede Wahrheit / Falschheit, aber nur zwei.
— Bodqhrohro

Antworten:

8

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.
— Dennis
quelle
6

Pyth , 9 Bytes

{Ism{PhxG

Testsuite

Erläuterung: 
{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?

— hakr14
quelle
6

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

— Don Tausend
quelle
4
96 for~> 96for; lambda x,y:x*y~> int.__mul__.
— Jonathan Frech
5

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
— Emigna
quelle
Ist das Finale Θwirklich notwendig?
— Mr. Xcoder
@ Mr.Xcoder: Nein nehme ich nicht an. Ich bin nur davon ausgegangen, dass wir 2 Distict-Werte verwenden müssen, aber jetzt, da ich sehe, gibt es nichts an der Herausforderung. Truthy / Falsy sollte dann okay sein.
— Emigna
@Emigna Ich habe eine Klarstellung hinzugefügt: Es sollte nur zwei Varianten von Ausgabewerten geben.
— Bodqhrohro
@ Bodqhrohro: OK. Ich habe auf die vorherige Version zurückgesetzt, um diese neue Anforderung zu erfüllen.
— Emigna
5

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
— PunPun1000
quelle
4

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

— Chas Brown
quelle
Sieht so aus, als hätten wir die gleiche Idee, aber Sie haben mich ein paar Minuten geschlagen :) Können Sie diese 2 Bytes nicht mit allund retten <2?
— Vincent
4

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.

— Vincent
quelle
3
c%96%x<1for c in sSpart 2 Bytes.
— Dennis
4

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
— Scherzen
quelle
Wenn ich mich nicht irre, funktioniert das ? (21 Bytes)
— Conor O'Brien
@ ConorO'Brien Nein, haben kartiert einfach azu 0lol
— Jo König
@JoKing oh, ok lol
— Conor O'Brien
Diese Strategie war fehlerhaft, Testfall: day.
— Ørjan Johansen
1
— Nwellnhof
3

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!

— Jona
quelle
[:(1=[:*/+./~#&,~#\~:/#\)_96+a.&i.für 34 Bytes Sie hatten ein Leerzeichen in "1 =" :)
— Galen Ivanov
1
Thanks @GalenIvanov
— Jonah
3

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.
— dylnan
quelle
2
ỊẠdreht die Booleschen um.
— Dennis
3

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
— Luis Mendo
quelle
3

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

— Mischa Lawrow
quelle
1
Gibt weder Testfall Tnoch Fauf a.
— Bodqhrohro
@bodqhrohro Danke für den Fang! (Am Ende ging meine Byteanzahl zurück, weil ich feststellte, dass ich jede neue Zeile als zwei Bytes zählte.)
— Misha Lavrov
2

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.

— Neil
quelle
2

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)

— jld
quelle
1

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?
— Bubbler
quelle
1

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
— Kevin Cruijssen
quelle
0

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]]}
— Thaufeki
quelle
0

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.

— Multi
quelle
Stax-Autor hier. Danke, dass du stax ausprobiert hast! Hier ist ein Programm, das Ihren Algorithmus verwendet und auf 10 Bytes komprimiert. 2SOF{96-F:!* Lass es mich wissen, wenn du mehr darüber wissen willst. Ersteres ist kostenlos!
— Rekursiv
@recursive Danke, dass du Stax gemacht hast! Es ist momentan meine bevorzugte Golfsprache. Ich kann sehen, wie Ihre Antwort funktioniert, und ich muss weiter daran arbeiten, meine Antworten in Zukunft zu verbessern.
— Multi
0

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

— RosLuP
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.