Введение

Согласно сообщению Рэнда Аль'Тора в «Загадочной SE», под словом «сплоченный» подразумевается любое слово, которое содержит три буквы в алфавитном порядке (в любом порядке).

Такие слова, как образование , фогхорн и кабаре , считаются сплоченными словами, тогда как такие слова, как обучение , клаксон и исполнение , не являются сплоченными словами.

Вызов

Задача состоит в том, чтобы написать код-программу, способную принимать одно слово в качестве входных данных (предполагаемый нижний регистр, для всех намерений и целей) и возвращать вывод, который (если имеется) перечисляет все последовательные наборы букв (также в нижнем регистре), если он является сплоченным словом и пустым выводом, если это не сплоченное слово.

Примеры

Input: education
Output: cde

Input: foghorn
Output: fgh

Input: cabaret
Output: abc

Input: hijacking
Output: ghi, hij, ijk

Input: pneumonia
Output: mno, nop

Input: klaxon
Output: <<no output>>

Input: perform
Output: <<no output>>

Input: learning
Output: <<no output>>

правила

1. Принимая во внимание, что ввод должен считаться одним словом в нижнем регистре, а вывод должен быть в нижнем регистре, характер вывода будет варьироваться в зависимости от выбора языка кодирования. Пожалуйста, выберите форму вывода, которая наилучшим образом соответствует характеру задачи, будь то STDOUT, вывод файла, массив и т. Д.
2. Поскольку это код-гольф, это будет случай, когда наименьшее количество байтов будет явным победителем.
3. Никаких глупых лазеек .
4. Я не приму ответы с последовательными буквами в не алфавитном порядке ... Так cabчто, например, не будет считаться подходящим выводом cabaret.
5. Особое примечание: хотя «триплеты» не обязательно должны быть в алфавитном порядке, но символы в триплетах должны быть ... так что в случае слова «производительность», например, выходные данные mno,nopбудут приняты, как будет nop,mno. В случае слова «угон», есть шесть способов , что тройки ghi, hijи ijkмогут быть организованы в виде списка, а все шесть перестановок являются приемлемыми в качестве выходного сигнала.

Кроме этого, по твоим оценкам, садись, гольф!

05AB1E , 7 6 5 байт

Код:

3ãAŒÃ

Объяснение:

3ã      # Cartesian product × 3 with input
  AΠ   # All substrings of the alphabet
    Ã   # Setwise intersection

Использует кодировку CP-1252 . Попробуйте онлайн!

Python 3.5, 68 байт

w=input()
a=0
while 1:s='%c'*3%(a,a+1,a+2);a+=1;{*s}-{*w}or print(s)

Печатает выходные строки и завершается с ошибкой, когда значение символа становится слишком большим.

Создает все строки из трех последовательных строк и печатает те, которые являются подмножеством входного слова.

Pyth - 11 10 8 7 байт

Метод супер грубой силы.

@^z3.:G

Тестовый пакет .

@            Setwise intersection, finds common strings between the two lists
 ^           Cartesian product
  z          Input
  3          Of length 3
 .:          Substrings. Without second input finds all substrings which is ok
  G          Lowercase aphabet

Желе , 7 байт

ØaẆfṗ3$

Это монадическая ссылка. Попробуйте онлайн!

Как это работает

ØaẆfṗ3$  Monadic link. Argument: s (string)

Øa       Yield the lowercase alphabet, i.e., a := "abcdefghijklmnopqrstuvwxyz".
  Ẇ      Window; yields all substrings of a.
      $  Combine the two links to the left into a monadic chain.
    ṗ3   Take the third Cartesian power of s, yielding all combinations of three
         characters that can be formed from the letters in s.
   f     Filter; keep only those substrings of a that appear in the Cart. power.

JavaScript (ES6), 95 90 байт

f=
s=>[...s].map(c=>a[parseInt(c,36)]=c,a=[])&&a.map((c,i)=>c+a[i+1]+a[i+2]).filter(c=>!c[3])
;

<input oninput="o.textContent=f(this.value).join`, `"><div id=o>

Пропущенные значения объединяются как undefined, поэтому результирующая строка содержит более 3 символов. Я позаимствовал !c[3]уловку из @ETHproductions, чтобы сохранить 5 байтов.

Python 3.5, 78 байт

s={*input()}
for c in s:o=ord(c);a=chr(o-2);b=chr(o-1);s>{a,b}and print(a+b+c)

PHP, 100 байт

for($a="abc",$i=98;$i<123;$a=substr($a,1).chr(++$i))if(strstr(count_chars($argv[1],3),$a))echo"$a,";

принимает входные данные в качестве аргумента командной строки; печатает запятую беги с -r.

C 175 174 байта

main(_,a,m,n)char**a;{char*s=a[1],*t=s;while(*++s)while(s>t&&(n=s[-1])>=*s){m=(*s^n)?*s:0;*s=n;*--s=m;!*t&&++t;}for(;t[1]&t[2];++t)*t==t[1]-1&&*t==t[2]-2&&printf("%.3s ",t);}

отступ:

main(_,a,m,n)char**a;
{
  char*s=a[1],*t=s;
  while(*++s)
    while(s>t&&(n=s[-1])>=*s){
      m=(*s^n)?*s:0;
      *s=n;
      *--s=m;
      !*t&&++t;
    }
  for(;t[1]&t[2];++t)
    *t==t[1]-1&&*t==t[2]-2&&printf("%.3s ",t);
}

Выполняя сортировку, она заменяет дублирующиеся значения на 0, эти 0 сортируются в начало слова. Поиск последовательных значений тогда тривиален.

MATL , 13 байт

2Y23YCtjmAZ)!

Попробуйте онлайн!

2Y2    % Push string of lowercase alphabet
3YC    % 2D char array with sliding blocks of size 3, each on a column
t      % Duplicate
j      % Take input
m      % Member function: true for elements of the 2D array that are in the input
A      % All: true for columns that consist of all true values
Z)     % Use as logical index into the columns of the 2D char array
!      % Transpose. Implicitly display

Haskell, 48 байтов

f w=filter(all(`elem`w))[take 3[c..]|c<-['a'..]]

Генерирует все тройки из трех последовательных символов, принимает те, которые используют только буквы на входе.

53 байта:

f w=filter(all(`elem`w))[[pred$pred c..c]|c<-['c'..]]

Список ['c'..]содержит все символы 'c'Юникода начиная с. Понимание списка [[pred$pred c..c]|c<-['c'..]]превращает их во все строки из 3-х последовательных символов и "abc"далее. Мы делаем шаг назад, [pred$pred c..c]а не вперед, [c..succ$succ c]чтобы избежать ошибки при приеме преемника самого высокого символа юникода.

Эти тройки фильтруются для тех, которые используют только буквы на входе.

Perl, 36 байт

Включает +1 для -n

Внесите свой вклад в STDIN:

perl -nE 'join("",a..z)=~/[$_]{3}(?{say$&})^/' <<< "hijacking"

Просто код:

join("",a..z)=~/[$_]{3}(?{say$&})^/

T-SQL, 153 байта

Пришлось отреагировать на комментарий от WallyWest, так как это было давно с момента последнего ответа TSQL. Ответ был частично вдохновлен ответом Брайана Дж.

Golfed:

USE MASTER
DECLARE @ varchar(max)='hijacking'

;WITH C as(SELECT distinct ascii(substring(@,number,1))z FROM spt_values)SELECT CHAR(C.z)+CHAR(D.z)+CHAR(E.z)FROM C,C D,C E WHERE c.z+1=d.z and d.z=e.z-1

скрипка

Ungolfed:

USE MASTER -- can be left out if the master database is already being used
DECLARE @ varchar(max)='hijacking'

;WITH C as
(
  SELECT distinct ascii(substring(@,number,1))z
  FROM spt_values
)
SELECT CHAR(C.z)+CHAR(D.z)+CHAR(E.z)
FROM C,C D,C E
WHERE c.z+1=d.z and d.z=e.z-1

Haskell, 63 60 52 байта

f w=[x|x<-take 3<$>scanr(:)"_"['a'..],all(`elem`w)x]

Пример использования: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]строит список с хвостами список всех Юникода символов , начиная с 'a'и позволяет ему закончить с '_', то есть ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Затем мы берем до трех символов каждой строки и привязываем ее к x. Храните все, xгде каждая буква находится во входном параметре w.

Редактировать: @xnor сохранил 3 7 байтов. Благодарность!

T-SQL (SQL Server 2014), 217 байт

Golfed

declare @ table(a char)declare @i int=1while @i<=len(@a)begin insert into @ values(SUBSTRING(@a,@i,1))set @i+=1 end select distinct t.a+u.a+v.a from @ t,@ u,@ v where ASCII(t.a)+1=ASCII(u.a)and ASCII(u.a)+1=ASCII(v.a)

использование

Сначала объявите переменную @a в виде какого-либо символа и назначьте входные данные примерно так:

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Я не считал объявление как часть моего кода, но я не нашел стандарт SQL для ввода, поэтому я готов изменить свой счет

Выходными данными будет либо одна строка для каждой тройки, либо не будет строк, если слово не близко сплетено

Ungolfed

declare @temp table ( letter char(1) ) -- table to hold each letter of the word

declare @i int = 1

while @i <= len(@input) -- split each letter, and each row in @temp will have one letter
begin
    insert into @temp values (SUBSTRING(@input, @i, 1))
    set @i = @i + 1
end

-- join the letters table to itself to get three letter triples, where the three are in adjacent increasing order
-- use distinct because there might be duplicates in the word
select distinct t1.letter + t2.letter + t3.letter
from @temp t1
cross apply @temp t2
cross apply @temp t3
where ASCII(t1.letter) + 1 = ASCII(t2.letter)
and ASCII(t2.letter) + 1 = ASCII(t3.letter)

R 220 байт

Мое решение довольно простое. Он просматривает возможные комбинации из трех букв, просматривает и проверяет символы введенной строки по трем последовательным буквам и добавляет их в строку. Строка печатается только тогда, когда найдено три буквы (c == 4).

f<-function(w){if(nchar(w)>2){for(i in 1:24){
c<-1
t<-""
for(k in 1:3){for(j in 1:nchar(w)){if(substr(w,j,j)==intToUtf8(95+k+i)&c<4){
t<-paste(t,substr(w,j,j),sep="")
c<-c+1
break
}}}
if(c==4){print(paste(t))}}}}

ввод, вывод

> f("education")
> [1] "cde"
> > f("foghorn")
> [1] "fgh"
> > f("cabaret")
> [1] "abc"
> > f("hijacking")
> [1] "ghi"
> [1] "hij"
> [1] "ijk"
> > f("pneumonia")
> [1] "mno"
> [1] "nop"
> > f("klaxon")
> > f("perform")
> > f("learning")
> > 

Python 3.5, 114 111 88 80 79 байтов:

lambda X,W=[*map(chr,range(65,91))]:[i*({*X}>={*i})for i in zip(W,W[1:],W[2:])]

Анонимная лямбда-функция. Принимает ввод в виде строки в верхнем регистре и выводит массив кортежей, причем те, которые заполнены тремя заглавными буквами, представляют все наборы 3последовательных букв, которые появляются во вводе. Например,

[(), (), (), (), (), (), ('G', 'H', 'I'), ('H', 'I', 'J'), ('I', 'J', 'K'), (), (), (), (), (), (), (), (), (), (), (), (), (), ()]

будет выход для ввода HIJACKING. Этот формат вывода подтвержден OP. Таким образом, имеет единственный входной формат в верхнем регистре. Тем не менее, если вы хотите ввести в только в нижнем регистре, просто заменить range(65,91)с range(97,123), добавив еще один байт.

Repl.it со всеми тестовыми примерами!

Объяснение:

В основном, что здесь происходит:

1. Список, Wсоздается с использованием W=[*map(chr,range(65,91))], который содержит все заглавные буквы в английском алфавите. Из-за этого всегда требуется ввод заглавных букв .

2. Для каждого кортежа, iв списке, который мы будем называть U, содержащем все три последовательных кортежа букв, то есть:

   U=[('A','B','C'),('B','C','D'),('C','D','E'),...]
   

   создано zip(W,W[1:],W[2:]), каждый iполностью добавляются в список вывода, пока все элементы в наборе версии i( {*i}) в заданной версии ввода X( {*X}), то есть {*X}>={*i}, то есть Xявляется надстройкой из i. В противном случае пустая версия i( ()) будет добавлена ​​в список.

3. Как только все кортежи пройдены с полностью добавленными совпадениями, список возвращается в качестве окончательного результата.

Скала, 59 байт

(s:Set[Char])=>'a'to'z'sliding 3 filter{_.toSet subsetOf s}

Ungolfed:

(s:Set[Char]) => ('a' to 'z').sliding(3).filter{threeChars => threeChars.toSet.subsetOf(s)}

Объяснение:

(s:Set[Char])=>             //define a function with a Set of Chars called s as an argument
'a' to 'z'                  //create a Range of characters 'a' to 'z'
sliding 3                   //create an Iterator(Seq(a, b, c), Seq(b, c, d), Seq(c, d, e), ... , Seq(x, y, z))
filter{_.toSet subSetOf s}  //keep only the triplets which are a subset of s

На самом деле, 13 байтов

Предложения по игре в гольф приветствуются. Попробуйте онлайн!

S3@╧`εj`M3úV∩

Ungolfing

                Implicit input string s.
S               sorted(s).
 3@╧            Push all length-3 combinations of s.
    `εj`M       Join all of those combinations into single strings.
         3úV    Push all slices of the lowercase alphabet of length 1 <= n <= b
            ∩   Push the intersection of the combinations and slices.
                Implicit return.

Java 7, 230 байт

String c(char[]q){java.util.Arrays.sort(q);char a[]=new String(q).replaceAll("(.)\\1","$1").toCharArray(),c=97,i=2;String r="",z="",s;for(;c<'z';z+=c++);while(i<a.length)if(z.contains(s=""+a[i-2]+a[i-1]+a[i++]))r+=s+" ";return r;}

Скорее всего, это возможно, но задача оказалась намного сложнее, чем я думал в Java.

Ungolfed и тестовые случаи:

Попробуй это здесь.

class M{
  static String c(char[] q){
    java.util.Arrays.sort(q);
    char a[] = new String(q).replaceAll("(.)\\1", "$1").toCharArray(),
         c = 97,
         i = 2;
    String r = "",
           z = "",
           s;
    for(; c < 'z'; z += c++);
    while(i < a.length){
      if(z.contains(s = "" + a[i-2] + a[i-1] + a[i++])){
        r += s+" ";
      }
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("education".toCharArray()));
    System.out.println(c("foghorn".toCharArray()));
    System.out.println(c("cabaret".toCharArray()));
    System.out.println(c("hijacking".toCharArray()));
    System.out.println(c("pneumonia".toCharArray()));
    System.out.println(c("klaxon".toCharArray()));
    System.out.println(c("perform".toCharArray()));
    System.out.println(c("learning".toCharArray()));
    System.out.println(c("dblacghmeifjk".toCharArray()));
  }
}

Выход:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 байта

param($n)97..120|%{-join[char[]]($_,++$_,++$_)}|?{(-join([char[]]$n|sort|select -u))-match$_}

Чувствуется намного дольше, чем требуется, но я не могу играть в гольф дальше.

Принимает участие $n. Петли от 97до 120, построения смежных трехбуквенный строк - то есть, до |?, мы будем иметь abc, bcd, cdeи т.д. на трубопроводе. Затем это подается через Where-Object( |?), чтобы вытащить только те элементы, где условие истинно. Здесь, это предложение: 1) входная строка $n, приведенная как char-array, sorted и select -unique'd, затем отредактированная -joinобратно в строку, 2) -matched против трехбуквенных строк (т. Е. Сопоставление с регулярным выражением). Если это совпадение, то в слове есть трехбуквенная строка, и поэтому она фильтрует через |?. Результаты остаются на конвейере, а вывод неявным.

Примеры

(Обратите внимание, что здесь выходные данные разделены пробелами, так как мы структурируем выходные данные конкатенацией.)

PS C:\Tools\Scripts\golfing> 'education','foghorn','cabaret','hijacking','pneumonia','klaxon','perform','learning'|%{"$_ -> "+(.\close-knit-words.ps1 $_)}
education -> cde
foghorn -> fgh
cabaret -> abc
hijacking -> ghi hij ijk
pneumonia -> mno nop
klaxon -> 
perform -> 
learning -> 

Retina, 106 56 байт

D`.
O`.
^
abc¶
{`^(.*)¶.*\1.*
$0¶$1
}T`_l`l;`^.*
2`.*¶?

Дублировать, Сортировать. Добавить abc. Найдите, найдена ли подстрока, и добавьте, если так. Перевести на следующую подстроку. Повторение. Затем удалите первые две строки.

Попробуйте онлайн

Наивное решение:

D`.
O`.
!&`abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz

Дедуплицируйте, сортируйте, затем выводите совпадающие совпадения из 3 последовательных букв.

Попробуйте онлайн

JavaScript (Firefox 48), 93 байта

x=>[for(c of a=[...new Set(x,i=0)].sort())if(parseInt(d=c+a[++i]+a[i+1],36)%1333==38&!d[3])d]

Это подходит для 96-байтовой версии ES6 :

x=>[...new Set(x)].sort().map((c,i,a)=>c+a[i+1]+a[i+2]).filter(x=>!x[3]&parseInt(x,36)%1333==38)

Как это работает

Первый основной кусок функции это:

[...new Set(x)].sort()

new Set(string)создает объект Set, который содержит один из каждого уникального символа в строке. Например, new Set("foghorn")вернется Set ["f", "o", "g", "h", "r", "n"]. Мы можем преобразовать это в массив с [... ], а затем отсортировать его с помощью встроенного .sort(). Это превращается "foghorn"в ["f", "g", "h", "n", "o", "r"].

Следующий шаг - это:

.map((c,i,a)=>c+a[i+1]+a[i+2])

Это сопоставляет каждого cперсонажа в aряду с персонажем, соединенным с двумя предметами после него. Например, ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"]. ( undefinedS появляется, когда вы пытаетесь получить доступ к несуществующему члену массива.

Последний шаг - фильтрация:

.filter(x=>!c[3]&parseInt(x,36)%1333==38)

Во-первых, !c[3]&это исключить любые строки, которые содержат undefined. Это необходимо, потому что ошибка приводит к тому, что следующий алгоритм считается, например, gmundefinedкак последовательный триплет.

Все строки с тремя последовательными символами, если их интерпретировать как числа с основанием 36, равны 38 по модулю 1333. Я понял это с помощью следующего вычисления:

• 012 (база 36) = 38
• 123 (база 36) = 1371
• 1371 - 38 = 1333
• 1371 мод 1333 × 38 мод 1333 × 38

Следовательно, если строка из трех символов содержит 38 mod 1333 в base-36, эти три символа являются последовательными в алфавите.

Тестовый фрагмент

function test(x){O.innerHTML=/[^a-z]/.test(x)?"Invalid input":f(x);}
f=x=>[...new Set(x)].sort().map((c,i,a)=>c+a[i+1]+a[i+2]).filter(x=>!x[3]&parseInt(x,36)%1333==38)

<input id=I value="hijacked">
<button onclick="test(I.value)">Run</button>
<pre id=O>cde,hij,ijk</pre>

Ракетка 237 байт

(define(f s)(let((lr(λ(l i)(list-ref l i)))(l(sort(map char->integer(string->list s))<)))(for((i(-(length l)2)))
(when(=(-(lr l(+ i 2))(lr l(+ i 1)))1(-(lr l(+ i 1))(lr l i)))(for((j 3))(display(string(integer->char(lr l(+ i j))))))))))

Тестирование:

(f "education")

Выход:

cde

Подробная версия:

(define(f2 s)
  (let ((lr (λ(l i)(list-ref l i)))
        (l (sort (map char->integer (string->list s)) <)))
  (for ((i (-(length l)2)))
    (when (=  (- (lr l (+ i 2)) (lr l (+ i 1)))
              1
              (- (lr l (+ i 1)) (lr l i)))
      (for((j 3))
        (display (string(integer->char (lr l (+ i j))))))))))

Рубин , 50 байтов

each_cons(3)получает все последовательные подсписки длины 3 из алфавита ?a..?z, а затем использует e&s.chars==eдля выбора только те из них, у которых есть все символы в целевой строке, используя пересечение по ступеням. Возвращает список списков.

->s{(?a..?z).each_cons(3).select{|e|e&s.chars==e}}

Попробуйте онлайн!

[R], 110 байт

 f=function(b){a=combn(sort(utf8ToInt(b)),3);apply(unique(t(a[,which(apply(diff(a),2,prod)==1)])),1,intToUtf8)}

Я уверен, что он все еще пригоден для игры в гольф

Japt , 10 9 байт

;Cã3 fUá3

Попробуйте или запустите все тесты

;Cã3 fUá3     :Implicit input of string U
;C            :Lowercase alphabet
  ã3          :Substrings of length 3
     f        :Filter elements contained in
      Uá3     :Permutations of U of length 3