Bir kelime verildiğinde, her harfi İngilizce alfabesinde sayı olarak ele alın (böylece a1 bolur, 2 zolur, 26 olur vb.) Ve kopyalar da dahil olmak üzere hepsinin çift olarak eşleşip eşleşmediğini kontrol edin .

Giriş tam olarak küçük harflerle yazılmış bir İngilizce harftir. Çıktı, kelimenin gizli olması gerçeğidir: herhangi bir doğruluk / falsey değeri, ancak bunların sadece iki çeşidi. Standart boşluklar yasaktır.

Test senaryoları:

• man: True
• day: True(Ørjan Johansen sayesinde)
• led: False( l=12ve d=4var gcd=4)
• mana: True( abirden çok kez olsa da , 1 ve 1 kopyadır)
• mom: False( gcd(13,13)=13))
• of: False(xnor sayesinde; ama 15∤6, gcd(15,6)=3)
• a: True(bir çift harf yoksa, kelimeye aynı zamanda eşik gibi davran)

Bu bir kod golf , bu yüzden bayt içindeki en kısa kod kazanır!

Wolfram Dili (Mathematica) , 36 bayt

CoprimeQ@@LetterNumber@Characters@#&

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 33 bayt

• Bu üç baytlık kısa versiyon için Misha Lavrov'a teşekkürler .

CoprimeQ @@ (ToCharacterCode @ # - 96) ve

Çevrimiçi deneyin!

Jöle , 10 bayt

ØaiⱮgþ`P$Ƒ

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Çok basit: dizeyi bir sayı listesine dönüştürür ve ardından ürünün LCM'ye eşit olup olmadığını kontrol eder.

Pyth , 9 bayt

{Ism{PhxG

Test odası

{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 Jelly'den daha mı geçti?}

Python 2-121 118 bayt

@JonathanAllan sayesinde -4 bayt

Bu dürüst korkunç, ama bunu göndermek için çok uzun zaman geçirdim.

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)

Çevrimiçi Deneyin

05AB1E , 11 bayt

Ç96-2.Æ€¿PΘ

Çevrimiçi deneyin!

açıklama

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

ạ{-₉₆ḋd}ᵐc≠

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Temel olarak, (girişteki bazı çiftler eş-birincil değildir) yalnızca ve yalnızca (girişlerden birden fazlasını bölen i> 1 sayısı varsa).

Python 3 , 61 59 bayt

Python baytlarını argüman olarak kullanma:

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

Kontrol edilecek son bölen 23, 26'nın altındaki en büyük başbakan.

Çevrimiçi deneyin!

@Dennis'e iki bayt kaydettiği için teşekkürler.

Perl 6 , 34 32 bayt

Nwellnhof sayesinde -2 bayt

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

Çevrimiçi deneyin!

Bir dize alan ve True veya False döndüren anonim bir kod bloğu. Harflerin en küçük ortak katı, ortak bölenleri paylaşmadıklarından, harflerin çarpımına eşitse.

Açıklama:

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

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

Ungolfed

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

açıklama

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 60 bayt

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

Çevrimiçi deneyin!

• Fikrini kullanarak Buffergelen Shieru Asakoto 'ın yazı .
• Arnauld sayesinde 5 bayt kurtardı.

Jöle , 11 bayt

ŒcO_96g/€ỊẠ

Çevrimiçi deneyin!

• Dennis'e booleans'ımı not ettiği için teşekkürler

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

96-YF&fdA&

Aksi halde 1, coprime için çıktılar 0.

Çevrimiçi deneyin!Veya tüm test senaryolarını doğrulayın .

açıklama

'man'Örneğin girişi düşünün .

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 algoritması tarafından yorumlandığı gibi Emain ( 474 484 463 bayt, 76 78 76 kuralları)

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

İlk 17 kural, "bileşik harfleri" çokluklarını göz ardı ederek "ana harf" faktörlerine dönüştürür. (Örneğin,tbe 2 gücünün ve 5 gücünün bir ürünü olarak 20 faktör olur .)

Sonraki 36 kural (örneğin cb->bc) ortaya çıkan ana faktörleri sıralar.

Sonraki 9 kural (örneğin bb->F) tekrarlanan bir asal çarpanı değiştirir , kalan 9 harften Fdaha fazla kural (örneğin b->) kaldırılır.

Bu noktada, boş bir dizemiz veya bir veya daha fazla Fs ->!Tdizemiz var ve son kural !Tbaşında bir a ekliyor . Sonra kurallar FF->Fve TF->Fya sonucu basitleştirmek !Tveya !F. Bu noktada, !->.kural kurtulmamızı !ve durmamızı söyler : Tbir gizli kelime için geri dönme , Faksi takdirde.

(Önceki sürümde bu kodun girişte boş bir dize vermesine neden olan bir hatayı işaret ettiği için bodqhrohro'ya teşekkürler a.)

Python 3 , 90 89 bayt

Numbermaniac tarafından -1 bayt

f=lambda q,*s:s==()or all(math.gcd(ord(q)-96,ord(w)-96)<2for w in s)and f(*s)
import math

Çevrimiçi deneyin!

Olarak kullan f(*'man').

Retina 0.8.2 , 45 bayt

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

Çevrimiçi deneyin! Açıklama:

;

Her harf arasına ve başlangıcına ve sonuna ayırıcılar ekleyin.

{`\w
#$&

#Her harfe bir a ekleyin .

}T`l`_l

aS harflerini silerek her harfi 1 alfabeye geri taşıyın . Ardından, tüm harfler silinene kadar yukarıdaki işlemleri tekrarlayın. Bu, her harfi tek başına 1 tabanlı alfabe dizinine dönüştürür.

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

İki değerin 1'den büyük ortak bir faktör paylaşıp paylaşmadığını test edin. (Bu, örneğin kelimede ortak faktörlü birden fazla harf bulabilir yearling.)

^0

Ortak faktör bulunmadığından emin olun.

R + pracma kütüphanesi, 75 bayt

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

Bu gcdişlevipracmaKütüphanemdeki R bunun için bir yerleşik yok. GDS'lerin ürününü sayılarla karşılaştırma yaklaşımını kullanıyorum.

65 bayt (kredi: @ J.Doe)

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

Japt , 14 bayt

;à2 e_®nR+CÃrj

Çevrimiçi deneyin!

Girişi bir karakter dizisi olarak alır.

Nasıl çalışır

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

Yakut , 56 bayt

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

Çevrimiçi deneyin!

Java 10, 86 bayt

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 @Vincent 'in Python 3 cevap .

Çevrimiçi deneyin.

Açıklama:

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 bayt

Girişi karakter dizisi olarak alır.

®c uHÃà2 e_rj

Deneyin veya tüm test senaryolarını doğrulayın

q, 121111 bayt

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

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

Çevrimiçi deneyin!

Orijinal yaklaşım (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))

Çevrimiçi deneyin!

Stax , 16 bayt

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

Çalıştır ve hata ayıkla

açıklama

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

True için çıkışlar, 0 için false.

Muhtemelen sayı kısmına dönüştürme yapmanın daha iyi bir yolu var, ama işe yarıyor.

APL (NARS), 16 karakter, 32 bayt

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

Bu kullanım yöntemi diğer LCM () = × / kullanılan, hızlı ama giriş dizisi yeterli uzunsa taşma; diğer alternatif çözümler biraz daha yavaş:

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

aşağıda, yukarıdaki fonksiyonlardan 10 kat daha hızlı (veya +) görünüyor

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

Ben bu son tercih çünkü daha kolay, daha hızlı, güvenilir (çünkü daha az taşma olasılığı), yazmak daha kolay ve nasıl olması gerekir (bazı bayt daha fazla olsa bile ...)