18

给定一个单词，将每个字母都当作英语字母中的数字（因此a变成1，b变成2，z变成26，依此类推），然后检查所有它们（包括重复项）是否都是成对的互质数。

输入的内容正好是一个小写英文字母的单词。如果单词是互质的，则输出为事实：任何真值/假值，但只有它们的两个变体。禁止出现标准漏洞。

测试用例：

man： True
day：（True感谢ØrjanJohansen）
led：False（l=12和d=4有gcd=4）
mana：（True尽管a多次出现，1和1是互质数）
mom：False（gcd(13,13)=13)）
of：False（感谢XNOR;虽然15∤6，gcd(15,6)=3）
a：（True如果没有成对的字母，也将该单词视为互素）

这是一个代码高尔夫球，因此以字节为单位的最短代码胜出！

— Bodqhrohro
source

1

0如果它们是互质的，我们可以输出1吗？

— dylnan

2

这本来是可以赶上的童车回答表明测试用例：day: True

— 与Orjan约翰森

1

我也建议of: False举一个错误的例子，其中没有值是另一个的倍数。

— xnor

@dylnan不，这是直觉的。无论如何，丹尼斯的答案更好；-)

— bodqhrohro

@LuisMendo任何真实/错误，但只有两个。

— bodqhrohro 18/09/27

12

Wolfram语言（Mathematica），36字节

CoprimeQ@@LetterNumber@Characters@#&

在线尝试！

Wolfram语言（Mathematica），33个字节

感谢Misha Lavrov提供的这三个字节的较短版本。

CoprimeQ @@（ToCharacterCode @＃-96）＆

在线尝试！

— 乔纳森·弗雷奇
source

1

CoprimeQ@@(ToCharacterCode@#-96)&短三个字节。

— Misha Lavrov

8

果冻，10字节

ØaiⱮgþ`P$Ƒ

在线尝试！

怎么运行的

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

— 丹尼斯
source

7

Haskell，48个字节

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

在线尝试！

非常简单：将字符串转换为数字列表，然后检查乘积是否等于LCM。

— Delfad0r
source

6

Pyth，9个字节

{Ism{PhxG

测试套件

说明：

{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）刚超越果冻吗？}}

— hakr14
source

6

Python 2-122 118字节

-4个字节，感谢@JonathanAllan

老实说这很糟糕，但是我花了很长时间才发布此消息。

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)

在线尝试

— 唐千
source

4

96 for〜> 96for; lambda x,y:x*y〜> int.__mul__。

— 乔纳森·弗雷希

5

05AB1E，11个字节

Ç96-2.Æ€¿PΘ

在线尝试！

说明

Ç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

— 艾米尼亚
source

决赛Θ真的有必要吗？

— Xcoder先生18年

@ Mr.Xcoder：不，我想不是。我只是假设我们需要使用2个Distict值，但现在看来，这没有什么挑战。那么Truthy / Falsy应该可以。

— Emigna

@Emigna我为此添加了一个澄清：输出值应该只有两个变体。

— bodqhrohro 18/09/27

@bodqhrohro：好的。我回滚到以前的版本以符合此新要求。

— Emigna

5

Brachylog，11个字节

ạ{-₉₆ḋd}ᵐc≠

在线尝试！

说明

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

— 双关1000
source

4

Python 2中，77个 68 64字节

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

在线尝试！

基本上，（且输入中的某对不是互质的）当且仅当（存在一个i> 1的数字对多个输入之一进行除法）时。

— 查斯·布朗
source

看起来我们有相同的想法，但是您击败了我几分钟:)您不能通过使用alland来保存那两个字节<2吗？

— 文森特

4

Python 3中，61 59个字节

使用python字节作为参数：

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

最后要检查的因数是23，是26以下的最大质数。

在线尝试！

感谢@Dennis节省了两个字节。

— 文森特
source

3

c%96%x<1for c in s节省2个字节。

— 丹尼斯

4

Perl 6的，34 32个字节

-2字节归功于nwellnhof

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

在线尝试！

接受字符串并返回True或False的匿名代码块。如果字母的最低公倍数等于字母的乘积，则它们不共享公因数。

说明：

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

— 乔·金
source

如果我没记错的话，这行得通吗？（21字节）

— Conor O'Brien

@ ConorO'Brien不，您刚映射a到0哈哈

— Jo King

@JoKing哦，好吧

— Conor O'Brien

测试用例表明，该策略存在问题day。

— 与Orjan约翰森

1

32个字节

— nwellnhof，

3

J，36个字节

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

不打高尔夫球

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

说明

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

在线尝试！

— 约拿
source

[:(1=[:*/+./~#&,~#\~:/#\)_96+a.&i.为34个字节，您在'1 ='中有一个空格:)

— Galen Ivanov '18

1

感谢@GalenIvanov

— 约拿（Jonah）

3

JavaScript（Node.js），60字节

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

在线尝试！

使用的想法Buffer从Shieru Asakoto的职位。
多亏了Arnauld，节省了5个字节。

— tsh
source

通过递归使用62个字节every(c=>c%32%v||n--,n=1)。

— Arnauld

@Arnauld谢谢。然后我又打了2个字节。

— tsh

3

果冻，11字节

ŒcO_96g/€ỊẠ

在线尝试！

感谢Dennis注意我的布尔值

Œ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

ỊẠ翻转布尔值。

— 丹尼斯

3

玛特，10字节

96-YF&fdA&

产出 10否则为coprime的。

在线尝试！要么验证所有测试用例。

说明

'man'例如考虑输入。

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

— 路易斯·门多
source

3

马尔可夫算法，如通过解释eMain（474个 484 463字节，76条 78 76规则）

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

前17条规则将“复合字母”纳入其“本字母”因素，而忽略了多重性。（例如，t变成be 20乘以2的幂和5的幂的乘积。）

接下来的36条规则（例如cb->bc）对所得的主要因子进行排序。

接下来的9条规则（例如bb->F）将替换为重复的素数F，然后再b->删除9条规则（例如），以消除剩余的单个字母。

此时，我们要么有一个空字符串，要么是一个或多个Fs 字符串，最后一条规则在开头->!T添加了一个!T。然后规则FF->F和TF->F简化的结果要么!T或!F。在这一点上，该!->.规则适用，告诉我们摆脱!并停止：返回T一个互质词，F否则返回。

（感谢bodqhrohro指出了早期版本中的一个错误，该错误导致该代码在输入时给出一个空字符串a。）

— 米莎·拉夫罗夫（Misha Lavrov）
source

1

给人既不T也不F对a测试用例。

— bodqhrohro 18/09/29

@bodqhrohro感谢您的收获！（最后，我的字节数减少了，因为我意识到我将每个换行符都计为两个字节。）

— Misha Lavrov

2

Python 3中，90 89个字节

-1字节按数字

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

在线尝试！

用作f(*'man')。

— 起泡器
source

2

视网膜0.8.2，45字节


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

在线尝试！说明：

在每个字母之间以及开头和结尾之间插入分隔符。

{`\w
#$&

前置一个#对每个字母。

}T`l`_l

将每个字母1移回字母表，删除as。然后重复上述操作，直到所有字母都被删除。这会将每个字母转换为其一进制的从1开始的字母索引。

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

测试是否有两个值共享一个大于1的公共因子。（这可以找到一对以上具有公共因子的字母，例如单词yearling。）

^0

检查没有发现共同因素。

— 尼尔
source

2

R + Pracma库，75个字节

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

据我所知，我正在使用库中的gcd函数，pracmaR对此没有内置函数。我正在使用将gcd的乘积与数字本身进行比较的方法。

65个字节（来源：@ J.Doe）

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

— jld
source

1

Japt，14个字节

;à2 e_®nR+CÃrj

在线尝试！

将输入作为字符数组。

怎么运行的

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

— 起泡器
source

1

红宝石，56个字节

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

在线尝试！

— 国标
source

1

Java 10，86个字节

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

@Vincent的Python 3答案端口。

在线尝试。

说明：

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

— 凯文·克鲁伊森
source

1

Japt，13个字节

将输入作为字符数组。

®c uHÃà2 e_rj

尝试或验证所有测试用例

— 毛茸茸
source

0

q，121111字节

{$[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]]}

— 陶菲基
source

0

JavaScript（Node.js），87 82字节

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

在线尝试！

原始方法（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))

在线尝试！

— 浅香诗人
source

0

Stax，16 个字节

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

运行并调试

说明

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

输出1为True，0为false。

可能存在一种更好的方法来转换为数字部分，但是它可以工作。

— 多
source

Stax作者在这里。感谢您尝试stax！这是一个使用您的算法的程序，可压缩到10个字节。 2SOF{96-F:!* 如果您想进一步了解，请告诉我。第一个是免费的！

— 递归

@recursive感谢您制作Stax！目前，这是我选择的高尔夫语言。我可以看到您的答案如何工作，将来我将不得不继续努力以改善我的答案。

— 多

0

APL（NARS），16个字符，32个字节

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

该使用方法还使用了LCM（）=×/的方法，它很快但是如果输入数组足够长就会溢出；其他替代解决方案稍微慢一点：

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

这似乎比上面的功能快10倍（或+）

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

我更喜欢这最后一个，因为它更容易，更快，更受信任（因为更少的溢出可能性），更容易编写以及它的方式（即使它还有更多字节...）

— 罗斯鲁普
source

coprime这个词是吗？

Wolfram语言（Mathematica），36字节

Wolfram语言（Mathematica），33个字节

果冻，10字节

怎么运行的

Haskell，48个字节

Pyth，9个字节

Python 2-122 118字节

05AB1E，11个字节

Brachylog，11个字节

说明

Python 2中，77个 68 64字节

Python 3中，61 59个字节

Perl 6的，34 32个字节

说明：

J，36个字节

不打高尔夫球

说明

JavaScript（Node.js），60字节

果冻，11字节

玛特，10字节

说明

马尔可夫算法，如通过解释eMain（474个 484 463字节，76条 78 76规则）

Python 3中，90 89个字节

视网膜0.8.2，45字节

R + Pracma库，75个字节

65个字节（来源：@ J.Doe）

Japt，14个字节

怎么运行的

红宝石，56个字节

Java 10，86个字节

Japt，13个字节

q，121111字节

JavaScript（Node.js），87 82字节

原始方法（87B）

Stax，16 个字节

APL（NARS），16个字符，32个字节