Introdução

De acordo com o post de Rand Al'Thor no Puzzling SE, uma palavra muito unida é qualquer palavra que contenha três letras alfabeticamente consecutivas (em qualquer ordem).

Palavras como educação , foghorn e cabaré são consideradas palavras muito unidas, enquanto palavras como aprender , klaxon e performance não são palavras muito unidas.

Desafio

O desafio é codificar golfe um programa capaz de receber uma única palavra como entrada (em minúscula assumida, para todos os efeitos) e retornar a saída que (se disponível) lista todos os conjuntos de letras consecutivos (também em minúscula) se é uma palavra unida e saída vazia se não for uma palavra unida.

Exemplos

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

Regras

1. Enquanto a entrada deve ser assumida como uma única palavra em minúscula e a saída em minúscula, a natureza da saída varia de acordo com a escolha do idioma de codificação. Selecione uma forma de saída que melhor se adapte à natureza do desafio, seja STDOUT, saída de arquivo, matriz, etc.
2. Por se tratar de código-golfe, será o caso do menor número de bytes que será o vencedor.
3. Sem brechas tolas .
4. Não aceitarei respostas que tenham as letras consecutivas em ordem não alfabética ... Portanto cab, não será considerado uma saída adequada cabaret, por exemplo.
5. Nota especial, enquanto os "trigêmeos" não precisam necessariamente estar em ordem alfabética, mas os caracteres contidos nos trigêmeos devem estar ... portanto, no caso da palavra "desempenho", por exemplo, a saída mno,nopserá aceita, como vontade nop,mno. No caso da palavra "seqüestro", há seis maneiras que os trigêmeos de ghi, hije ijkpodem ser organizados em uma lista, e todas as seis permutações são aceitáveis como saída.

Fora isso, em suas marcas, prepare-se, golfe!

05AB1E , 7 6 5 bytes

Código:

3ãAŒÃ

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Python 3.5, 68 bytes

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

Imprime as seqüências de saída e termina com erro quando o valor do caractere fica muito grande.

Gera todas as seqüências de três consecutivas e imprime aquelas que são um subconjunto da palavra de entrada.

Pitão - 11 10 8 7 bytes

Método de força bruta super.

@^z3.:G

Conjunto de Teste .

@            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

Geléia , 7 bytes

ØaẆfṗ3$

Este é um link monádico. Experimente online!

Como funciona

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

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>

Valores ausentes concatenam como undefined, portanto, a sequência resultante contém mais de 3 caracteres. Peguei emprestado o !c[3]truque do @ETHproductions para economizar 5 bytes.

Python 3.5, 78 bytes

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 bytes

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

recebe entrada como argumento de linha de comando; imprime uma vírgula à direita. corra com -r.

C, 175 174 bytes

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

recuado:

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

Ao fazer a classificação, substitui valores duplicados por 0s, esses 0s são classificados no início da palavra. Procurar os valores consecutivos é então trivial.

MATL , 13 bytes

2Y23YCtjmAZ)!

Experimente online!

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 bytes

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

Gera todos os triplos de três caracteres consecutivos, pega aqueles que usam apenas letras na entrada.

53 bytes:

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

A lista ['c'..]contém todos os caracteres unicode a partir de então 'c'. A compreensão da lista os [[pred$pred c..c]|c<-['c'..]]transforma em todas as seqüências de caracteres de 3 caracteres consecutivos a partir de então "abc". Retrocedemos com em [pred$pred c..c]vez de avançar com [c..succ$succ c]para evitar um erro ao assumir o sucessor do caractere unicode mais alto.

Esses triplos são filtrados para aqueles que usam apenas letras na entrada.

Perl, 36 bytes

Inclui +1 para -n

Dê entrada no STDIN:

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

Apenas o código:

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

T-SQL, 153 bytes

Tive que reagir ao comentário do WallyWest, já que fazia muito tempo desde a última resposta do TSQL. A resposta foi parcialmente inspirada na resposta de Brian J

Golfe:

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

Violino

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 bytes

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

Exemplo de uso: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]cria uma lista com as caudas da lista de todos os caracteres unicode começando com 'a'e deixa terminar com a '_', ie ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Em seguida, pegamos até três caracteres de cada string e o vinculamos x. Mantenha tudo xonde todas as letras estão no parâmetro de entrada w.

Edit: @xnor salvou 3 7 bytes. Obrigado!

T-SQL (SQL Server 2014), 217 bytes

Golfe

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)

Uso

Primeiro, declare a variável @a como um caractere de algum tipo e atribua a entrada da seguinte maneira

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Não contei a declaração como parte do meu código, mas não encontrei um padrão sql para entrada, por isso estou disposto a alterar minha contagem

A saída será uma linha para cada triplo ou nenhuma linha se a palavra não estiver unida

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 bytes

Minha solução é bem direta. Ele percorre as três combinações possíveis de letras, percorre e verifica os caracteres da sequência inserida nas três letras consecutivas e as adiciona a uma sequência. A sequência é impressa apenas quando três letras são encontradas (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))}}}}

entrada / saída

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

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

Uma função lambda anônima. Recebe a entrada como uma sequência maiúscula e gera uma matriz de tuplas, com as preenchidas com três caracteres maiúsculos representando todos os conjuntos de 3letras consecutivas que aparecem na entrada. Por exemplo,

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

seria a saída para entrada HIJACKING. Este formato de saída foi confirmado como bom pelo OP. Então, tem o único formato de entrada em maiúsculas. No entanto, se você quiser inserir apenas letras minúsculas, substitua-as range(65,91)por range(97,123), adicionando mais um byte.

Repl.it com todos os casos de teste!

Explicação:

Basicamente, o que está acontecendo aqui é:

1. Uma lista, Wé criada usando W=[*map(chr,range(65,91))], que contém todas as letras maiúsculas no alfabeto inglês. Por esse motivo, sempre é necessária uma entrada em maiúscula .

2. Para cada tupla, iem uma lista que chamaremos U, contendo as três tuplas de letras consecutivas, ou seja:

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

   criado por zip(W,W[1:],W[2:]), cada um ié totalmente adicionado à lista de saída, desde que todos os elementos na versão definida de i( {*i}) estejam na versão definida de input X( {*X}), ou seja {*X}>={*i}, seja Xum superconjunto de i. Caso contrário, a versão vazia de i( ()) será adicionada à lista.

3. Depois que todas as tuplas forem concluídas com as correspondências totalmente adicionadas, a lista será retornada como saída final.

Scala, 59 bytes

(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)}

Explicação:

(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

Na verdade, 13 bytes

Sugestões de golfe são bem-vindas. Experimente online!

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 bytes

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

Provavelmente isso pode ser jogado, mas o desafio foi muito mais difícil do que eu pensava em Java ..

Casos não testados e de teste:

Experimente aqui.

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()));
  }
}

Saída:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 bytes

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

Parece muito mais tempo do que o necessário, mas não consigo jogar mais.

Recebe entrada $n. Loops de 97a 120, construindo cadeias de três letras contíguas - ou seja, até o |?, teremos abc, bcd, cde, etc. no pipeline. Então, isso é alimentado por um Where-Object(the |?) para retirar apenas os itens em que a cláusula é verdadeira. Aqui, a cláusula é 1) a string de entrada $n, convertida em char-array, sorted e select -unique'd, depois -joined de volta em uma string, 2) -matched contra as strings de três letras (ou seja, correspondência de expressões regulares). Se for uma correspondência, a sequência de três letras estará na palavra e será filtrada através do |?. Os resultados são deixados no pipeline e a saída está implícita.

Exemplos

(Observe que aqui a saída é separada por espaço, pois estamos restringindo a saída por concatenação.)

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 bytes

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

Desduplicar, Classificar. Adicionar abc. Descubra se a substring foi encontrada e, se houver, acrescente. Traduzir para a próxima substring. Repetir. Em seguida, remova as duas primeiras linhas.

Experimente online

Solução ingênua:

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

Desduplicar, Classificar e gerar correspondências sobrepostas de 3 letras seqüenciais.

Experimente online

JavaScript (Firefox 48), 93 bytes

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]

Isso se presta a uma versão ES6 de 96 bytes :

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)

Como funciona

O primeiro pedaço principal da função é este:

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

new Set(string)cria um objeto Set que contém um de cada caractere exclusivo na string. Por exemplo, new Set("foghorn")retornará Set ["f", "o", "g", "h", "r", "n"]. Podemos converter isso em um array com [... ], e depois classificá-lo com o incorporado .sort(). Isso se "foghorn"transforma ["f", "g", "h", "n", "o", "r"].

O próximo passo é este:

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

Isso mapeia cada personagem cno araio para o personagem concatenado com os dois itens depois. Por exemplo ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"],. (Eles undefinedaparecem quando você tenta acessar um membro inexistente da matriz.

A etapa final é filtrar:

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

Primeiro, !c[3]&é excluir todas as strings que contêm undefined. Isso é necessário porque um bug faz com que o seguinte algoritmo conte, por exemplo, gmundefinedcomo um trigêmeo consecutivo.

Todas as seqüências de caracteres de três caracteres consecutivos, quando interpretadas como números de base 36, são 38 módulo 1333. Descobri isso pelo seguinte cálculo:

• 012 (base 36) = 38
• 123 (base 36) = 1371
• 1371 - 38 = 1333
• 1371 mod 1333 ≡ 38 mod 1333 ≡ 38

Portanto, se uma sequência de três caracteres for 38 mod 1333 na base 36, os três caracteres serão consecutivos no alfabeto.

Snippet de teste

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>

Raquete 237 bytes

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

Teste:

(f "education")

Saída:

cde

Versão detalhada:

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

Ruby , 50 bytes

each_cons(3)obtém todas as sublistas consecutivas de comprimento 3 do alfabeto e ?a..?z, em seguida, use e&s.chars==epara selecionar apenas aquelas que possuem todos os caracteres na sequência de destino usando a interseção setwise. Retorna uma lista de listas.

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

Experimente online!

[R], 110 bytes

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

Tenho certeza que ainda é jogável

Japonês , 10 9 bytes

;Cã3 fUá3

Experimente ou execute todos os casos de teste

;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