Wprowadzenie

Według postu Rand Al'Thor w Puzzling SE, zwarte słowo to każde słowo, które zawiera trzy kolejne litery alfabetu (w dowolnej kolejności).

Słowa takie jak edukacja , mgła i kabaret są uważane za ściśle powiązane, podczas gdy słowa takie jak nauka , klaxon i występ nie są ściśle powiązane.

Wyzwanie

Wyzwanie polega na kodowaniu w golfa programu, który może przyjmować pojedyncze słowo jako dane wejściowe (zakładane małe litery, dla wszystkich celów i celów) i zwracać dane wyjściowe, które (jeśli są dostępne) zawierają listę wszystkich kolejnych zestawów liter (także małych), jeśli jest słowem zwartym i pustym, jeśli nie jest słowem ścisłym.

Przykłady

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

Zasady

1. Podczas gdy dane wejściowe należy przyjmować jako pojedyncze małe litery, a dane wyjściowe muszą być pisane małymi literami, charakter danych wyjściowych będzie się różnić w zależności od wybranego języka kodowania. Wybierz formę wyjściową, która najlepiej pasuje do charakteru wyzwania, czy będzie to STDOUT, plik wyjściowy, tablica itp.
2. Ponieważ jest to gra w golfa kodowego, będzie to przypadek najmniejszej liczby bajtów, która będzie wyraźnym zwycięzcą.
3. Żadnych głupich luk .
4. Nie przyjmuję odpowiedzi, które mają kolejne litery w kolejności niealfabetycznej ... Tak więc , na przykład, cabnie będę uważany za odpowiedni wynik cabaret.
5. Uwaga specjalna, podczas gdy „trojaczki” niekoniecznie muszą być w kolejności alfabetycznej, ale znaki w trojaczkach muszą być… więc w przypadku słowa „wydajność”, na przykład, wynik mno,nopzostanie zaakceptowany, jak będzie nop,mno. W przypadku słowa „porwania”, istnieje sześć sposobów, że trypletach ghi, hiji ijkmoże być umieszczony na liście, a wszystkie sześć permutacje są dopuszczalne jako wyjście.

Poza tym, na swoje oceny, ustaw się, golf!

05AB1E , 7 6 5 bajtów

Kod:

3ãAŒÃ

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Python 3.5, 68 bajtów

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

Wyświetla ciągi wyjściowe i kończy się błędem, gdy wartość znaku staje się zbyt duża.

Generuje wszystkie ciągi trzech kolejnych i drukuje te, które są podzbiorem słowa wejściowego.

Pyth - 11 10 8 7 bajtów

Metoda super brutalnej siły.

@^z3.:G

Pakiet testowy .

@            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

Galaretka , 7 bajtów

ØaẆfṗ3$

To jest link monadyczny. Wypróbuj online!

Jak to działa

Ø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 bajtów

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>

Brakujące wartości łączą się jako undefined, więc wynikowy ciąg zawiera więcej niż 3 znaki. Pożyczyłem ten !c[3]trik z @ETHproductions zaoszczędzić 5 bajtów.

Python 3.5, 78 bajtów

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 bajtów

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

przyjmuje dane wejściowe jako argument wiersza poleceń; drukuje przecinek końcowy. biegać z -r.

C, 175 174 bajtów

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

zębaty:

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

Podczas sortowania zastępuje zduplikowane wartości zerami, te zera są sortowane na początek słowa. Szukanie kolejnych wartości jest wtedy banalne.

MATL , 13 bajtów

2Y23YCtjmAZ)!

Wypróbuj 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 bajtów

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

Generuje wszystkie trzykrotnie trzy kolejne znaki, pobiera te, które używają tylko liter na wejściu.

53 bajty:

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

Lista ['c'..]zawiera wszystkie znaki Unicode od początku 'c'. Zrozumienie listy [[pred$pred c..c]|c<-['c'..]]zamienia je odtąd we wszystkie ciągi 3 kolejnych znaków "abc". Cofamy się do tyłu [pred$pred c..c]zamiast do przodu z, [c..succ$succ c]aby uniknąć błędu przy przyjmowaniu następcy najwyższego znaku Unicode.

Te tróje są filtrowane dla tych, które używają tylko liter na wejściu.

Perl, 36 bajtów

Obejmuje +1 dla -n

Podaj dane na STDIN:

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

Tylko kod:

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

T-SQL, 153 bajty

Musiałem zareagować na komentarz WallyWest, że minęło sporo czasu od ostatniej odpowiedzi TSQL. Odpowiedź była częściowo zainspirowana odpowiedzią Briana J.

Gra w golfa:

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

Skrzypce

Nie golfowany:

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 bajtów

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

Przykład użycia: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]buduje listę z ogonami listy wszystkich znaków Unicode zaczynających się od 'a'i pozwala kończyć na a '_', tj ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Następnie bierzemy do trzech znaków każdego łańcucha i wiążemy go x. Zachowaj wszystko xtam, gdzie każda jego litera znajduje się w parametrze wejściowym w.

Edycja: @xnor zapisał 3 7 bajtów. Dzięki!

T-SQL (SQL Server 2014), 217 bajtów

Grał w golfa

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)

Stosowanie

Najpierw zadeklaruj zmienną @a jako jakiś rodzaj znaku i tak przypisz dane wejściowe

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Nie liczyłem deklaracji jako części mojego kodu, ale nie znalazłem standardu SQL dla danych wejściowych, więc jestem gotów zmienić moje liczenie

Wyjście będzie albo jeden wiersz na każdy potrójny, albo brak wierszy, jeśli słowo nie będzie ścisłe

Nie golfił

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 bajtów

Moje rozwiązanie jest dość proste. Pętla przechodzi przez trzy możliwe kombinacje liter, zapętla i sprawdza znaki wprowadzonego ciągu względem trzech kolejnych liter i dodaje je do ciągu. Łańcuch jest następnie drukowany tylko wtedy, gdy zostaną znalezione trzy litery (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))}}}}

wejście wyjście

> 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 bajtów:

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

Anonimowa funkcja lambda. Pobiera dane wejściowe jako ciąg wielkich liter i wypisuje tablicę krotek, przy czym te wypełnione są trzema wielkimi literami reprezentującymi wszystkie zestawy 3kolejnych liter pojawiających się na wejściu. Na przykład,

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

byłoby wyjściem dla danych wejściowych HIJACKING. Ten format wyjściowy został potwierdzony przez OP. Ma więc jedyny format wprowadzania wielkich liter. Jednakże, jeśli chcesz wprowadzić w tylko małymi literami, po prostu wymienić range(65,91)się range(97,123), dodając jeszcze jeden bajt.

Zamień na wszystkie przypadki testowe!

Wyjaśnienie:

Zasadniczo dzieje się tutaj:

1. Za Wpomocą W=[*map(chr,range(65,91))], tworzona jest lista, która zawiera wszystkie wielkie litery alfabetu angielskiego. Z tego powodu zawsze wymagane jest wprowadzenie wielkich liter .

2. Dla każdej krotki, ina liście, którą nazwiemy U, zawierającej wszystkie trzy kolejne krotki literowe, tj .:

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

   stworzony przez zip(W,W[1:],W[2:])każdy ijest w pełni dodany do listy wyjściowej tak długo, jak wszystkie elementy w zestawie wersji i( {*i}) są w zbiorze wersją wejścia X( {*X}), czyli {*X}>={*i}, czyli Xjest rozszerzeniem o i. W przeciwnym razie pusta wersja i( ()) zostanie dodana do listy.

3. Po przejściu wszystkich krotek z całkowicie dodanymi dopasowaniami lista jest zwracana jako wynik końcowy.

Scala, 59 bajtów

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

Nie golfowany:

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

Wyjaśnienie:

(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

Właściwie 13 bajtów

Sugestie dotyczące gry w golfa mile widziane. Wypróbuj 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 bajtów

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

Najprawdopodobniej można grać w golfa, ale wyzwanie było znacznie trudniejsze, niż początkowo myślałem w Javie ..

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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

Wydajność:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 bajty

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

Czuje się znacznie dłużej niż jest to wymagane, ale nie wydaje mi się, że mogę grać w golfa.

Pobiera dane wejściowe $n. Pętle od 97celu 120, budowy sąsiadujących strun trzyliterowe - czyli aż do |?, będziemy mieli abc, bcd, cde, itd. Na rurociągu. To jest przekazywane przez Where-Object(the |?), aby wyciągnąć tylko te elementy, w których klauzula jest prawdziwa. Tutaj klauzula to 1) ciąg wejściowy $n, rzutowany jako char-array, sorted i select -unique'd, a następnie -joined z powrotem na ciąg, 2) -matched przeciwko ciągom trzyliterowym (tj. Dopasowanie wyrażenia regularnego). Jeśli pasuje, to trzyliterowy ciąg znajduje się w słowie, więc filtruje przez |?. Wyniki są pozostawione w potoku, a wyniki są niejawne.

Przykłady

(Zauważ, że w tym przypadku dane wyjściowe są rozdzielone spacjami, ponieważ dzielimy dane wyjściowe na konkatenację).

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

Siatkówka, 106 56 bajtów

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

Deduplikuj, Sortuj. Dodaj abc. Sprawdź, czy podciąg został znaleziony i dołącz, jeśli tak. Przetłumacz na następny podciąg. Powtarzać. Następnie usuń pierwsze dwie linie.

Wypróbuj online

Naiwne rozwiązanie:

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

Deduplikuj, posortuj, a następnie wyprowadź nakładające się dopasowania 3 kolejnych liter.

Wypróbuj online

JavaScript (Firefox 48), 93 bajty

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]

Daje to 96-bajtową wersję 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)

Jak to działa

Pierwszą dużą częścią tej funkcji jest:

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

new Set(string)tworzy obiekt Set, który zawiera jeden z każdego unikalnego znaku w ciągu. Na przykład new Set("foghorn")wróci Set ["f", "o", "g", "h", "r", "n"]. Możemy przekonwertować to na tablicę za pomocą [... ], a następnie posortować za pomocą wbudowanego .sort(). To zamienia się "foghorn"w ["f", "g", "h", "n", "o", "r"].

Kolejny krok to:

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

To mapuje każdy znak cw aszyku na postać połączoną z dwoma przedmiotami po nim. Na przykład ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"]. ( undefinedWyskakujące okienko przy próbie uzyskania dostępu do nieistniejącego elementu tablicy.

Ostatnim krokiem jest filtrowanie:

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

Po pierwsze, !c[3]&należy wykluczyć wszelkie ciągi zawierające undefined. Jest to konieczne, ponieważ błąd powoduje, że następujący algorytm liczy się np. gmundefinedJako kolejny triplet.

Wszystkie trzy kolejne ciągi znaków, interpretowane jako liczby podstawowe 36, mają wartość 38 modulo 1333. Zrozumiałem to na podstawie następującego obliczenia:

• 012 (podstawa 36) = 38
• 123 (podstawa 36) = 1371
• 1371–38 = 1333
• 1371 mod 1333 ≡ 38 mod 1333 ≡ 38

Dlatego jeśli ciąg znaków składający się z trzech znaków ma wartość 38 mod 1333 w bazie 36, trzy znaki są następujące po sobie w alfabecie.

Testowy fragment kodu

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>

Rakieta 237 bajtów

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

Testowanie:

(f "education")

Wydajność:

cde

Wersja szczegółowa:

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

Rubinowy , 50 bajtów

each_cons(3)pobiera z alfabetu wszystkie kolejne listy podrzędne o długości 3 ?a..?z, a następnie służy e&s.chars==edo wybierania tylko tych, które mają wszystkie znaki w ciągu docelowym, za pomocą przecięcia zgodnie z sekwencją. Zwraca listę list.

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

Wypróbuj online!

[R], 110 bajtów

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

Jestem pewien, że nadal można grać w golfa

Japt , 10 9 bajtów

;Cã3 fUá3

Wypróbuj lub uruchom wszystkie przypadki testowe

;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