소개

Puzzling SE 의 Rand Al'Thor의 게시물 에 따르면 , 밀접한 단어는 알파벳 순서로 연속 된 3 개의 문자를 포함하는 모든 단어입니다.

education , foghorn 및 cabaret 와 같은 단어 는 모두 밀접한 단어로 간주되는 반면 learning , klaxon 및 perform 같은 단어 는 근접한 단어가 아닙니다.

도전

문제는 단일 단어를 입력으로 사용할 수있는 프로그램 (모든 의도와 목적을 위해 소문자로 가정)을 코드 골프로 만들고 가능한 경우 모든 연속 문자 세트를 나열하는 출력을 반환하는 것입니다 (소문자도 포함). close-knit 단어이며 close-nit 단어가 아닌 경우 빈 출력입니다.

예

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

규칙

1. 입력은 단일 소문자 단어로 가정되고 출력은 소문자 여야하지만 출력의 특성은 코딩 언어의 선택에 따라 다릅니다. STDOUT, 파일 출력, 배열 등 문제의 성격에 가장 적합한 출력 형식을 선택하십시오.
2. 이것은 코드 골프이기 때문에 가장 적은 수의 바이트가 확실한 승자가 될 것입니다.
3. 바보 같은 허점이 없습니다 .
4. 알파벳이 아닌 순서로 연속 된 문자가있는 답변 cab은받지 않습니다 cabaret. 예를 들어에 적합한 출력으로 간주되지 않습니다 .
5. "트리플렛"이 반드시 알파벳 순서 일 필요는 없지만, 트리플렛 내의 문자는 반드시 "성능"이라는 단어의 경우에 출력 mno,nop이 허용됩니다. 의지대로 nop,mno. 단어 "가로 채기"의 경우의 트리플렛이 여섯 가지 방법으로 ghi, hij및 ijk리스트에 배열 될 수 있고, 여섯 개의 순열 출력으로 허용.

그 외에는 마크에 골프를 치십시오!

05AB1E , 7 6 5 바이트

암호:

3ãAŒÃ

설명:

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬 3.5, 68 바이트

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

출력 문자열을 인쇄하고 문자 값이 너무 커지면 오류와 함께 종료됩니다.

세 개의 연속 문자열을 모두 생성하고 입력 단어의 하위 집합 인 문자열을 인쇄합니다.

Pyth- 11 10 8 7 바이트

초강력 방법.

@^z3.:G

테스트 스위트 .

@            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

젤리 , 7 바이트

ØaẆfṗ3$

이것은 모나 딕 링크입니다. 온라인으로 사용해보십시오!

작동 원리

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

자바 스크립트 (ES6), 95 90 바이트

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>

결 측값은로 연결되어 undefined결과 문자열에 3자를 초과합니다. !c[3]@ETHproductions에서 5 바이트를 절약하기 위한 트릭을 빌 렸습니다 .

파이썬 3.5, 78 바이트

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 바이트

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

명령 행 인수로 입력을받습니다. 후행 쉼표를 인쇄합니다. 로 실행하십시오 -r.

C, 175 174 바이트

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

들여 쓰기 :

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

정렬을 수행하는 동안 중복 값이 ​​0으로 바뀌지 만 이러한 0은 단어의 시작 부분으로 정렬됩니다. 연속적인 값을 찾는 것은 사소한 일입니다.

MATL , 13 바이트

2Y23YCtjmAZ)!

온라인으로 사용해보십시오!

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

하스켈, 48 바이트

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

세 개의 연속 문자로 구성된 트리플을 모두 생성하고 입력에 문자 만 사용하는 문자를 사용합니다.

53 바이트 :

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

이 목록 ['c'..]에는 모든 유니 코드 문자가 포함되어 있습니다 'c'. 목록 이해 [[pred$pred c..c]|c<-['c'..]]는 그것들을 3 연속 문자의 모든 문자열로 바꿉니다 "abc". 가장 높은 유니 코드 문자의 후속 작업을 수행 할 때 오류가 발생하지 않도록 [pred$pred c..c]앞으로 가 아니라 뒤로 이동 [c..succ$succ c]합니다.

이 트리플은 입력에 문자 만 사용하는 트리플에 대해 필터링됩니다.

펄, 36 바이트

에 +1 포함 -n

STDIN에 입력하십시오 :

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

코드 만 :

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

T-SQL, 153 바이트

지난 TSQL 응답 이후 오랜 시간이 지났음을 WallyWest의 의견에 반응해야했습니다. 답변은 Brian J의 답변에서 부분적으로 영감을 받았습니다

골프 :

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

깡깡이

언 골프 드 :

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

하스켈, 63 60 52 바이트

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

사용 예 : f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]로 시작하는 모든 유니 코드 문자 목록의 꼬리가있는 목록 'a'을 작성하고'_' ,로["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"] . 그런 다음 각 문자열에서 최대 3 개의 문자를 가져 와서 바인딩합니다 x. x입력 매개 변수의 모든 문자가있는 곳에 모두 유지하십시오 w.

편집 : @xnor는 3 7 바이트를 저장했습니다 . 감사!

T-SQL (SQL Server 2014), 217 바이트

골프

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)

용법

먼저 변수 @a를 일종의 char로 선언하고 입력을 다음과 같이 지정하십시오.

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

코드의 일부로 선언을 계산하지 않았지만 입력에 대한 SQL 표준을 찾지 못했기 때문에 계산을 변경하려고합니다.

출력은 각 트리플에 대해 하나의 행이거나 단어가 근접하지 않으면 행이 없습니다.

언 골프

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 바이트

내 솔루션은 매우 간단합니다. 가능한 3 개의 문자 조합을 반복하고, 3 개의 연속 문자에 대해 입력 된 문자열의 문자를 반복하여 확인한 후 문자열에 추가합니다. 문자열은 세 글자가 발견 될 때만 인쇄됩니다 (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))}}}}

입출력

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

파이썬 3.5 114 111 88 80 79 바이트 :

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

익명의 람다 함수. 입력을 대문자 문자열 로 받아서 튜플 배열을 출력합니다. 튜플 은 입력에 나타나는 모든 연속 문자 세트를 나타내는 3 개의 대문자로 채워집니다 3. 예를 들어

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

input 출력이됩니다 HIJACKING. 이 출력 형식은 OP에 의해 확인 되었습니다 . 그래서이 유일한 대문자 입력 형식을. 당신이 입력하려는 경우, 단지 소문자, 간단하게 교체 range(65,91)와 함께 range(97,123)또 하나의 바이트를 추가.

모든 테스트 케이스와 함께 반복하십시오!

설명:

기본적으로 여기서 일어나는 일은 다음과 같습니다.

1. 을 (를) W사용하여 만든 목록 W=[*map(chr,range(65,91))]은 영어 알파벳의 모든 대문자를 포함합니다. 이 때문에 항상 대문자 입력이 필요합니다.

2. 각각의 튜플에 대해 3 개의 연속 된 문자 튜플 을 모두 포함 i하는 목록 에서을 호출합니다 .U

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

   에 의해 생성 된 zip(W,W[1:],W[2:]), i세트 버전 i( {*i}) 의 모든 요소 가 입력 세트 X( {*X})의 버전 ( 즉 {*X}>={*i}, X)의 슈퍼 세트 인 한 , 각각 은 출력리스트에 완전히 추가된다 i. 그렇지 않으면 빈 버전 i( ())이 목록에 추가됩니다.

3. 일치 항목이 완전히 추가 된 상태에서 모든 튜플이 완료되면 목록이 최종 출력으로 반환됩니다.

스칼라, 59 바이트

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

언 골프 드 :

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

설명:

(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

실제로 13 바이트

골프 제안을 환영합니다. 온라인으로 사용해보십시오!

S3@╧`εj`M3úV∩

언 골핑

                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.

자바 7, 230 바이트

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

이것은 골프를 칠 가능성이 높지만, Java에서 처음 생각했던 것보다 훨씬 어려웠습니다.

언 골프 및 테스트 사례 :

여기에서 시도하십시오.

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

산출:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 바이트

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

필요 이상으로 느껴지지만 더 이상 골프를 칠 수는 없습니다.

입력을 $n받습니다. 에서 루프 97에 120연속 세 글자 문자열을 구성 -까지이며 |?, 우리는해야합니다 abc, bcd, cde파이프 라인에 등. 그런 다음 Where-Object( |?)를 통해 절이 참인 항목 만 가져옵니다. 여기서, 절은 1) 입력 문자열 $n이며, 배열 로 캐스팅되고 char, sorted 및 select -unique'd 된 다음 -join문자열로 다시 보내집니다 -match. 일치하는 경우 3 글자 문자열이 단어에 있으므로를 통해 필터링합니다 |?. 결과는 파이프 라인에 남고 출력은 암시 적입니다.

예

(여기서 출력은 연결로 문자열 화되므로 출력은 공백으로 구분됩니다.)

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

레티 나, 106 56 바이트

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

중복 제거, 정렬 추가하십시오 abc. 부분 문자열이 발견되면 찾아서 추가하십시오. 다음 부분 문자열로 번역하십시오. 반복. 그런 다음 처음 두 줄을 제거하십시오.

온라인으로 사용해보십시오

순진한 솔루션 :

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

중복 제거, 정렬 후 3 개의 연속 문자가 겹치는 일치 항목을 출력합니다.

온라인으로 사용해보십시오

JavaScript (Firefox 48), 93 바이트

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]

이것은 96 바이트 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)

작동 원리

함수의 첫 번째 주요 덩어리는 다음과 같습니다.

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

new Set(string)문자열에서 각 고유 문자 중 하나를 포함하는 Set 객체를 만듭니다. 예를 new Set("foghorn")들어을 반환 Set ["f", "o", "g", "h", "r", "n"]합니다. 이것을 사용하여 배열로 변환 [... ]한 다음 내장으로 정렬 할 수 .sort()있습니다. 이 차례"foghorn" 에 ["f", "g", "h", "n", "o", "r"].

다음 단계는 이렇습니다 :

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

이것은 레이의 각 haracter를 그 뒤의 두 항목과 연결된 캐릭터 c에 매핑 a합니다. 예를 들어["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"] . 합니다 ( undefined당신이 배열의 존재하지 않는 멤버에 액세스 할 때의 팝업.

마지막 단계는 필터링입니다.

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

먼저, !c[3]&포함하는 모든 문자열을 배제하는 것입니다undefined . 버그로 인해 다음 알고리즘 gmundefined이 연속적인 삼중 항으로 계산되기 때문 입니다.

기본 36 개의 숫자로 해석 될 때 세 개의 연속 문자 스트링은 모두 38 모듈로 1333입니다. 나는 이것을 다음 계산으로 알아 냈습니다.

• 012 (베이스 36) = 38
• 123 (기본 36) = 1371
• 1371-38 = 1333
• 1371 모드 1333 ≡ 38 모드 1333 ≡ 38

따라서 3 문자열 문자열이 기수 -36에서 38 mod 1333 인 경우, 3 개의 문자는 알파벳에서 연속적입니다.

테스트 스 니펫

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>

라켓 237 바이트

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

테스트 :

(f "education")

산출:

cde

자세한 버전 :

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

루비 , 50 바이트

each_cons(3) 알파벳에서 길이가 3 인 연속 된 모든 하위 목록을 가져옵니다. ?a..?z 다음 e&s.chars==e대상 교차로를 사용하여 대상 문자열에 모든 문자가있는 하위 목록 만 선택합니다. 리스트의리스트를 돌려줍니다.

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

온라인으로 사용해보십시오!

[R], 110 바이트

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

나는 여전히 골프 가능하다

Japt , 10 9 바이트

;Cã3 fUá3

사용해 보거나 모든 테스트 사례를 실행하십시오.

;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