Đầu vào

Một chuỗi ký tự chữ và số s.

Đầu ra

Chuỗi ngắn nhất xảy ra chính xác một lần dưới dạng chuỗi con (liền kề) trong s. Sự xuất hiện chồng chéo được tính là khác biệt. Nếu có một vài ứng cử viên có cùng độ dài, bạn phải xuất tất cả chúng theo thứ tự xuất hiện. Trong thử thách này, chuỗi rỗng xuất hiện n + 1lần trong một chuỗi độ dài n.

Thí dụ

Hãy xem xét chuỗi

"asdfasdfd"

Chuỗi rỗng xảy ra 10 lần trong đó, vì vậy nó không phải là ứng cử viên cho sự xuất hiện duy nhất. Mỗi phòng trong số chữ "a", "s", "d", và "f"xảy ra ít nhất hai lần, vì vậy họ không phải là ứng cử viên trong hai. Các chuỗi con "fa"và "fd"chỉ xảy ra một lần và theo thứ tự này, trong khi tất cả các chuỗi con khác có độ dài 2 xảy ra hai lần. Do đó, đầu ra đúng là

["fa","fd"]

Quy tắc

Cả hai chức năng và chương trình đầy đủ đều được cho phép, và sơ hở tiêu chuẩn thì không. Định dạng chính xác của đầu ra là linh hoạt, trong lý do. Cụ thể, việc tạo ra không có đầu ra cho chuỗi trống là được phép, nhưng việc ném lỗi thì không. Số byte thấp nhất sẽ thắng.

Các trường hợp thử nghiệm

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

Bảng xếp hạng

Đây là bảng xếp hạng ngôn ngữ mà tôi đã hứa.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# 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>

Bình thường, 27 26 byte

&zhfTmf!/>zhxzYYm<>zkdUzUz

Hãy thử nó ở đây.

Lưu ý rằng do lỗi trong trình biên dịch trực tuyến, trường hợp chuỗi trống chỉ hoạt động chính xác trên phiên bản dòng lệnh, có thể được tìm thấy ở đây.

Bạn cũng có thể khắc phục lỗi bằng cách đưa ra một dòng mới làm đầu vào cho trình biên dịch trực tuyến.

Giải trình:

                                   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 byte

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)

Tìm các chuỗi sao cho lần xuất hiện đầu tiên từ bên trái giống như lần xuất hiện đầu tiên từ bên phải. Các +1trong rangelà để phù hợp với trường hợp chuỗi rỗng.

Bây giờ nếu chỉ có Python có .count()số lượng trùng khớp, thì điều này sẽ ngắn hơn một chút.

Toán học, 95 94 79 byte

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

StringCasesgiúp tôi có tất cả các chuỗi con có thể, Tallyvà Caseslọc ra những thứ xuất hiện nhiều hơn một lần vàMinimalBy tìm ra những thứ ngắn nhất.

GolfScript, 44 byte

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

Đưa đầu vào dưới dạng một chuỗi trên stdin và xuất ra theo cú pháp hai mảng: vd [["b"] ["c"]] . Bản demo trực tuyến

Mổ xẻ

: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

Điều này được sắp xếp sao cho không có trường hợp đặc biệt nào được yêu cầu cho chuỗi trống (mà tôi đã đưa vào làm trường hợp thử nghiệm trong bản demo trực tuyến được liên kết ở trên).

CJam, 52 43 40 byte

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

Đầu vào là chuỗi không có dấu ngoặc kép

Giải thích :

]]                                       "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";

Thí dụ:

asdfdfasddfdfaddsasadsasadsddsddfdsasdf

Đầu ra

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

Dùng thử trực tuyến tại đây

Scala, 120 byte

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

Tôi đã bắt đầu với 140 mà ít nhất đã phù hợp với một tweet.

(                                        // 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

Chỉnh sửa tìm kiếm thay vì indexOf, vì chuỗi đầu vào là chữ và số. Cảm ơn @IsmaelMiguel

Hàm đệ quy, tìm kiếm các chuỗi con bắt đầu với chiều dài 1 và đi lên.

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]

Ung dung và giải thích

 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
 }

Kiểm tra trong bảng điều khiển FireFox / FireBug

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

Đầu ra

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

Java, 168 176 233

Đây là một ví dụ vòng lặp lồng nhau khá cơ bản.

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

Hoặc dễ đọc hơn một chút :

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)

Để dùng nó:

f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"

Cung cấp cho:

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

Btw. Tôi ghét dòng cuối cùng của mã của tôi (lặp lại h y). Bất cứ ai có gợi ý để thoát khỏi nó?

J, 61 58 44 42 40 38 37 byte

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

Đây là một phiên bản được chia thành các thành phần riêng biệt của giải pháp:

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

• x #/. ytính toán cho từng yếu tố riêng biệt trong xtần suất xảy ra trong y. Nếu chúng ta sử dụng điều này như là y #/. y, chúng ta sẽ nhận được cho mỗi phần tử riêng biệt trong ysố của nó. Ví dụ, a #/. acho a =. 1 2 2 3 4 4sản lượng 1 2 1 2.
• 1 = ykiểm tra xem các mục ybằng 1. Ví dụ, 1 = a #/. asản lượng 1 0 1 0.
• u~là phản xạ của một động từ đơn âm u. Đây là, u~ ygiống như y u y. Như vậy, #/.~ ycũng giống như#/.~ y . Khi áp dụng cho một động từ dyadic, u~là thụ động của u. Đó là, x u~ ygiống nhưy u x . Chúng được sử dụng ở một vài nơi khác mà tôi không đề cập rõ ràng.
• ~. y là nub của y, một vectơ với các bản sao được loại bỏ. Ví dụ, ~. asản lượng 1 2 3 4.
• x # y ( bản sao ) chọn từ ycác mục tại các chỉ mục xcó chứa a 1.
• Như vậy (1 = y #/. y) # (~. y) tạo ra một vectơ của các phần tử ychỉ xuất hiện một lần. Trong ký hiệu ngầm, động từ này được viết là ~. #~ 1 = #/.~; Hãy gọi cụm từ này unqscho phần còn lại của lời giải thích.

• x ]\ ytạo ra một xbằng 1 + y - xmảng của tất cả infixes của vector ycó độ dàix . Chẳng hạn, 3 ]\ 'asdfasdfdsản lượng

  asd
  sdf
  dfa
  fas
  asd
  sdf
  dfd
  

• # y là số liệu của y, đó là số lượng phần tử trong y.

• u\ yáp dụng ucho từng tiền tố của y. Ngẫu nhiên, #\ ytạo ra một vectơ số nguyên từ 1đến #y.
• < y đặt y vào một cái hộp Điều này là cần thiết bởi vì các mảng không thể bị rách và chúng tôi tính toán một mảng các hậu tố có độ dài khác nhau; một mảng được tính là vô hướng.

• Do đó, (i. # y) <@:unqs@(]\) ytạo ra một vectơ của #ycác mảng được đóng hộp có độ dài k (với tất cả 0 k < #y) các kết hợp của y xảy ra chính xác một lần. Hình thức ngầm của động từ này là i.@# <@unqs@(]\) ]hoặc i.@# <@(~. #~ 1 = #/.~)@(]\) ]nếu chúng ta không sử dụng unqstên. Hãy gọi cụm từ này allsbsqcho phần còn lại của lời giải thích này. Ví dụ,allsbsq 'asdfasdfd' sản lượng:

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

• (#@> y) # ylấy từ vectơ của các mảng được đóng hộp ymà không trống.

• {. ylấy phần tử đầu tiên của vectơ y.
• > y lấy hộp ra khỏi y .
• Do đó, > {. (#@> y) # ymang lại mảng không rỗng đầu tiên được bỏ hộp từ vectơ của các mảng được đóng hộpy . Cụm từ này được viết bằng >@{.@(#~ #@>)ký hiệu ngầm.

• Cuối cùng, [: >@{.@(#~ #@>) allsbsqtập hợp các cụm từ trước đó allsbsqđể tạo ra một giải pháp cho vấn đề chúng ta có. Dưới đây là cụm từ đầy đủ với khoảng trắng:

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

Haskell, 135 byte

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 (Java regex về triển khai Oracle), 124

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

Đã thử nghiệm trên Groovy 2.4 + Oracle JRE 1.7. Regex nên hoạt động cho Java 6 đến Java 8, vì lỗi cho phép mã ở trên không hoạt động. Không chắc chắn cho phiên bản trước, vì có một lỗi nhìn phía sau trong Java 5 đã được sửa trong Java 6.

Regex tìm chuỗi ngắn nhất không có chuỗi con trùng lặp ở nơi khác, tại mọi vị trí trong chuỗi đầu vào. Mã bên ngoài đảm nhiệm việc lọc.

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

• Vì các chuỗi có thể chồng lên nhau, tôi bao quanh toàn bộ mọi thứ trong tầm nhìn phía trước (?=...).
• (.*?) tìm kiếm từ chuỗi con ngắn nhất
• (?=(.*)) chụp phần còn lại của chuỗi để đánh dấu vị trí hiện tại.
• (?<=^(?!.*\1(?!\2$)).*)là một mô phỏng của nhìn phía sau có chiều dài thay đổi, lợi dụng lỗi thực thi cho phép (?<=.*)vượt qua kiểm tra độ dài.

• (?!.*\1(?!\2$))chỉ cần kiểm tra rằng bạn không thể tìm thấy cùng một chuỗi con ở nơi khác. Việc (?!\2$)từ chối vị trí ban đầu nơi chuỗi con được khớp.

  Giới hạn của cấu trúc nhìn xung quanh bên ngoài không áp dụng cho cấu trúc nhìn xung quanh lồng nhau. Do đó, cái nhìn tiêu cực lồng nhau (?!.*\1(?!\2$))thực sự kiểm tra toàn bộ chuỗi, không chỉ đến ranh giới bên phải của cái nhìn phía sau.

Rebol, 136 byte

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]]]

Ung dung:

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]
    ]
]

Ví dụ sử dụng:

>> 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"]

Lưu ý Tôi cho rằng trung tâm của mã là cách findphần hoạt động. Hy vọng rằng điều này sẽ giúp giải thích ...

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

Haskell, 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 byte

sᶠ≡ᵍ~gˢlᵍt

Hãy thử trực tuyến!

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.

Mặc dù ᵍkhông tự nhiên sắp xếp theo giá trị mà nhóm đó theo, thay vào đó, sắp xếp các nhóm theo lần xuất hiện đầu tiên của mỗi giá trị, lần xuất hiện đầu tiên của mỗi độ dài sẽ theo thứ tự giảm dần. Tôi không chắc chắn 100% rằng bộ lọc duy nhất không thể làm hỏng điều này, nhưng tôi chưa nghĩ ra trường hợp thử nghiệm nào thất bại.

05AB1E , 10 byte

Œʒ¢}é.γg}н

Đầu ra không có gì cho một chuỗi rỗng.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Π          # 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)

Điều này tận dụng lợi thế của 05AB1E chỉ có 1giá trị trung thực và mọi thứ khác như falsey. Chuỗi con duy nhất ngắn nhất luôn được đảm bảo xảy ra chính xác một lần cho tất cả các chuỗi đầu vào có thể. (Đối với một chuỗi đầu vào chỉ chứa cùng một ký tự (nghĩa là aaaaa), chính chuỗi đầu vào là chuỗi con xảy ra chỉ một lần, do đó, kết quả là ["aaaaa"]. Đối với một chuỗi đầu vào có mẫu lặp lại (nghĩa là "abcabc"), vẫn có các chuỗi con duy nhất chỉ có các chuỗi con duy nhất xảy ra một lần ( ["abca","abcab","abcabc","bca","bcab","bcabc","ca","cab","cabc"]), vì vậy điều này sẽ dẫn đến ["ca"].)

Con trăn 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 byte

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

Hãy thử trực tuyến!

Phương thức cũ: 114 byte