pengantar

Menurut posting Rand Al'Thor di SE membingungkan, kata yang berhubungan erat adalah kata yang berisi tiga huruf berurutan alfabet (dalam urutan apa pun).

Kata-kata seperti pendidikan , foghorn , dan kabaret semuanya dianggap sebagai kata-kata yang terjalin erat sedangkan kata-kata seperti belajar , klaxon dan pertunjukan bukanlah kata-kata yang terjalin erat.

Tantangan

Tantangannya adalah untuk kode-golf program yang mampu mengambil satu kata sebagai input (diasumsikan huruf kecil, untuk semua maksud dan tujuan) dan untuk mengembalikan output yang (jika tersedia) daftar semua set huruf berturut-turut (juga dalam huruf kecil) jika adalah kata yang terkait erat, dan mengosongkan hasil jika bukan kata yang terkait erat.

Contohnya

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

Aturan

1. Jika input dianggap sebagai satu huruf kecil dan output harus lebih kecil, sifat dari output akan bervariasi sesuai dengan pilihan bahasa pengkodean Anda. Silakan pilih bentuk output yang paling sesuai dengan sifat tantangan, apakah itu STDOUT, output file, array, dll.
2. Karena ini adalah kode-golf, ini akan menjadi kasus jumlah byte terendah yang menjadi pemenang.
3. Tidak ada celah konyol .
4. Saya tidak akan menerima jawaban yang memiliki huruf berturut-turut dalam urutan non-alfabet ... Jadi cabtidak akan dianggap sebagai output yang cocok untuk cabaret, misalnya.
5. Catatan khusus, sementara "kembar tiga" tidak harus dalam urutan abjad, tetapi karakter dalam kembar tiga harus ... jadi dalam hal kata "kinerja", misalnya, output mno,nopakan diterima, seperti yang akan nop,mno. Dalam kasus kata "pembajakan", ada enam cara yang kembar tiga dari ghi, hijdan ijkdapat diatur dalam daftar, dan keenam permutasi dapat diterima sebagai output.

Selain itu, sesuai keinginan Anda, siap, golf!

05AB1E , 7 6 5 byte

Kode:

3ãAŒÃ

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

Python 3.5, 68 byte

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

Mencetak string keluaran, dan berakhir dengan kesalahan ketika nilai karakter menjadi terlalu besar.

Menghasilkan semua string dari tiga berturut-turut dan mencetak yang merupakan bagian dari kata input.

Pyth - 11 10 8 7 byte

Metode kekuatan super brute.

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

Jelly , 7 byte

ØaẆfṗ3$

Ini adalah tautan monadik. Cobalah online!

Bagaimana itu bekerja

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

Nilai yang hilang digabungkan sebagai undefined, sehingga string yang dihasilkan berisi lebih dari 3 karakter. Saya meminjam !c[3]trik dari @ETHproductions untuk menghemat 5 byte.

Python 3.5, 78 byte

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 byte

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

mengambil input sebagai argumen baris perintah; mencetak koma jejak. jalankan bersama -r.

C, 175 174 byte

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

bertakuk:

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

Saat melakukan pengurutan itu menggantikan nilai duplikat dengan 0s, 0s ini disortir ke awal kata. Mencari nilai-nilai yang berurutan kemudian sepele.

MATL , 13 byte

2Y23YCtjmAZ)!

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

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

Menghasilkan semua tiga kali lipat dari tiga karakter berturut-turut, mengambil yang hanya menggunakan huruf dalam input.

53 byte:

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

Daftar ini ['c'..]berisi semua karakter unicode mulai dari 'c'seterusnya. Pemahaman daftar [[pred$pred c..c]|c<-['c'..]]mengubahnya menjadi semua string 3 karakter berturut-turut dari "abc"seterusnya. Kami melangkah mundur dengan [pred$pred c..c]bukannya maju dengan [c..succ$succ c]untuk menghindari kesalahan saat mengambil penerus karakter unicode tertinggi.

Tiga kali lipat ini difilter untuk mereka yang hanya menggunakan huruf dalam input.

Perl, 36 byte

Termasuk +1 untuk -n

Berikan masukan pada STDIN:

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

Hanya kode:

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

T-SQL, 153 byte

Harus bereaksi pada komentar dari WallyWest, tentang itu sudah lama sejak jawaban TSQL terakhir. Jawaban sebagian diilhami oleh jawaban Brian J

Golf:

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

Biola

Tidak Disatukan:

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 byte

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

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

scanr(:)"_"['a'..]membangun daftar dengan ekor daftar semua karakter unicode yang dimulai dengan 'a'dan membiarkannya diakhiri dengan '_', yaitu ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Lalu kami mengambil hingga tiga karakter dari setiap string dan mengikatnya x. Simpan semua xtempat di mana setiap huruf dalam parameter input w.

Edit: @xnatau disimpan 3 7 byte. Terima kasih!

T-SQL (SQL Server 2014), 217 byte

Golf

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)

Pemakaian

Pertama-tama deklarasikan variabel @a sebagai semacam char dan berikan input seperti itu

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Saya tidak menghitung pernyataan sebagai bagian dari kode saya, tetapi saya tidak menemukan standar sql untuk input, jadi saya bersedia mengubah penghitungan saya

Output akan menjadi satu baris untuk setiap triple, atau tidak ada baris jika kata tersebut tidak dirajut

Tidak disatukan

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 byte

Solusi saya cukup mudah. Ini loop melalui kombinasi tiga huruf yang mungkin, loop melalui dan memeriksa karakter dari string yang dimasukkan terhadap tiga huruf berturut-turut, dan menambahkannya ke string. String kemudian hanya dicetak ketika tiga huruf ditemukan (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 byte:

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

Fungsi lambda anonim. Mengambil input sebagai string huruf besar dan menghasilkan array tupel, dengan yang diisi dengan tiga karakter huruf besar yang mewakili semua set 3huruf berturut - turut yang muncul di input. Sebagai contoh,

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

akan menjadi output untuk input HIJACKING. Format output ini telah dikonfirmasi oke oleh OP. Jadi memiliki satu-satunya format input huruf besar. Namun, jika Anda ingin masukan dalam hanya huruf kecil, cukup mengganti range(65,91)dengan range(97,123), menambahkan satu byte lagi.

Repl.it dengan semua Kasing Uji!

Penjelasan:

Pada dasarnya yang terjadi di sini adalah:

1. Daftar,, Wdibuat menggunakan W=[*map(chr,range(65,91))], yang berisi semua huruf besar dalam alfabet bahasa Inggris. Karena itu, input huruf besar selalu diperlukan.

2. Untuk setiap tuple, i, dalam daftar, yang akan kita sebut U, mengandung semua tiga tupel surat berturut-turut, yaitu:

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

   dibuat oleh zip(W,W[1:],W[2:])masing-masing isepenuhnya ditambahkan ke daftar keluaran selama semua elemen dalam versi set i( {*i}) adalah dalam versi set input X( {*X}), yaitu {*X}>={*i}, yaitu Xmerupakan superset dari i. Jika tidak, versi kosong i( ()) ditambahkan ke daftar.

3. Setelah semua tupel dilalui dengan pertandingan yang sepenuhnya ditambahkan, daftar dikembalikan sebagai hasil akhir.

Scala, 59 byte

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

Tidak Disatukan:

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

Penjelasan:

(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

Sebenarnya, 13 byte

Saran golf diterima. Cobalah online!

S3@╧`εj`M3úV∩

Tidak melakukanolf

                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 byte

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

Ini kemungkinan besar bisa golf, tetapi tantangannya jauh lebih sulit daripada yang saya pikir di Jawa.

Kasus yang tidak disatukan & uji:

Coba di sini.

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

Keluaran:

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

Terasa jauh lebih lama dari yang dibutuhkan, tapi sepertinya saya tidak bisa bermain golf lebih jauh.

Mengambil input $n. Loop dari 97ke 120, membangun berdekatan string tiga huruf - yaitu, sampai |?, kita akan memiliki abc, bcd, cde, dsb di pipa. Maka itu dimasukkan melalui Where-Object( |?untuk) menarik hanya item-item di mana klausa itu benar. Di sini, klausa adalah 1) string input $n, dilemparkan sebagai char-array, sorted dan select -unique'd, kemudian -joined kembali menjadi string, 2) -matched terhadap string tiga huruf (yaitu, pencocokan regex). Jika itu cocok, maka string tiga huruf ada di kata, dan itu menyaring melalui |?. Hasilnya dibiarkan dalam pipa dan output tersirat.

Contohnya

(Perhatikan bahwa di sini output dipisahkan oleh ruang, karena kita sedang mengencangkan output dengan penggabungan.)

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 byte

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

Deduplicate, Sortir. Tambah abc. Cari apakah substring ditemukan dan tambahkan jika demikian. Terjemahkan ke substring berikutnya. Ulangi. Kemudian hapus dua baris pertama.

Cobalah online

Solusi naif:

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

Deduplicate, Sortir, lalu hasilkan pencocokan 3 huruf berurutan yang tumpang tindih.

Cobalah online

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]

Ini cocok untuk versi ES6 96-byte :

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)

Bagaimana itu bekerja

Potongan utama pertama dari fungsi ini adalah ini:

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

new Set(string)membuat objek Tetapkan yang berisi salah satu dari setiap karakter unik dalam string. Misalnya new Set("foghorn")akan kembali Set ["f", "o", "g", "h", "r", "n"]. Kita dapat mengonversinya menjadi array dengan [... ], lalu mengurutkannya dengan built-in .sort(). Ini berubah "foghorn"menjadi ["f", "g", "h", "n", "o", "r"].

Langkah selanjutnya adalah ini:

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

Ini memetakan setiap karakter cdalam array ke karakter yang digabungkan dengan dua item setelahnya. Sebagai contoh ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"],. ( undefinedS muncul ketika Anda mencoba mengakses anggota array yang tidak ada.

Langkah terakhir adalah memfilter:

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

Pertama, !c[3]&adalah untuk mengesampingkan string yang mengandung undefined. Ini diperlukan karena bug menyebabkan algoritma berikut ini menghitung misalnya gmundefinedsebagai triplet berturut-turut.

Semua string char tiga berturut-turut, ketika ditafsirkan sebagai angka base-36, adalah 38 modulo 1333. Saya menemukan ini dengan perhitungan berikut:

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

Oleh karena itu, jika string tiga karakter adalah 38 mod 1333 di base-36, ketiga karakter tersebut berurutan dalam alfabet.

Cuplikan tes

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 byte

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

Pengujian:

(f "education")

Keluaran:

cde

Versi detail:

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

each_cons(3)dapatkan semua daftar panjang berturut-turut 3 dari alfabet ?a..?z, kemudian gunakan e&s.chars==euntuk memilih hanya yang memiliki semua karakter dalam string target dengan menggunakan persimpangan setwise. Mengembalikan daftar daftar.

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

Cobalah online!

[R], 110 byte

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

Saya yakin masih golf

Japt , 10 9 byte

;Cã3 fUá3

Cobalah atau jalankan semua test case

;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