Le mot est-il coprime?

18

É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!

code-golf  decision-problem  number-theory  primes 
— bodqhrohro
source
1
Pouvons-nous sortir 0s'ils sont coprimes et 1sinon?
— dylnan
2
Cas de test suggéré qui aurait attrapé une réponse de buggy:day: True
— Ørjan Johansen
1
Je suggère également of: Falsed'avoir un faux exemple où aucune valeur n'est un multiple d'un autre.
— xnor
@dylnan non, c'est contr-intuitif. Quoi qu'il en soit, la réponse de Dennis est meilleure ;-)
— bodqhrohro
@LuisMendo toute vérité / falsey, mais seulement deux.
— bodqhrohro

Réponses:

8

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.
— Dennis
source
7

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.

— Delfad0r
source
6

Pyth , 9 octets

{Ism{PhxG

Suite de tests

Explication: 
{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?

— hakr14
source
6

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

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

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
— Emigna
source
La finale est-elle Θvraiment nécessaire?
— M. Xcoder
@ Mr.Xcoder: Non, je suppose que non. J'ai juste supposé que nous devions utiliser 2 valeurs distinctes, mais maintenant que je regarde il n'y a rien dans le défi à ce sujet. Truthy / Falsy devrait être d'accord alors.
— Emigna
@Emigna J'ai ajouté une précision à cela: il ne devrait y avoir que deux variantes de valeurs de sortie.
— bodqhrohro
@bodqhrohro: OK. Je suis revenu à la version précédente pour me conformer à cette nouvelle exigence.
— Emigna
5

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

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

— Chas Brown
source
On dirait que nous avons eu la même idée mais tu m'as battu de quelques minutes :) Tu ne peux pas sauver ces 2 octets en utilisant allet <2pourtant?
— Vincent
4

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.

— Vincent
source
3
c%96%x<1for c in senregistre 2 octets.
— Dennis
4

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
— Jo King
source
Si je ne me trompe pas, ça marche? (21 octets)
— Conor O'Brien
@ ConorO'Brien Non, vous venez de mapper aà 0lol
— Jo King
@JoKing oh, ok lol
— Conor O'Brien
Cette stratégie était bogué, cas de test: day.
— Ørjan Johansen
1
— nwellnhof
3

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!

— Jonas
source
[:(1=[:*/+./~#&,~#\~:/#\)_96+a.&i.pour 34 octets Vous aviez un espace dans `1 = ':)
— Galen Ivanov
1
Merci @GalenIvanov
— Jonah
3

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.
— dylnan
source
2
ỊẠretourne les booléens.
— Dennis
3

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

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

— Misha Lavrov
source
1
Ne donne Tni Fsur atestcase.
— bodqhrohro
@bodqhrohro Merci pour la capture! (En fin de compte, mon nombre d'octets a baissé, car j'ai réalisé que je comptais chaque nouvelle ligne comme deux octets.)
— Misha Lavrov
2

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

— Neil
source
2

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)

— jld
source
1

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

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

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

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.

— Multi
source
Auteur de Stax ici. Merci d'avoir essayé Stax! Voici un programme utilisant votre algorithme qui contient 10 octets. 2SOF{96-F:!* Faites-moi savoir si vous voulez en savoir plus. Le premier est gratuit!
— récursif
@recursive Merci d'avoir fait Stax! C'est ma langue de golf de choix en ce moment. Je peux voir comment votre réponse fonctionne et je devrai continuer à travailler pour améliorer mes réponses à l'avenir.
— Multi
0

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

— RosLuP
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.