Einführung

Laut Rand Al'Thor's Post in der Puzzling SE ist ein eng verbundenes Wort jedes Wort, das drei alphabetisch aufeinanderfolgende Buchstaben enthält (in beliebiger Reihenfolge).

Worte wie Bildung , Nebelhorn und Kabarett ist alle engmaschigen Worte während Worte wie als Lernen , klaxon und führt nicht engmaschige Worte.

Herausforderung

Die Herausforderung besteht darin, mit Code-Golf ein Programm zu erstellen, das ein einzelnes Wort als Eingabe verwendet (Kleinbuchstaben vorausgesetzt, in jeder Hinsicht) und eine Ausgabe zurückgibt, in der (falls verfügbar) alle aufeinanderfolgenden Buchstabensätze aufgelistet werden (auch in Kleinbuchstaben) ist ein eng verbundenes Wort und eine leere Ausgabe, wenn es kein eng verbundenes Wort ist.

Beispiele

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

Regeln

1. Während für die Eingabe ein einzelnes Wort in Kleinbuchstaben und für die Ausgabe Kleinbuchstaben angenommen werden müssen, hängt die Art der Ausgabe von der Wahl Ihrer Codiersprache ab. Bitte wählen Sie eine Ausgabeform, die der Art der Herausforderung am besten entspricht, sei es STDOUT, Dateiausgabe, Array usw.
2. Da dies Codegolf ist, ist die niedrigste Anzahl von Bytes der eindeutige Gewinner.
3. Keine dummen Schlupflöcher .
4. Ich akzeptiere keine Antworten, bei denen die aufeinanderfolgenden Buchstaben nicht alphabetisch sortiert sind. Daher cabwird dies beispielsweise nicht als geeignete Ausgabe für angesehen cabaret.
5. Besonderer Hinweis: Während die "Drillinge" nicht unbedingt in alphabetischer Reihenfolge sein müssen, müssen die Zeichen in den Drillingen ... sein. Im Fall des Wortes "Leistung" wird beispielsweise die Ausgabe mno,nopakzeptiert. wie es sein wird nop,mno. Im Fall des Wortes „Besetzung“, gibt es sechs Möglichkeiten , dass das von Triolen ghi, hijund ijkkönnten in einer Liste angeordnet werden, und alle sechs Permutationen sind akzeptabel als Ausgabe.

Anders als das, auf Ihre Noten, machen Sie sich bereit, Golf!

05AB1E , 7 6 5 Bytes

Code:

3ãAŒÃ

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es 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)

Gibt die ausgegebenen Zeichenfolgen aus und wird mit einem Fehler beendet, wenn der Zeichenwert zu groß wird.

Erzeugt alle Zeichenfolgen von drei aufeinanderfolgenden und druckt diejenigen, die eine Teilmenge des Eingabeworts sind.

Pyth - 11 10 8 7 Bytes

Super-Brute-Force-Methode.

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

Gelee , 7 Bytes

ØaẆfṗ3$

Dies ist eine monadische Verbindung. Probieren Sie es online!

Wie es funktioniert

Ø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 bis 90 Byte

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>

Fehlende Werte verketten sich wie folgt undefined: Die resultierende Zeichenfolge enthält mehr als 3 Zeichen. Ich habe den !c[3]Trick von @ETHproductions ausgeliehen, um 5 Bytes zu sparen.

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,";

Nimmt Eingaben als Kommandozeilenargument; druckt ein nachstehendes Komma. renn mit -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);}

eingerückt:

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

Bei der Sortierung werden doppelte Werte durch Nullen ersetzt. Diese Nullen werden an den Anfang des Wortes sortiert. Das Suchen nach aufeinanderfolgenden Werten ist dann trivial.

MATL , 13 Bytes

2Y23YCtjmAZ)!

Probieren Sie es 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'..]]

Erzeugt alle Tripel von drei aufeinanderfolgenden Zeichen und verwendet die, die nur Buchstaben in der Eingabe verwenden.

53 Bytes:

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

Die Liste ['c'..]enthält alle Unicode-Zeichen ab 'c'. Das Listenverständnis [[pred$pred c..c]|c<-['c'..]]wandelt sie von nun an in alle Zeichenfolgen mit 3 aufeinanderfolgenden Zeichen um "abc". Wir machen einen Schritt zurück mit [pred$pred c..c]anstatt vorwärts mit [c..succ$succ c], um einen Fehler zu vermeiden, wenn wir den Nachfolger des höchsten Unicode-Zeichens nehmen.

Diese Tripel werden für diejenigen gefiltert, die nur Buchstaben in der Eingabe verwenden.

Perl, 36 Bytes

Beinhaltet +1 für -n

Geben Sie Input auf STDIN:

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

Nur der Code:

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

T-SQL, 153 Bytes

Musste auf den Kommentar von WallyWest reagieren, da es lange her ist, dass TSQL das letzte Mal geantwortet hat. Die Antwort wurde teilweise von Brian Js Antwort inspiriert

Golf gespielt:

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

Geige

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]

Anwendungsbeispiel: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]Erstellt eine Liste mit den 'a'Endpunkten der Liste aller Unicode-Zeichen, beginnend mit und endet mit a '_', d ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. h . Dann nehmen wir bis zu drei Zeichen von jeder Zeichenfolge und binden sie an x. Behalten Sie alles dort, xwo sich jeder Buchstabe im Eingabeparameter befindet w.

Edit: @xnor 3 7 Bytes gespeichert . Vielen Dank!

T-SQL (SQL Server 2014), 217 Byte

Golf gespielt

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)

Verwendung

Deklarieren Sie zuerst die Variable @a als Zeichen und weisen Sie die Eingabe wie folgt zu

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Ich habe die Deklaration nicht als Teil meines Codes gezählt, aber ich habe keinen SQL-Standard für die Eingabe gefunden, daher bin ich bereit, meine Zählung zu ändern

Die Ausgabe erfolgt entweder in einer Zeile für jedes Tripel oder ohne Zeilen, wenn das Wort nicht eng verwoben ist

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

Meine Lösung ist ziemlich einfach. Es durchläuft die möglichen drei Buchstabenkombinationen, überprüft und vergleicht die Zeichen der eingegebenen Zeichenfolge mit den drei aufeinander folgenden Buchstaben und fügt sie einer Zeichenfolge hinzu. Die Zeichenfolge wird dann nur gedruckt, wenn drei Buchstaben gefunden wurden (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))}}}}

Input-Output

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

Eine anonyme Lambda-Funktion. Nimmt Eingaben als Großbuchstaben und gibt eine Reihe von Tupeln aus, wobei die mit drei Großbuchstaben gefüllten Tupel alle Sätze 3aufeinanderfolgender Buchstaben darstellen, die in der Eingabe erscheinen. Beispielsweise,

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

wäre die Ausgabe für die Eingabe HIJACKING. Dieses Ausgabeformat wurde vom OP als in Ordnung bestätigt . Hat also das einzige Großbuchstaben-Eingabeformat. Wenn Sie jedoch in eingeben möchten nur Klein, ersetzen Sie einfach range(65,91)mit range(97,123), ein weiteres Byte hinzufügen.

Repl.it mit allen Testfällen!

Erläuterung:

Grundsätzlich passiert hier Folgendes:

1. Mit wird eine Liste Werstellt W=[*map(chr,range(65,91))], die alle Großbuchstaben des englischen Alphabets enthält. Aus diesem Grund ist immer eine Eingabe in Großbuchstaben erforderlich.

2. Für jedes Tupel iin einer Liste, die wir aufrufen werden U, die alle drei aufeinander folgenden Buchstabentupel enthält, dh:

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

   erstellt von zip(W,W[1:],W[2:])jedem iist , so lange die Ausgabeliste vollständig hinzugefügt , wie alle Elemente in der eingestellten Version i( {*i}) in der eingestellten Version des Eingangs sind X( {*X}), das heißt {*X}>={*i}, das heißt Xein Superset von i. Andernfalls wird die leere Version von i( ()) zur Liste hinzugefügt.

3. Nachdem alle Tupel mit den vollständig hinzugefügten Übereinstimmungen durchlaufen wurden, wird die Liste als endgültige Ausgabe zurückgegeben.

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

Erläuterung:

(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

Eigentlich 13 Bytes

Golfvorschläge sind willkommen. Probieren Sie es 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;}

Dies kann höchstwahrscheinlich Golf gespielt werden, aber die Herausforderung war viel schwieriger als ich ursprünglich in Java dachte.

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 Byte

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

Fühlt sich viel länger an als erforderlich, aber ich kann nicht weiter Golf spielen.

Übernimmt die Eingabe $n. Schleifen von 97bis 120zusammenhängende Drei-Buchstaben - Strings Konstruktion - die, bis zu der ist |?, werden wir haben abc, bcd, cdeetc. an der Pipeline. Dann wird dies durch ein Where-Object(das |?) geleitet, um nur die Elemente herauszunehmen, bei denen die Klausel wahr ist. Hier ist die Klausel 1) die Eingabezeichenfolge $n, die als char-array, sorted und select -unique'd umgewandelt und dann -joinwieder in eine Zeichenfolge umgewandelt wird -match. Wenn es sich um eine Übereinstimmung handelt, befindet sich die Zeichenfolge mit drei Buchstaben im Wort und wird daher durch die gefiltert|? . Die Ergebnisse verbleiben in der Pipeline und die Ausgabe ist implizit.

Beispiele

(Beachten Sie, dass hier die Ausgabe durch Leerzeichen getrennt ist, da die Ausgabe durch Verkettung stringiert wird.)

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

Deduplizieren, Sortieren. Hinzufügen abc. Suchen Sie, ob die Teilzeichenfolge gefunden wurde, und hängen Sie sie an. Zum nächsten Teilstring übersetzen. Wiederholen. Dann entfernen Sie die ersten beiden Zeilen.

Probieren Sie es online aus

Naive Lösung:

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

Deduplizieren, sortieren und dann überlappende Übereinstimmungen von 3 aufeinander folgenden Buchstaben ausgeben.

Probieren Sie es online aus

JavaScript (Firefox 48), 93 Byte

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]

Dies bietet sich für eine 96-Byte-ES6-Version an :

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)

Wie es funktioniert

Der erste große Teil der Funktion lautet:

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

new Set(string)Erstellt ein Set-Objekt, das eines der eindeutigen Zeichen in der Zeichenfolge enthält. Zum Beispiel new Set("foghorn")wird zurückkehren Set ["f", "o", "g", "h", "r", "n"]. Wir können dies mit in ein Array konvertieren [... ]und es dann mit dem eingebauten sortieren .sort(). Dies wird "foghorn"zu["f", "g", "h", "n", "o", "r"] .

Der nächste Schritt ist dies:

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

Dies ordnet jeden cHaracter im aRay dem Charakter zu, der mit den beiden Gegenständen dahinter verkettet ist. Zum Beispiel ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"]. (Das undefineds wird angezeigt, wenn Sie versuchen, auf ein nicht vorhandenes Mitglied des Arrays zuzugreifen.

Der letzte Schritt ist das Filtern:

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

Erstens ist das !c[3]&, alle Zeichenfolgen, die enthalten, auszuschließen undefined. Dies ist notwendig, weil ein Fehler dazu führt, dass der folgende Algorithmus z. B. gmundefinedals aufeinanderfolgendes Triplet gezählt wird.

Alle drei aufeinanderfolgenden Zeichenfolgen lauten, wenn sie als Basis-36-Zahlen interpretiert werden, 38 modulo 1333. Ich habe dies durch die folgende Berechnung herausgefunden:

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

Wenn also eine Zeichenfolge mit drei Zeichen 38 mod 1333 in base-36 ist, sind die drei Zeichen im Alphabet aufeinanderfolgend.

Testschnipsel

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>

Schläger 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))))))))))

Testen:

(f "education")

Ausgabe:

cde

Ausführliche Version:

(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)Ruft alle aufeinanderfolgenden Unterlisten der Länge 3 aus dem Alphabet ab ?a..?zund e&s.chars==ewählt dann mithilfe von setwise intersection nur diejenigen aus, die alle Zeichen in der Zielzeichenfolge enthalten. Gibt eine Liste von Listen zurück.

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

Probieren Sie es 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)}

Ich bin sicher, es ist immer noch Golf

Japt , 10 9 Bytes

;Cã3 fUá3

Probieren Sie es aus oder führen Sie alle Testfälle aus

;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