在有传闻说Codegolf将会举办Rock-Paper-Scissors锦标赛时，您可以看看无方字的话题。由字母R，组成的单词如果不包含重复两次的序列P，S则是无平方的。也就是说，这个词不能写成

a x x b

其中a和b是任何长度的单词和x至少一个长度的字，所有制成的字母R，P，S。

任务

写生成的程序无平方的字母的字R，P，S长度的n其中数字1 <= n <= 10被作为输入。

例

例如，长度为3 的无平方字为

RPR，RSR，RPS，RSP，SPS，SRS，SRP，SPR，PRP，PSP，PSR，PRS

长度为4的是

RPRS，RPSR，RPSP，RSRP，RSPR，RSPS，PRPS，PRSR，PRSP，PSRP，PSRS，PSPR，SRPR，SRPS，SRSP，SPRP，SPRS，SPSR

并注意例如SPSP或PRPR不是正方形

规则

• 这是代码高尔夫球，最短的程序获胜，标准漏洞被关闭。
• 您可以打印单词或在内存中创建单词。
• 您的程序可以作为函数编写。

参考文献

维基百科条目上的无平方字

给定长度的无平方三进制字数在https://oeis.org/A006156中

相关：任意长度三进制Squarefree词

Ruby，39个字节

->n{(?P*n..?S*n).grep_v /[^RPS]|(.+)\1/}

这个效率低下的函数会生成所有长度为N的字符串，这些字符串按字母顺序位于N Ps和N Ss之间，然后过滤掉包含非RPS字符的绝大多数字符串。实际的squarefree检查仅使用Regexp后向引用：(.+)\1。

更多惯用的65个字节，在N = 10的合理时间内完成：

->n{%w[R P S].repeated_permutation(n).map(&:join).grep_v /(.+)\1/}

编辑：感谢GB节省了一个字节。

果冻，15 14字节

“RPS”ṗẆ;"f$$Ðḟ

在线尝试！

怎么运行的

“RPS”ṗẆ;"f$$Ðḟ  Main link. Argument: n

“RPS”ṗ          Cartesian power; yield all strings of length n over this alphabet.
            Ðḟ  Filterfalse; keep only strings for which the quicklink to the left 
                returns a falsy result.
           $      Monadic chain. Argument: s (string)
      Ẇ             Window; yield the array A of all substrings of s.
          $         Monadic chain. Argument: A
       ;"             Concatenate all strings in A with themselves.
         f            Filter; yield all results that belong to A as well.

视网膜，28字节

+%1`1
R$'¶$`P$'¶$`S
A`(.+)\1

在线尝试！

接受一元输入。

说明

+%1`1
R$'¶$`P$'¶$`S

这将生成所有由RPSlength 组成的字符串n。我们这样做的方法是我们重复替换1每一行中的第一行。让我们把这行看做是<1>，哪里<是比赛前的>一切，又是比赛后的一切（它们分别是$`和$'分别是regex替换语法，但看起来不太直观）。我们更换1用R>¶<P>¶<S，哪里¶有换行。所以这种替代的完整的结果居然是<R>¶<P>¶<S>，这是该行的三个副本，与1替换为R，P，S分别在三个副本。一旦所有1都被替换，该过程就停止。

A`(.+)\1

最后，我们简单地丢弃所有包含重复的行。

外壳，15 14字节

-1个字节感谢Zgarb！

fȯεfoE½QΠR"RPS

在线尝试！

构建正确长度的所有可能序列，并仅保留所有子字符串（空字符串除外）由两个不同的半部分组成的序列。

该死，我真的很想在这里击败果冻。

Mathematica，61个字节

""<>#&/@{"R","P","S"}~Tuples~#~DeleteCases~{___,x__,x__,___}&

在线尝试！

爪哇8，285个 277字节

import java.util.*;Set r=new HashSet();n->p("",((1<<3*n)+"").replaceAll(".","PRS"),n)void p(String p,String s,int n){int l=s.length(),i=0;if(l<1&&(s=p.substring(0,n)).equals(s.replaceAll("(.*)\\1","")))r.add(s);for(;i<l;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,l),n));}

尽管Java几乎总是很冗长，但在这种情况下，它绝对不是解决此类挑战的正确语言。用子字符串生成置换对性能不利且效率低下。

当然，可以打更多的球。

-8个字节，感谢@Jakob。

说明：

在这里尝试。（对于3个以上的测试用例，性能太差了，但是它确实可以在本地工作。）

import java.util.*;   // Required import for Set and HashSet

Set r=new HashSet();  // Result-Set on class-level

n->                   // Method with integer parameter and no return-type
  p("",((1<<3*n)+"").replaceAll(".","PRS"),n)
                      //  Get all permutations and save them in the Set
                      // End of method (implicit / single-line return-statement)

void p(String p,String s,int n){
                      // Separated method with 2 String & int parameters and no return-type
  int l=s.length(),   //  The length of the second input-String
      i=0;            //  Index-integer, starting at 0
  if(l<1              //  If the length is 0,
     &&(s=p.substring(0,n)).equals(s.replaceAll("(.*)\\1","")))
                      //  and it doesn't contain a repeated part:
    r.add(s);         //   Add it to the result-Set
  for(;i<l;           //  Loop (2) from 0 to `l`
    p(                //   Recursive-call with:
      p+s.charAt(i),  //    Prefix-input + the character of the second input at index `i`
      s.substring(0,i)+s.substring(++i,l),
                      //    and the second input except for this character
      n)              //    and `n`
  );                  //  End of loop (2)
}                     // End of separated method

Python 3中，97 96个字节

f=lambda n:{c+s for c in'RPS'*n for s in f(n-1)or{''}if all(k-s.find(c+s[:k])for k in range(n))}

返回一组字符串。

在线尝试！

朱莉娅0.6，65字节

!n=n>0?["$c"s for s=!~-n,c="RPS"if~ismatch(r"(.+)\1","$c"s)]:[""]

在线尝试！

Perl 5，37个字节

sub r{grep!/(.+)\1/,glob"{R,S,P}"x<>}

在线尝试！

函数返回平方自由字符串的数组。

解释：

的glob生成与长度R，S，＆P的所有组合等于输入。该grep语句将那些不是正方形的对象过滤掉。

R，97字节

cat((x=unique(combn(rep(c('p','r','s'),n),n<-scan(),paste,collapse='')))[!grepl("(.+)\\1",x,,T)])

在线尝试！

combn(rep(c('p','r','s'),n),n,paste,collapse='')计算所有n以字符数限制的字符串p，r，s，但遗憾的是许多重复（*），所以我们uniquify它，把那些符合该正则表达式(.+)\1使用Perl样式匹配，那么我们打印出结果的列表。

（*）从技术上讲，它一次生成3次重复生成3n字母的所有组合，然后将其应用于每个组合，而不是直接计算字符串，但这比（真正的笛卡尔积）要复杂得多。p,r,snpaste(..., collapse='')3^nexpand.grid

JavaScript（Firefox 30-57），69个字节

f=n=>n?[for(x of f(n-1))for(y of'RPS')if(!/(.+)\1/.test(y+=x))y]:['']

由于所有无平方词的子字符串也都是无平方的，因此可以递归进行检查。

Haskell，101 98字节

f n=[x:r|x:r<-mapM(\_->"RPS")[1..n],[x]#r]
h#t@(x:r)=h/=take(length h)t&&(h++[x])#r&&[x]#r
h#t=1<3

在线尝试！

JavaScript（ES6），93个字节

n=>[...Array(3**n)].map(g=(d=n,i)=>d?'RPS'[i%3]+g(d-1,i/3|0):'').filter(s=>!/(.+)\1/.test(s))

使用RPS数字将所有从0到3ⁿ的整数转换为（反向填充）以3 为底的整数，并将其过滤为无平方字。

朱莉娅88岁

f(n)=[filter(A->!ismatch.(r"(.+)\1",join(A)),Iterators.product(repeated("RPS",n)...))...]

没有什么花哨。

C＃/ LINQ，169

Enumerable.Range(0,(int)Math.Pow(3,n)).Select(i=>string.Concat(Enumerable.Range(1,n).Select(p=>"PRS"[(i/(int)Math.Pow(3,n-p))%3]))).Where(s=>!Regex.IsMatch(s,@"(.+)\1"))

必须有一个更好的方法来做到这一点:)

F＃143

let f n=[1..n]|>List.fold(fun l _->List.collect(fun s->["R";"P";"S";]|>List.map((+)s))l)[""]|>Seq.filter(fun x->not(Regex.IsMatch(x,"(.+)\1")))

k，56个字节

f:{$[x;(,/"RPS",/:\:f x-1){x@&~~/'(2,y)#/:x}/1_!x;,""]}

缺乏本地正则表达式使k一次落后于曲线。我采用了递归解决方案，因为实现它的字符是通过更简单的squarefree检查保存的。

$[ test ; if-true ; if-false ]

是k的三元运算符，这里我们对非零长度进行有趣的处理，如果要求输入零长度的单词，则返回一个空字符串。

(,/"RPS",/:\:f x-1)

取“ RPS”和所有n-1个长度的无平方字的笛卡尔乘积。，/：\：将右边的每个元素连接到左边，得到长度为3的数组，长度为n个数组。，/将其展平为长度为3n的数组。

{x@&~~/'(2,y)#/:x}

接受每个字符串的前n个字母，并将其与后n个字母进行比较，然后将数组缩小到仅不匹配的位置。因为我们知道之前的结果是无平方的，所以只有从第一个字符开始的子字符串才需要匹配-简化此处的检查值得实现递归的字符。最后，

/1_!x

将lambda应用于左侧的初始结果集，并在每个子字符串长度（从1到（字长）-1）之间进行迭代。！x生成从0到x-1的列表，然后1_删除第一个元素（因为0长度的子字符串将始终匹配）

牺牲一些字符，我们可以使用.zs进行自引用，而不是依赖函数名，并且不检查长度不超过n-1的子字符串，仅检查floor（n / 2）的性能。它在7700k上约120秒内找到了所有长度49个单词（其中有5207706个），超过了我遇到的免费32位k的4GB限制。

{$[x;(,/"RPS",/:\:.z.s x-1){x@&~~/'(2,y)#/:x}/1+!_x%2;,""]}

Python 2，99个字节

import re
f=lambda n:n and[c+s for c in'RPS'for s in f(n-1)if not re.search(r'(.+)(\1)',c+s)]or['']

在线尝试！