Giriş

Rand Al'Thor'un Puzzling SE'deki görevine göre , sıkı sıkıya bağlı bir kelime, alfabetik olarak art arda üç harf içeren herhangi bir kelimedir (herhangi bir sıra ile).

Gibi kelimeler eğitim , foghorn ve kabare tüm gibi kelimeler oysa birbirine sıkı sıkıya kelimeleri kabul edilir öğrenme , klaxon ve gerçekleştirmek değil sıkı sıkıya bağlı bir kelimelerdir.

Meydan okuma

Buradaki zorluk, girdi olarak tek bir kelime alabilen bir programı kodlamak (golfün bütün amaçları ve amaçları için kabul edilir) ve eğer varsa (varsa) tüm ardışık harf setlerini listeleyen çıktıyı döndürmek. sıkı sıkıya bağlı bir kelime ve sıkı sıkıya kapalı bir kelime değilse boş çıktı.

Örnekler

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

kurallar

1. Girdilerin tek küçük harfli bir kelime olduğu varsayılırken, çıktı küçük harf olmalıdır, çıktıların niteliği kodlama dilinin seçimine göre değişecektir. Lütfen STDOUT, dosya çıktısı, dizi vb. Olsun, mücadelenin yapısına en uygun olan bir çıktı biçimi seçin.
2. Bu kod-golf olduğundan, açık kazanan en düşük bayt sayısına sahip olacaktır.
3. Aptal boşluklar yok .
4. Ardışık harfleri alfabetik sıraya sahip olmayan cevapları kabul etmeyeceğim ... Örneğin cab, bunun için uygun bir çıktı olarak kabul edilmeyecektir cabaret.
5. Özel not, "üçüzlerin" mutlaka alfabetik olarak sıralanması gerekmemekle birlikte, üçüzlerin içindeki karakterlerin olması gerekir ... bu nedenle "performans" kelimesi söz konusu olduğunda, örneğin, çıktı mno,nopkabul edilecektir. olacak gibi nop,mno. Kelime "kaçırma" durumunda, bir üçlü altı yolu vardır ghi, hijve ijkbir liste halinde de düzenlenebilir ve altı permütasyon çıkış olarak kabul edilebilir.

Bunun dışında, izlerinle golf oynamaya başla!

05AB1E , 7 6 5 bayt

Kod:

3ãAŒÃ

Açıklama:

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Python 3.5, 68 bayt

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

Çıkış dizelerini yazdırır ve karakter değeri çok büyüdüğünde hatayla sonlanır.

Tüm ardışık üç dizgeyi oluşturur ve giriş sözcüğünün alt kümesi olanları yazdırır.

Pyth - 11 10 8 7 bayt

Süper kaba kuvvet yöntemi.

@^z3.:G

Test Takımı .

@            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

Jöle , 7 bayt

ØaẆfṗ3$

Bu monadik bir bağlantıdır. Çevrimiçi deneyin!

Nasıl çalışır

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

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>

Eksik değerler, birleştirilmiş undefineddizgede 3 karakterden daha büyük karakterler bulunduğundan birleştirilir. Ödünç !c[3]5 bayt kaydetmek için @ETHproductions gelen hile.

Python 3.5, 78 bayt

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 bayt

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

girdiyi komut satırı argümanı olarak alır; sonunda virgül basar. ile koş -r.

C, 175 174 bayt

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

girintili:

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

Sıralama yaparken, yinelenen değerleri 0'larla değiştirir, bu 0'lar kelimenin başına göre sıralanır. Ardışık değerleri aramak o zaman önemsizdir.

MATL , 13 bayt

2Y23YCtjmAZ)!

Çevrimiçi deneyin!

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 bayt

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

Ardışık üç karakterin tüm üçlülerini oluşturur, girişte yalnızca harfleri kullananları alır.

53 bayt:

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

Liste ['c'..], tüm unicode karakterleri baştan 'c'itibaren içerir. Liste kavrama [[pred$pred c..c]|c<-['c'..]]onları baştan "abc"itibaren 3 ardışık karakter dizisine dönüştürür. En yüksek unicode karakterinin ardılını alırken bir hatayı önlemek için [pred$pred c..c]ileriye değil, geriye doğru [c..succ$succ c]ilerleriz.

Bu üçlüler, yalnızca girdideki harfleri kullananlar için filtrelenir.

Perl, 36 bayt

İçin +1 içerir -n

STDIN'e giriş verin:

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

Sadece kod:

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

T-SQL, 153 bayt

Son TSQL cevabından bu yana uzun zaman geçtiği konusunda WallyWest'in yorumuna tepki vermek zorunda kaldım. Cevap kısmen Brian J'in cevabından ilham aldı.

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

Keman

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 bayt

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

Kullanım örneği: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]ile başlayan tüm unicode karakterlerin listesinin kuyrukları ile bir liste oluşturur 'a've '_'örneğin a ile bitmesine izin verir ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Sonra her diziden üç karaktere kadar ayırır ve onu bağlarız x. xHer harfini giriş parametresinde olduğu yerde saklaw .

Düzenleme: @xnor kaydedilen 3 7 bayt. Teşekkürler!

T-SQL (SQL Server 2014), 217 bayt

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)

kullanım

İlk olarak, @a değişkenini bir tür char karakter olarak ilan edin ve böyle bir girişi yapın

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Bildirimi kodumun bir parçası olarak saymadım, ancak girdi için bir sql standardı bulamadım, bu yüzden sayımı değiştirmeye istekliyim

Çıktı, her üçlü için bir satır veya kelime kapalı değilse, satır yok

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 bayt

Benim çözümüm oldukça basit. Mümkün olan üç harf kombinasyonundan geçerek döngüye girer ve girilen dizginin karakterlerini ardışık üç harfe karşı kontrol eder ve bunları bir dizgeye ekler. Ardından, dize yalnızca üç harf bulunduğunda yazdırılır (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))}}}}

giriş çıkış

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

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

Anonim bir lambda işlevi. Girdiyi büyük harfli bir dize olarak alır ve girişte görünen tüm ardışık harfler kümesini temsil eden üç büyük harf karakteriyle dolu olanlar ile bir dizi teli çıkarır 3. Örneğin,

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

giriş için çıktı olurdu HIJACKING. Bu çıkış formatının OP tarafından uygun olduğu onaylandı . Bu yüzden tek büyük giriş formatı vardır. Ancak, yalnızca küçük harflerle giriş yapmak istiyorsanız range(65,91),range(97,123) bir byte daha eklemeyi.

Tüm Test Durumlarında Repl.it!

Açıklama:

Temelde burada olan şey:

1. İngilizce alfabedeki tüm büyük harfleri içeren bir liste, Wkullanılarak oluşturulur W=[*map(chr,range(65,91))]. Bu nedenle, büyük harfli bir giriş her zaman gereklidir.

2. Her demet için, iarayacağımız bir listede, arka arkaya gelen üç harfli tekilin hepsiniU içeren , yani:

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

   tarafından oluşturulur zip(W,W[1:],W[2:]), her iolarak uzun grubu versiyonu tüm elemanları gibi çıkış listesine eklenir i( {*i}), girişin grubu versiyonu olan X( {*X}), yani {*X}>={*i}, örneğin, Xa, kümesidir arasında i. Aksi halde, i( ()) ' nın boş versiyonu listeye eklenir.

3. Tüm kayıtlar tamamen eklenen eşleşmelerden geçtikten sonra, liste son çıktı olarak döndürülür.

Scala, 59 bayt

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

Açıklama:

(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

Aslında, 13 bayt

Golf önerileri kabul edilir. Çevrimiçi deneyin!

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 bayt

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

Bu büyük olasılıkla golf olabilir, ancak meydan okuma Java'da düşündüğümden çok daha zordu.

Ungolfed ve test durumları:

Burada dene.

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

Çıktı:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 bayt

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

Gerektiğinden çok daha uzun geliyor ama daha fazla golf oynayamıyor gibiyim.

Girdi alır $n. Dan Döngüler 97için 120, bitişik üç harfli dizileri üretmeye - kadar olan |?biz gerekecek abc, bcd, cdeboru hattı üzerinde, vb. Daha sonra, sadece cümlenin doğru olduğu maddeleri çıkarmak için bir Where-Object( |?) ile beslenir . Buradaki fıkra 1) giriş dizisi $n, charaarray, sorted ve select -unique'd biçiminde atılır, daha sonra üç harfli dizgilere karşı (yani regex eşleşmesi) dizilen, -joinbir dizgeye geri döndürülür, 2 -match). Eşleşiyorsa, üç harfli dize kelimededir ve bu nedenle|? . Sonuçlar boru hattında bırakılır ve çıktı kesindir.

Örnekler

(Burada çıktının boşlukla ayrıldığını, çünkü çıktının birleştirme işlemine göre dize edildiğini unutmayı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 bayt

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

Tekilleştir, Sırala. Ekle abc. Alt dizinin bulunup bulunmadığını bulun ve varsa ekleyin. Sonraki alt dize çevir. Tekrar et. Ardından ilk iki satırı kaldırın.

Çevrimiçi deneyin

Saf çözüm:

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

Tekilleştirin, Sıralayın, ardından 3 ardışık harften oluşan çakışan eşleşmeleri yazdırın.

Çevrimiçi deneyin

JavaScript (Firefox 48), 93 bayt

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]

Bu, kendisini 96 bayt ES6 sürümüne yönlendirir :

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)

Nasıl çalışır

Fonksiyonun ilk büyük öbekleri şudur:

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

new Set(string)Dize her benzersiz karakterden birini içeren bir Set nesnesi oluşturur. Örneğin, new Set("foghorn")geri dönecek Set ["f", "o", "g", "h", "r", "n"]. Bunu bir diziye dönüştürebiliriz [... ], sonra yerleşik olarak sıralayabiliriz .sort(). Bu döner "foghorn"içine ["f", "g", "h", "n", "o", "r"].

Bir sonraki adım şudur:

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

Bu c, araydaki her bir haracıyı iki öğe ile birleştirilen karaktere eşler. Örneğin,["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"] ,. (undefined var olmayan bir üyesine erişmeye çalıştığınızda s açılır.

Son adım filtreleme:

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

İlk olarak, !c[3]&içeren herhangi bir dize ekarte etmektir undefined. Bu gereklidir, çünkü bir hata aşağıdaki algoritmanın örneğin gmundefinedardışık üçlü olarak sayılmasına neden olur .

Her üç ardışık karakter dizisi, baz-36 sayıları olarak yorumlandığında, 38 modulo 1333'tür. Bunu aşağıdaki hesaplama ile çözdüm:

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

Bu nedenle, üç karakterli bir dize temel 36'da 38 mod 1333 ise, üç karakter alfabede ardışıktır.

Test pasajı

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>

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

Testing:

(f "education")

Output:

cde

Detailed 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) gets all consecutive sublists of length 3 from the alphabet ?a..?z, then use e&s.chars==e to select only the ones that have all characters in the target string by using setwise intersection. Returns a list of lists.

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

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

I'm sure its still golfable

Japt, 10 9 bytes

;Cã3 fUá3

Try it or run all test cases

;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