Вхідні дані

Буквено-цифровий рядок 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"]

Таблиця лідерів

Ось мовна таблиця мов, яку я пообіцяв.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон 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()підрахунок збігів, що збігаються , то це було б досить коротше.

Математика, 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"]

Ява, 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міститься a 1.
• Таким чином, (1 = y #/. y) # (~. y)створюється вектор тих елементів, yякі з’являються лише один раз. У мовчазних позначеннях це дієслово пишеться як ~. #~ 1 = #/.~; назвемо цю фразу unqsдля решти пояснень.

• x ]\ yстворює xна 1 + y - xмасив всіх Інфікси вектора yдовжини x. Наприклад, 3 ]\ '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 = #/.~)@(]\) ]
  

Хаскелл, 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 на впровадженні 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$))перевіряє всю нитку, а не лише до правої межі огляду.

Ребол, 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"]

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)

Це використовує переваги лише того 1, що 05AB1E має цінність, а все інше - фальси. Найкоротша унікальна підрядка завжди гарантується, що вона відбудеться один раз для всіх можливих рядків введення. (Для вхідного рядка, що містить лише ті самі символи (тобто aaaaa), сам рядок введення як підрядка виникає лише один раз, тому результат є ["aaaaa"]. Для введення-рядка з повторюваним шаблоном (тобто "abcabc"), все ще є унікальні підрядки, які лише виникають один раз ( ["abca","abcab","abcabc","bca","bcab","bcabc","ca","cab","cabc"]), тому це призведе до ["ca"].)

Пітон 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 байт