Introducción

Según la publicación de Rand Al'Thor en Puzzling SE, una palabra muy unida es cualquier palabra que contiene tres letras alfabéticamente consecutivas (en cualquier orden).

Palabras como educación , foghorn y cabaret se consideran palabras muy unidas, mientras que palabras como learning , klaxon y performance no son palabras muy unidas.

Reto

El desafío es codificar un programa capaz de tomar una sola palabra como entrada (se supone minúscula, para todos los efectos) y devolver la salida que (si está disponible) enumera todos los conjuntos de letras consecutivas (también en minúscula) si es una palabra unida y salida vacía si no es una palabra unida.

Ejemplos

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

Reglas

1. Mientras que se supone que la entrada es una sola palabra en minúsculas y la salida debe ser en minúsculas, la naturaleza de la salida variará de acuerdo con la elección de su lenguaje de codificación. Seleccione una forma de salida que se adapte mejor a la naturaleza del desafío, ya sea STDOUT, salida de archivo, matriz, etc.
2. Debido a que este es el código de golf, será el caso de que el número más bajo de bytes sea el claro ganador.
3. No hay lagunas tontas .
4. No aceptaré respuestas que tengan las letras consecutivas en orden no alfabético ... Por cablo tanto , no se considerará una salida adecuada para cabaret, por ejemplo.
5. Nota especial, mientras que los "trillizos" no necesariamente tienen que estar en orden alfabético, pero los caracteres dentro de los trillizos deben estar ... así que en el caso de la palabra "performance", por ejemplo, la salida mno,nopserá aceptada, como voluntad nop,mno. En el caso de la palabra "secuestro", hay seis formas en que la tripletes de ghi, hijy ijkpodrían estar dispuestos en una lista, y todas las seis permutaciones son aceptables como salida.

Aparte de eso, en tus marcas, prepárate, ¡golf!

05AB1E , 7 6 5 bytes

Código:

3ãAŒÃ

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

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 cadenas de salida y termina con un error cuando el valor del carácter es demasiado grande.

Genera todas las cadenas de tres consecutivas e imprime las que son un subconjunto de la palabra de entrada.

Pyth - 11 10 8 7 bytes

Método de fuerza súper bruta.

@^z3.:G

Test Suite .

@            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

Jalea , 7 bytes

ØaẆfṗ3$

Este es un enlace monádico. Pruébalo en línea!

Cómo 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>

Los valores faltantes se concatenan como undefined, por lo que la cadena resultante contiene más de 3 caracteres. Tomé prestado el !c[3]truco de @ETHproductions para ahorrar 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,";

toma la entrada como argumento de línea de comando; imprime una coma final. correr con -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);}

sangrado:

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

Mientras realiza la ordenación, reemplaza los valores duplicados con 0, estos 0 se ordenan al comienzo de la palabra. Buscar los valores consecutivos es trivial.

MATL , 13 bytes

2Y23YCtjmAZ)!

Pruébalo en línea!

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

Genera todos los triples de tres caracteres consecutivos, toma aquellos que usan solo letras en la entrada.

53 bytes:

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

La lista ['c'..]contiene todos los caracteres unicode de 'c'adelante en adelante. La comprensión de la lista los [[pred$pred c..c]|c<-['c'..]]convierte en todas las cadenas de 3 caracteres consecutivos en "abc"adelante. Retrocedemos en [pred$pred c..c]lugar de avanzar [c..succ$succ c]para evitar un error al tomar el sucesor del carácter unicode más alto.

Estos triples se filtran para aquellos que solo usan letras en la entrada.

Perl, 36 bytes

Incluye +1 para -n

Dar entrada en STDIN:

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

Solo el código:

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

T-SQL, 153 bytes

Tuve que reaccionar ante el comentario de WallyWest, sobre que pasó mucho tiempo desde la última respuesta de TSQL. La respuesta fue en parte inspirada por la respuesta de Brian J

Golfizado:

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

Violín

Sin golf:

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]

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

scanr(:)"_"['a'..]construye una lista con las colas de la lista de todos los caracteres unicode que comienzan con 'a'y deja que termine con un '_', es decir ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Luego tomamos hasta tres caracteres de cada cadena y lo unimos x. Mantenga todo xdonde está cada letra en el parámetro de entrada w.

Editar: @xnor guardó 3 7 bytes. ¡Gracias!

T-SQL (SQL Server 2014), 217 bytes

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)

Uso

Primero declare la variable @a como un carácter de algún tipo y asigne la entrada de esta manera

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

No conté la declaración como parte de mi código, pero no encontré un estándar sql para entrada, así que estoy dispuesto a cambiar mi conteo

La salida será una fila para cada triple o ninguna fila si la palabra no está muy unida

Sin golf

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

Mi solución es bastante sencilla. Recorre las posibles combinaciones de tres letras, recorre y comprueba los caracteres de la cadena ingresada contra las tres letras consecutivas, y las agrega a una cadena. La cadena solo se imprime cuando se encuentran tres letras (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))}}}}

de entrada y salida

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

Una función lambda anónima. Toma la entrada como una cadena en mayúscula y genera una matriz de tuplas, con las que están llenas de tres caracteres en mayúscula que representan todos los conjuntos de 3letras consecutivas que aparecen en la entrada. Por ejemplo,

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

sería la salida de entrada HIJACKING. OP ha confirmado que este formato de salida está bien. Entonces tiene el único formato de entrada en mayúscula. Sin embargo, si desea ingresar solo en minúsculas, simplemente reemplace range(65,91)con range(97,123), agregando un byte más.

Repl.it con todos los casos de prueba!

Explicación:

Básicamente lo que está sucediendo aquí es:

1. Se Wcrea una lista, W=[*map(chr,range(65,91))]que contiene todas las letras mayúsculas del alfabeto inglés. Debido a esto, siempre se requiere una entrada en mayúscula .

2. Para cada tupla, ien una lista, que llamaremos U, que contiene las tres tuplas de letras consecutivas, es decir:

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

   creado por zip(W,W[1:],W[2:]), cada uno ise agrega completamente a la lista de salida siempre que todos los elementos en la versión establecida de i( {*i}) estén en la versión establecida de input X( {*X}), es decir {*X}>={*i}, Xes un superconjunto de i. De lo contrario, la versión vacía de i( ()) se agrega a la lista.

3. Una vez que se han realizado todas las tuplas con las coincidencias completamente agregadas, la lista se devuelve como el resultado final.

Scala, 59 bytes

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

Sin golf:

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

Explicación:

(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

En realidad, 13 bytes

Sugerencias de golf bienvenidas. Pruébalo en línea!

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

Es muy probable que esto se pueda jugar al golf, pero el desafío fue mucho más difícil de lo que pensé originalmente en Java.

Sin golf y casos de prueba:

Pruébalo aquí

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

Salida:

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$_}

Se siente mucho más tiempo del requerido, pero parece que ya no puedo jugar más al golf.

Toma entrada $n. Bucles de 97que 120, la construcción de cadenas de tres letras contiguas - es decir, hasta el |?, vamos a tener abc, bcd, cde, etc, sobre la tubería. Luego, se alimenta a través de una Where-Object(la |?) para extraer solo aquellos elementos donde la cláusula es verdadera. Aquí, la cláusula es 1) la cadena de entrada $n, convertida como una charmatriz, sorted y select -unique'd, luego editada -joinnuevamente en una cadena, 2) -matched contra las cadenas de tres letras (es decir, coincidencia de expresiones regulares). Si es una coincidencia, entonces la cadena de tres letras está en la palabra, por lo que se filtra a través del|? . Los resultados se dejan en la tubería y la salida es implícita.

Ejemplos

(Tenga en cuenta que aquí la salida está separada por espacios, ya que estamos encadenando la salida por concatenación).

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`.*¶?

Deduplicar, ordenar. Añadir abc. Encuentre si se encuentra la subcadena y agregue si es así. Traducir a la siguiente subcadena. Repetir. Luego quite las primeras dos líneas.

Pruébalo en línea

Solución ingenua:

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

Deduplicar, ordenar y luego generar coincidencias superpuestas de 3 letras secuenciales.

Pruébalo en línea

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]

Esto se presta a una versión 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)

Cómo funciona

La primera parte importante de la función es esta:

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

new Set(string)crea un objeto Set que contiene uno de cada carácter único en la cadena. Por ejemplo, new Set("foghorn")volveremos Set ["f", "o", "g", "h", "r", "n"]. Podemos convertir esto en una matriz con [... ], luego ordenarlo con el incorporado .sort(). Esto se convierte "foghorn"en ["f", "g", "h", "n", "o", "r"].

El siguiente paso es este:

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

Esto asigna cada cpersonaje en la amatriz al personaje concatenado con los dos elementos después de él. Por ejemplo, ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"]. (Losundefined s aparecen cuando intenta acceder a un miembro inexistente de la matriz.

El último paso es filtrar:

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

Primero, !c[3]&es descartar cualquier cadena que contenga undefined. Esto es necesario porque un error hace que el siguiente algoritmo cuente, por ejemplo, gmundefinedcomo un triplete consecutivo.

Todas las cadenas de tres caracteres consecutivos, cuando se interpretan como números de base 36, son 38 módulo 1333. Lo descubrí mediante el siguiente cálculo:

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

Por lo tanto, si una cadena de tres caracteres es 38 mod 1333 en base 36, los tres caracteres son consecutivos en el alfabeto.

Fragmento de prueba

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>

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

Pruebas:

(f "education")

Salida:

cde

Versión detallada:

(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)obtiene todas las sublistas consecutivas de longitud 3 del alfabeto ?a..?z, luego se usa e&s.chars==epara seleccionar solo las que tienen todos los caracteres en la cadena de destino mediante la intersección setwise. Devuelve una lista de listas.

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

Pruébalo en línea!

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

Estoy seguro de que todavía es golfable

Japt , 10 9 bytes

;Cã3 fUá3

Pruébalo o ejecuta todos los casos de prueba

;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