输入值

一个字母数字字符串s。

输出量

与中的（连续）子字符串完全匹配一次的最短字符串s。重叠出现被视为不同。如果有多个相同长度的候选者，则必须按出现顺序输出所有候选者。在此挑战中，空字符串的出现n + 1时间为length字符串n。

例

考虑字符串

"asdfasdfd"

空字符串在其中出现10次，因此它不是唯一出现的候选对象。每个字母"a"，"s"，"d"，和"f"至少出现了两次，所以它们不是候选人要么。子字符串"fa"和"fd"仅出现一次，并以该顺序出现，而其他所有长度为2的子字符串出现两次。因此正确的输出是

["fa","fd"]

规则

允许使用功能和完整程序，而不允许出现标准漏洞。在合理范围内，输出的确切格式是灵活的。特别是，不允许为空字符串生成任何输出，但不允许抛出错误。最低字节数获胜。

测试用例

"" -> [""]
"abcaa" -> ["b","c"]
"rererere" -> ["ererer"]
"asdfasdfd" -> ["fa","fd"]
"ffffhhhhfffffhhhhhfffhhh" -> ["hffff","fffff","hhhhh","hfffh"]
"asdfdfasddfdfaddsasadsasadsddsddfdsasdf" -> ["fas","fad","add","fds"]

排行榜

这是我所承诺的按语言排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>site = 'meta.codegolf',postID = 5314,isAnswer = true,QUESTION_ID = 45056;jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)<\\/code><\/pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Pyth，27 26字节

&zhfTmf!/>zhxzYYm<>zkdUzUz

在这里尝试。

请注意，由于在线编译器中的错误，空字符串大小写仅在命令行版本上才能正常工作，可以在此处找到。

您还可以通过换行作为在线编译器的输入来解决该错误。

说明：

                                   z = input(), implicit.
&z                                 Prints empty string if input is empty.
  hfT                              Take the first non-empty list from
     m                  Uz         A list of list of substrings of z, divided by length
                m<>zkdUz           with some shorter strings repeated later, to no effect.
      f                            Where the substrings are filtered on
       !/      Y                   There being 0 occurrences of the substring in
         >z                        The slice of z
           hxzY                    from the character after the first character
                                   of the first occurrence of the substring in z
                                   to the end of z.

Python 3中，124个 123 111 96字节

f=lambda s,n=1:[x for x in[s[i:i+n]for i in range(len(s)+1)]if s.find(x)==s.rfind(x)]or f(s,n+1)

查找字符串，使左起的第一个匹配项与右起的第一个匹配项相同。的+1在range以容纳空字符串的情况。

现在，如果只有Python的.count()算出有重叠的匹配项，那么这会短很多。

Mathematica，95 94 79字节

Cases[Tally@StringCases[#,___,Overlaps->All],{s_,1}:>s]~MinimalBy~StringLength&

StringCases获取所有可能的子字符串，Tally并Cases过滤掉那些不止一次出现的子串，并MinimalBy找到最短的子串。

GolfScript，44个字节

:S;-1:x{;S,x):x-),{S>x<}%:^1/{^\/,2=},.!}do`

将输入作为stdin上的字符串，并以双数组语法输出：例如[["b"] ["c"]]。在线演示

解剖

:S;          # Store input in S and pop it
-1:x         # Store -1 in x
{            # do-while loop
  ;          #   Pop x the first time and [] every subsequent time
  S,x):x-),  #   Increment x and build an array [0 1 ... len(S)-x]
  {S>x<}%    #   Map that array to [substr(S,0,x) substr(S,1,x) ...]
  :^         #   Store in ^ (to avoid the token coalescing with the next char)
  1/         #   Split by length 1 to iterate over 1-elt arrays rather than strings
  {^\/,2=},  #   Filter to arrays which occur exactly once as a subarray of ^
  .!         #   Duplicate and test emptiness
}do          # end do-while loop: loop if the filtered array is empty
`            # Stringify for output

这样安排的目的是使空字符串不需要特殊情况（我在上面链接的在线演示中已将它作为测试用例包括在内）。

CJam，52 43 40字节

]]q:Q,,{)Q,1$-),f{Q><}:R{R\a/,2=},}%{}=p

输入是不带引号的字符串

说明：

]]                                       "For empty string input case";
  q:Q                                    "Read the input and store in Q";
     ,,                                  "Take length of input and 0 to length array";
       {                          }%     "Map the above array on this code block";
        )Q                               "Increment the number in the current iteration, L";
         Q,1$                            "Take input's length and copy the above number";
             -)                          "Get upper limit of next loop to get substrings";
               ,f{   }                   "Get 0 to above number array and for each";
                  Q><                    "Get the L length substring at Ith index where";
                                         "I loops from 0 to Q, - L + 1";
                      :R                 "Store this list of substring of length L in R";
                        {R\a/,2=},       "Filter to get unique substrings";
                                    {}=  "Get the first non empty substring array";
                                         "This leaves nothing on stack if all are empty";
                                       p "Print the top stack element. At this point, its";
                                         "Either the first non empty substring array or";
                                         "the ]] i.e. [""] which we added initially";

例：

asdfdfasddfdfaddsasadsasadsddsddfdsasdf

输出量

["fas" "fad" "add" "fds"]

在这里在线尝试

Scala，120字节

readLine.inits.flatMap(_.tails).toList.groupBy(l=>l).filter(x=>x._2.length<2).map(_._1).groupBy(_.length).minBy(_._1)._2

我以140开头，至少已经适合推文了。

(                                        // added for comments
 readLine                                // input
.inits.flatMap(_.tails).toList           // get all substrings of that string
.groupBy(l=>l).filter(x=>x._2.length<2)  // remove substrings that occur more than once
.map(_._1).groupBy(_.length)             // take the substring and group by length
.minBy(_._1)._2                          // take the list of shortest substrings
)

的JavaScript（ES6），109 110

编辑搜索而不是indexOf，因为输入字符串是字母数字。谢谢@IsmaelMiguel

递归函数，查找从长度1开始且向上的子字符串。

F=(s,n=1,r)=>
s?[...s].map((a,i)=>~s.indexOf(a=s.substr(i,n),s.search(a)+1)?r:r=[...r||[],a])&&r||F(s,n+1):[s]

脱节和解释

 F = function(s, n=1) { // start with length 1
   var i, a, p, r;
   if (s == "") // special case for empty input string
     return [s];
   for (i = 0; i < s.length; i++) 
   // for each possibile substring of length n
   // (should stop at s.length-n+1 but going beyond is harmless)
   // Golfed: "[...s].map((a,i)" ... using i, a is overwrittem
   {
     a = s.substr(i, n); // substring at position i
     p = s.search(a); // p is the first position of substring found, can be i or less
     p = s.indexOf(a, p + 1) // p is now the position of a second instance of substring, or -1 if not found
     if (~p) // ~p is 0 if p is -1
     {
       ; // found more than once, do nothing
     }
     else
     {
       r = r || []; // if r is undefined, then it becomes an empty array
       r.push(a); // save substring 
       // Golfed: "r=[...r||[],a]"
     }
   }
   if (r) // if found some substring, saved in r
   {
     return r;
   }
   return F(s, n+1) // recursive retry for a bigger length
 }

在FireFox / FireBug控制台中 测试

;["", "abcaa", "rererere", "asdfasdfd", "ffffhhhhfffffhhhhhfffhhh", 
 "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"]
.forEach(x=>console.log(x,F(x)))

输出量

 [""]
abcaa ["b", "c"]
rererere ["ererer"]
asdfasdfd ["fa", "fd"]
ffffhhhhfffffhhhhhfffhhh ["hffff", "fffff", "hhhhh", "hfffh"]
asdfdfasddfdfaddsasadsasadsddsddfdsasdf ["fas", "fad", "add", "fds"]

爪哇168176233

这是一个非常基本的嵌套循环示例。

void n(String s){for(int l=0,i=0,t=s.length(),q=0;l++<t&q<1;i=0)for(String b;i<=t-l;)if(s.indexOf(b=s.substring(i,i+++l),s.indexOf(b)+1)<0){System.out.println(b);q++;}}

或位更具可读性：

void t(String s){
    for(int l=0,i=0,t=s.length(),q=0;l++<t&q<1;i=0)
        for(String b;i<=t-l;)
            if(s.indexOf(b=s.substring(i,i++ +l),s.indexOf(b)+1)<0){
                System.out.println(b);
                q++;
            }
}

Haskell，169 162 155 153 151 138 120 115

import Data.List
l=length
q k=filter$(==)k.l
p y=q(minimum.map l$y)$y
f x=p$concat$q 1$group$sort$(tails x>>=inits)

要使用它：

f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"

这使：

["add","fad","fas","fds"]

顺便说一句。我讨厌代码的最后一行（重复h y）。有人暗示要摆脱它吗？

J，61 58 44 42 40 38 37字节

[:>@{.@(#~#@>)#\<@(~.#~1=#/.~)@(]\)]

这是拆分为解决方案各个组件的版本：

unqs =. ~. #~ 1 = #/.~               NB. uniques; items that appear exactly once
allsbsq =. #\ <@unqs@(]\) ]        NB. all unique subsequences
shrtsbsq =. [: >@{.@(#~ #@>) allsbsq NB. shortest unique subsequence

• x #/. y计算每个不同元素在x中出现的频率y。如果将其用作y #/. y，则会得到y其计数中每个不同元素的。例如，a #/. a对于a =. 1 2 2 3 4 4yields 1 2 1 2。
• 1 = y检查的项y等于1。例如，1 = a #/. ayields 1 0 1 0。
• u~是单子动词的自反u。这u~ y与相同y u y。因此，#/.~ y与相同#/.~ y。当施加到一个二进动词，u~是被动 的u。即x u~ y与相同y u x。这些用于其他许多地方，我没有明确提及。
• ~. y是凸起的y，以除去重复项的向量。例如，~. ayields 1 2 3 4。
• x # y（副本）从y索引中的项目中选择，其中x包含一个1。
• 因此，(1 = y #/. y) # (~. y)创建一个矢量，这些矢量的元素y仅出现一次。动词用默认表示形式~. #~ 1 = #/.~；让我们将此短语unqs称为其余解释。

• x ]\ y创建length 向量的所有后缀的xby 1 + y - x数组。例如，收益yx3 ]\ 'asdfasdfd

  asd
  sdf
  dfa
  fas
  asd
  sdf
  dfd
  

• # y是相符的y，即，在元件的数量y。

• u\ y适用u于每个前缀的y。顺便说一句，#\ y创建一个从1到的整数向量#y。
• < y放y成箱。这是必需的，因为数组不能参差不齐，并且我们可以计算长度不同的后缀数组。装箱的数组算作标量。

• 因此，(i. # y) <@:unqs@(]\) y产生的向量#y长度的盒装阵列ķ（对于所有0≤ ķ < #y）的缀ý发生一次。该动词的默认形式为i.@# <@unqs@(]\) ]或i.@# <@(~. #~ 1 = #/.~)@(]\) ]不使用unqs名称。让我们将此短语allsbsq称为其余解释。例如，allsbsq 'asdfasdfd'收益：

  ┌┬─┬──┬───┬────┬─────┬──────┬───────┬────────┐
  ││ │fa│dfa│sdfa│asdfa│asdfas│asdfasd│asdfasdf│
  ││ │fd│fas│dfas│sdfas│sdfasd│sdfasdf│sdfasdfd│
  ││ │  │dfd│fasd│dfasd│dfasdf│dfasdfd│        │
  ││ │  │   │sdfd│fasdf│fasdfd│       │        │
  ││ │  │   │    │asdfd│      │       │        │
  └┴─┴──┴───┴────┴─────┴──────┴───────┴────────┘
  

• (#@> y) # y从盒装数组的向量中获取y不为空的那些。

• {. y接受vector的第一个元素y。
• > y从中删除该框y。
• 因此，> {. (#@> y) # y从装箱数组的向量产生未装箱的第一个非空数组y。该短语>@{.@(#~ #@>)以默认符号书写。

• 最后，[: >@{.@(#~ #@>) allsbsq将前面的短语与组合在一起，allsbsq以解决我们遇到的问题。这是带空格的完整短语：

  [: >@{.@(#~ #@>) i.@# <@(~. #~ 1 = #/.~)@(]\) ]
  

Haskell，135字节

import Data.List
f ""=[""]
f g=map(snd)$head$groupBy(\a b->fst a==fst b)$sort[(length y,y)|[y]<-group$sort[x|x@(_:_)<-tails g>>=inits]]

PHP，171 152 134 125

function f($s){while(!$a&&++$i<strlen($s))for($j=0;$b=substr($s,$j++,$i);)strpos($s,$b)==strrpos($s,$b)&&($a[]=$b);return$a;}

http://3v4l.org/RaWTN

Groovy（有关Oracle实现的Java正则表达式），124

c={m=it=~/(?=(.*?)(?=(.*))(?<=^(?!.*\1(?!\2$)).*))/;o=m.collect({it[1]});o.findAll({it.size()==o.min({it.size()}).size()});}

在Groovy 2.4 + Oracle JRE 1.7上进行了测试。正则表达式应该适用于Java 6到Java 8，因为允许上述代码运行的错误尚未修复。由于Java 5中存在一个在Java 6中已修复的回溯错误，因此不确定是否使用先前版本。

正则表达式会在输入字符串的每个位置找到最短的字符串，该字符串在其他位置没有重复的子字符串。外部代码负责过滤。

(?=(.*?)(?=(.*))(?<=^(?!.*\1(?!\2$)).*))

• 由于字符串可以重叠，因此我将整个内容提前存储(?=...)。
• (.*?) 从最短的子字符串中搜索
• (?=(.*)) 捕获字符串的其余部分以标记当前位置。
• (?<=^(?!.*\1(?!\2$)).*)是对可变长度后视的仿真，它利用允许(?<=.*)通过长度检查的实现错误。

• (?!.*\1(?!\2$))只需检查您在其他地方找不到相同的子字符串即可。的(?!\2$)拒绝，其中子串匹配原来的位置。

  外部环顾构造的限制不适用于嵌套环顾构造。因此，嵌套的否定前瞻(?!.*\1(?!\2$))实际上会检查整个字符串，而不仅仅是检查后瞻的右边界。

Rebol，136个字节

f: func[s][repeat n length? b: copy s[unless empty? x: collect[forall s[unless find next find b t: copy/part s n t[keep t]]][return x]]]

取消高尔夫：

f: func [s] [
    repeat n length? b: copy s [
        unless empty? x: collect [
            forall s [
                unless find next find b t: copy/part s n t [keep t]
            ]
        ][return x]
    ]
]

用法示例：

>> f ""       
== none

>> f "abcaa"
== ["b" "c"]

>> f "rererere"
== ["ererer"]

>> f "asdfasdfd"
== ["fa" "fd"]

>> f "ffffhhhhfffffhhhhhfffhhh"
== ["hffff" "fffff" "hhhhh" "hfffh"]

>> f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"
== ["fas" "fad" "add" "fds"]

注意 我认为代码的核心是该find部分的工作方式。希望这将有助于解释...

>> find "asdfasdfd" "df"
== "dfasdfd"

>> next find "asdfasdfd" "df"
== "fasdfd"

>> find next find "asdfasdfd" "df" "df"
== "dfd"

>> ;; so above shows that "df" is present more than once - so not unique
>> ;; whereas below returns NONE because "fa" found only once - ie. bingo!

>> find next find "asdfasdfd" "fa" "fa"
== none

哈斯克尔（119）

f s=[r|n<-[1..length s],l<-[map(take n)$take(length s-n+1)$iterate(drop 1)s],r<-[[j|j<-l,[j]==[r|r<-l,r==j]]],r/=[]]!!0

Brachylog，10个字节

sᶠ≡ᵍ~gˢlᵍt

在线尝试！

sᶠ            The list of every substring of the input
  ≡ᵍ          grouped by identity,
    ~gˢ       with length-1 groups converted to their elements and other groups discarded,
       lᵍ     and grouped by their length,
         t    has the output as its last group.

尽管ᵍ并不是自然地按分组的值排序，而是按每个值的第一个出现对组进行排序，但每个长度的第一个出现都是按降序排列的。我不是100％确信唯一性过滤不会弄乱这一点，但是我还没有提出一个失败的测试案例。

05AB1E，10 个字节

Œʒ¢}é.γg}н

空字符串不输出任何内容。

在线尝试或验证所有测试用例。

说明：

Π          # Get all substrings of the (implicit) input-String
 ʒ          # Filter it by:
  ¢         #  Count how many times the current substring occurs in the (implicit) input-String
            #  (only 1 is truthy in 05AB1E, so the filter will leave unique substrings)
   }é       # After the filter: sort the remaining substrings by length
     .γg}   # Then group them by length as well
         н  # And only leave the first group containing the shortest substrings
            # (which is output implicitly as result)

这利用了05AB1E仅具有1真实价值，而其他所有事物具有虚假价值的优势。对于所有可能的输入字符串，始终保证最短的唯一子字符串出现一次。（对于仅包含相同字符（即aaaaa）的输入字符串，输入字符串本身仅作为子字符串出现一次，因此结果为["aaaaa"]。对于具有重复模式的输入字符串（即"abcabc"），仍然存在唯一的子字符串，发生一次（["abca","abcab","abcabc","bca","bcab","bcabc","ca","cab","cabc"]），因此将产生["ca"]。）

python 2，150

import re
a=input()
r=range
l=len(a)
d=0
for i in r(l):
 if d:break
 for j in r(l-i):
  k=a[j:i+j+1]
  if len(re.findall("(?="+k+")",a))<2:d=1;print k

Perl 5中 -a，114个 87字节

map{//;(grep$' eq$_,@q)-1||($l||=y///c)-y///c||say}@q=map{"@F"=~/(?=(.{$_}))/g}1..y///c

在线尝试！

旧方法： 114个字节