вход

Буквенно-цифровая строка s.

Выход

Самая короткая строка, которая встречается ровно один раз как (непрерывная) подстрока в s. Перекрывающиеся события считаются различными. Если есть несколько кандидатов одинаковой длины, вы должны вывести их всех в порядке появления. В этом вызове пустая строка встречается n + 1раз в строке длины 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"]

Leaderboard

Вот список лидеров по языкам, который я обещал.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

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

Ищет такие строки, что первое вхождение слева совпадает с первым вхождением справа. Значение +1in 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"]

Попробуйте онлайн здесь

Скала, 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"]

Ява, 168 176 233

Вот довольно простой пример вложенного цикла.

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

Хаскелл, 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"]

Btw. Я ненавижу последнюю строку моего кода (повторение 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 4урожайности 1 2 1 2.
• 1 = yпроверяет, какие элементы yравны 1. Например, 1 = a #/. aурожайность 1 0 1 0.
• u~является рефлексивным монадического глагола u. Это так u~ yже, как y u y. Таким образом, так #/.~ yже, как #/.~ y. При применении к двоичному глагола, u~является пассивным из u. То x u~ yесть так же, как y u x. Они используются во многих других местах, которые я не упоминаю явно.
• ~. yявляется гвоздем из y, вектор с дубликатами удалены. Например, ~. aурожайность 1 2 3 4.
• x # y( копия ) выбирает из yэлементов по индексам, где xсодержится 1.
• Таким образом, (1 = y #/. y) # (~. y)создается вектор тех элементов, из yкоторых появляются только один раз. В молчаливом обозначении этот глагол записывается как ~. #~ 1 = #/.~; давайте назовем эту фразу unqsдля остальной части объяснения.

• x ]\ yсоздает массив всех инфиксов вектора длины xby . Например, урожайность1 + y - xyx3 ]\ '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штучных массивов длины k (для всех 0 ≤ k < #y) инфиксов 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занимает первый элемент вектора 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 (Java regex для реализации Oracle), 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]]]

Ungolfed:

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

NB. Я полагаю, суть кода в том, как работает эта 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

Брахилог , 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 байт