क्लोज़-नाइट शब्द

Question

परिचय

पज़्लिंग एसई में रैंड अल थोर की पोस्ट के अनुसार , एक नज़दीकी शब्द कोई भी शब्द है जिसमें तीन वर्णानुक्रम में लगातार अक्षर (किसी भी क्रम में) होते हैं।

शिक्षा , फॉगहॉर्न और कैबरे जैसे शब्द सभी क्लोज-नाइट शब्द माने जाते हैं जबकि सीखना , क्लेक्सन और प्रदर्शन जैसे शब्द क्लोज-नाइट शब्द नहीं हैं।

चुनौती

चुनौती एक ऐसे कार्यक्रम को कोड-गोल्फ करना है जो एक शब्द को इनपुट के रूप में लेने में सक्षम है (सभी मामलों और उद्देश्यों के लिए निचला मामला) और आउटपुट वापस करने के लिए (यदि उपलब्ध हो) सभी लगातार पत्र सेटों को सूचीबद्ध करता है (यदि निचले मामले में भी) यदि यह क्लोज़-नाइट शब्द नहीं है, तो क्लोज़-नाइट शब्द और खाली आउटपुट है।

उदाहरण

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एक सूची में व्यवस्थित किया जा सकता है, और सभी छह क्रमांकन आउटपुट के रूप में स्वीकार्य हैं।

इसके अलावा, अपने निशान पर, सेट हो जाओ, गोल्फ!

Comments

क्या आउटपुट एक कॉलम में लगातार तीन अक्षरों के प्रत्येक सेट के साथ 2 डी चार सरणी हो सकता है ?

— लुइस मेन्डो

@LuisMendo क्या आप मुझे एक उदाहरण दे सकते हैं ताकि मैं इसकी कल्पना कर सकूं?

— वॉलीवेस्ट

फाइनल के बिना मेरे कोड को आज़माएं !और दूसरे शब्द के साथ, जैसा कि वर्तमान एक ही परिणाम देता है :-)

— लुइस मेंडो

@LuisMendo MATL स्तंभ प्रमुख है या कुछ और?

— माल्टसेन

Tuples के एक सरणी के प्रारूप में एक आउटपुट ठीक है, यानी के लिए आउटपुट pneumoniaहो सकता है [('m','n','o'),('n','o','p')])?

— आर। कप

Answer 1

05AB1E , 7 6 5 बाइट्स

कोड:

3ãAŒÃ

स्पष्टीकरण:

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

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

यह सिर्फ सरासर प्रतिभा है ... मुझे एक चुनौती बनाने की कोशिश करनी होगी जो इस भाषा को सीमा तक धकेलती है ...;)

— वैलीवेस्ट

Answer 2

पायथन 3.5, 68 बाइट्स

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

जब वर्ण मान बहुत बड़ा हो जाता है, तो आउटपुट स्ट्रिंग्स प्रिंट करता है, और त्रुटि के साथ समाप्त होता है।

लगातार तीन के सभी तारों को उत्पन्न करता है और उन लोगों को प्रिंट करता है जो इनपुट शब्द का सबसेट हैं।

Answer 3

पायथ - 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

Answer 4

जेली , 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.

Answer 5

जावास्क्रिप्ट (ईएस 6), 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]5 बाइट बचाने के लिए @ETHproductions से ट्रिक उधार ली ।

Comments

संयोग undefinedसे एक घनिष्ठ शब्द है;)

— वैलीवेस्ट

parseInt(c,36)इसके बजाय क्यों c.charCodeAt()?

— टाइटस

@ मुझे लगता है कि इससे कोई फर्क नहीं पड़ता, मैं सिर्फ parseIntकोड गोल्फ में उपयोग करने के लिए उपयोग किया जाता हूं ।

— नील

Answer 6

पायथन 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)

Answer 7

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।

Comments

for($s=join(range(Z,z));$a=substr($s,++$i,3);)$ a बनाने का एक छोटा तरीका है। यह स्वीकार करता है कि विराम चिह्नों का एक गुच्छा और कुछ 2-वर्ण श्रृंखला भी है, लेकिन जैसा कि इनपुट केवल कम केस अक्षर हैं और इसके लिए यह आवश्यक है कि इसमें 3 वर्ण ठीक हों।

— user59178

for($a="ab ", $ i = 98; $ i <123;!) strstr (count_chars ($ argv [1], 3), $ एक = substr ($ एक, 1) .chr (++ $ i)) ?: प्रिंट "$ a,"; `2 बाइट्स बचाता है। बहुत अच्छा तरीका है, मैंने PHP में अन्य तरीकों की कोशिश की है, लेकिन आपके कोड तक नहीं पहुंच सकता है। मुझे यकीन नहीं है कि अगर आपको कॉमा के बाद एक जगह की आवश्यकता है

— Jörg Hülsermann

Answer 8

सी, 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);
}

सॉर्ट करते समय यह डुप्लिकेट मानों को 0s से बदल देता है, ये 0s शब्द की शुरुआत में सॉर्ट किए जाते हैं। लगातार मूल्यों की तलाश तो तुच्छ है।

Comments

साइट पर आपका स्वागत है!

— DJMcMayhem

हां, PPCG में आपका स्वागत है! आपके जवाब पर महान काम, सी गोल्फ में सबसे आसान में से एक नहीं है!

— वॉलीवेस्ट

Answer 9

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

Answer 10

हास्केल, 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'..]]उन्हें "abc"आगे से 3 लगातार पात्रों के सभी तारों में बदल देती है । हम पीछे की ओर बढ़ते हैं[pred$pred c..c][c..succ$succ c] उच्चतम यूनिकोड वर्ण का उत्तराधिकारी लेते समय त्रुटि से बचने के लिए आगे की बजाय बढ़ते हैं ।

ये त्रिक उन लोगों के लिए फ़िल्टर किए जाते हैं जो केवल इनपुट में अक्षरों का उपयोग करते हैं।

Answer 11

पर्ल, 36 बाइट्स

के लिए +1 शामिल है -n

STDIN पर इनपुट दें:

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

बस कोड:

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

Answer 12

टी-एसक्यूएल, 153 बाइट्स

पिछले TSQL जवाब के बाद लंबे समय से किया जा रहा है, WallyWest की टिप्पणी पर प्रतिक्रिया करने के लिए किया था। उत्तर आंशिक रूप से ब्रायन जे के उत्तर से प्रेरित था

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

बेला

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

Comments

यह चालाकी है! उस तालिका के बारे में भी नहीं जानते थे। अच्छी बात है कि 2048 से अधिक अक्षर लंबे समय तक नहीं हैं!

— ब्रायन जे

Answer 13

हास्केल, 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_", "_"]। फिर हम प्रत्येक स्ट्रिंग के तीन चार्ट तक ले जाते हैं और इसे बांधते हैं x। xइनपुट पैरामीटर में इसका हर अक्षर रखेंw ।

संपादित करें: @xnor ने 3 7 बाइट्स बचाए । धन्यवाद!

Comments

क्या किसी को पता है कि क्या मैं सूची के पहले तीन तत्वों को a:b:c:_@ -pattern से कैप्चर कर सकता हूं?

— nimi

मुझे @ -पाटन के बारे में पता नहीं है, लेकिन आप 'z'ऊपरी सीमा को हटा सकते हैं और इसे सभी पात्रों को आज़मा सकते हैं।

— xnor

उन पहले 3 तत्वों को पकड़ना वास्तव में कष्टप्रद है। सबसे अच्छा मैं देख सकता हूँ takeकि खाली स्ट्रिंग का उपयोग और हटाना है:f w=[x|x<-init$take 3<$>scanr(:)""['a'..],all(`elem`w)x]

— xnor

@xnor: अच्छा। हम scanr"से शुरू कर सकते हैं ।" इसके बजाय ""और छोड़ दें init$।

— nimi

Answer 14

टी-एसक्यूएल (एसक्यूएल सर्वर 2014), 217 बाइट्स

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)

प्रयोग

पहले वेरिएबल @ ए को किसी प्रकार के चार के रूप में घोषित करें और इनपुट को इस तरह असाइन करें

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

मैंने अपने कोड के हिस्से के रूप में घोषणा की गिनती नहीं की, लेकिन मुझे इनपुट के लिए एक sql मानक नहीं मिला, इसलिए मैं अपनी गिनती बदलने के लिए तैयार हूं

आउटपुट या तो प्रत्येक ट्रिपल के लिए एक पंक्ति होगी, या कोई पंक्तियाँ नहीं होगी यदि शब्द क्लोज़ निट नहीं है

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)

Comments

घोषणा को यह देखते हुए नहीं गिना जाएगा कि हम उस कोड के साथ काम कर रहे हैं जो इस उदाहरण में आवश्यक कार्यक्षमता पोस्ट-घोषणा को निष्पादित करने के लिए आवश्यक होगा। महान काम, एक समय हो गया है क्योंकि मैंने एक चुनौती के लिए एक एसक्यूएल समाधान देखा है। अच्छा कार्य!

— वैलीवेस्ट

मैंने आपकी पटकथा को 185 वर्णों तक गढ़ा है , यहाँ अनगढ़ संस्करण है। आप मेरे उत्तर को भी

— देखना चाहेंगे

Answer 15

आर, 220 बाइट्स

मेरा समाधान बहुत सीधा है। यह संभावित तीन अक्षर संयोजनों के माध्यम से लूप करता है, लगातार तीन पत्रों के खिलाफ दर्ज स्ट्रिंग के पात्रों के माध्यम से देखता है और उन्हें एक स्ट्रिंग में जोड़ता है। स्ट्रिंग तब केवल तब मुद्रित होती है जब तीन अक्षर मिलते हैं (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")
> > 

Answer 16

पायथन 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। उदाहरण के लिए,

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

इनपुट के लिए आउटपुट होगा HIJACKING। यह आउटपुट प्रारूप ओपी द्वारा ठीक होने की पुष्टि की गई है। तो केवल अपरकेस इनपुट प्रारूप है। हालाँकि, यदि आप केवल लोअरकेस में इनपुट करना चाहते हैं, तो बस इसके range(65,91)साथ बदलेंrange(97,123) , एक और बाइट जोड़ने।

सभी टेस्ट मामलों के साथ प्रतिकृति।

स्पष्टीकरण:

मूल रूप से यहाँ क्या हो रहा है:

1. एक सूची, Wका उपयोग करके बनाई गई है W=[*map(chr,range(65,91))], जिसमें अंग्रेजी वर्णमाला के सभी बड़े अक्षर हैं। इस वजह से, एक अपरकेस इनपुट हमेशा आवश्यक होता है।

2. प्रत्येक tuple के लिए, iएक सूची में, जिसे हम कॉल करेंगे U, जिसमें सभी तीन लगातार अक्षर tuples होंगे, अर्थात:

   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. एक बार जब सभी ट्यूपल्स पूरी तरह से जोड़ दिए गए मैचों के माध्यम से चले गए हैं, तो सूची को अंतिम आउटपुट के रूप में लौटा दिया गया है।

Answer 17

स्काला, 59 बाइट्स

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

स्पष्टीकरण:

(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

Answer 18

दरअसल, 13 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

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.

Answer 19

जावा 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;}

यह सबसे अधिक संभावना हो सकती है, लेकिन जावा में मूल रूप से सोचा गया था कि चुनौती बहुत कठिन थी।

अनगढ़ और परीक्षण के मामले:

इसे यहाँ आज़माएँ।

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 

Comments

बस यह पूछना है कि जावा क्यों? यह भाषाओं का सबसे गोल्फ नहीं है ...? निश्चित रूप से प्रयास के लिए +1 ...

— WallyWest

@WallyWest, मैं रोजमर्रा की जिंदगी में जावा डेवलपर हूं। और मुझे पता है कि मैं जावा को कैसे क्रिया के साथ कभी भी चुनौती नहीं दूंगा, लेकिन यह अभी भी जावा imho में कोडगॉल्फ के लिए मजेदार है। :)

— केविन क्रूज़सेन

लगता है बीमार के लिए निकट भविष्य में कुछ रचनात्मक कोड चुनौतियों के साथ आने के लिए भाग लेने के लिए :) अच्छा काम फिर भी है!

— वैलीवेस्ट

Answer 20

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, a char-ray, sorted और select -unique'd के रूप में डाली जाती है, फिर -joinएक स्ट्रिंग में एड करें, 2) -matchतीन अक्षर स्ट्रिंग्स (यानी, regex मिलान) के खिलाफ एड। यदि यह एक मैच है, तो शब्द में तीन-अक्षर स्ट्रिंग है, और इसलिए यह फ़िल्टर करता है |?। परिणाम पाइपलाइन पर छोड़ दिए गए हैं और आउटपुट निहित है।

उदाहरण

(ध्यान दें कि यहाँ आउटपुट स्पेस-सेपरेट है, क्योंकि हम आउटपुट को कॉनटेनटेशन द्वारा सख्त कर रहे हैं।)

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

Comments

महान व्याख्या। यदि संभव हो तो मैं आपको दो वोट देता।

— WallyWest

Answer 21

रेटिना, 106 56 बाइट्स

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

डेडुप्लिकेट, सॉर्ट करें। जोड़ें abc। पता लगाएं कि क्या सबस्ट्रिंग पाया गया है और यदि ऐसा है तो संलग्न करें। अगले विकल्प के लिए अनुवाद करें। दोहराएँ। फिर पहले दो पंक्तियों को हटा दें।

इसे ऑनलाइन आज़माएं

---

Naive solution:

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, सॉर्ट करें, फिर 3 अनुक्रमिक अक्षरों के आउटपुट ओवरलैपिंग मैच।

इसे ऑनलाइन आज़माएं

Comments

भोला समाधान बहुत सीधा लगता है ... हालांकि मुझे आपका गोल्फ समाधान बेहतर लगता है ... अच्छा किया!

— वैलीवेस्ट

Answer 22

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 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)एक सेट ऑब्जेक्ट बनाता है जिसमें स्ट्रिंग में प्रत्येक अद्वितीय वर्ण होता है। उदाहरण के लिए, 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])

यह चरित्र के लिए दो आइटम के साथ संक्षिप्त करने के लिए चरित्र 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

इसलिए, यदि बेस -36 में एक तीन-चार स्ट्रिंग 38 मॉड 1333 है, तो तीन वर्ण वर्णमाला में लगातार हैं।

टेस्ट स्निपेट

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>

Comments

यह जैसे gemऔर के लिए विफल रहता है mage।

— नील

तो आप कह रहे हैं कि हेक्साट्रिग्ज़िमल (बेस 36) से वापस परिवर्तित होने पर लगातार सभी अक्षर ट्रिपल 1333 के विरुद्ध 38 हो जाएंगे ... जो कि भयानक है!

— व्लादिवेस्ट

@ छह बाइट की कीमत पर तय किया गया।

— ETHproductions

मैंने आपकी !c[3]चाल को लागू किया जिसने मेरे ES6 उत्तर को आपके पिछले ES6 उत्तर की लंबाई तक नीचे ला दिया, इसलिए अब मैं आपके फ़ायरफ़ॉक्स 30+ उत्तर को भी समाप्त कर रहा हूँ। उसके लिए माफ़ करना।

— नील

@ नहीं मुझे कोई आपत्ति नहीं है :)

— ETHproductions

Answer 23

रैकेट 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))))))))))

Answer 24

माणिक , 50 बाइट्स

each_cons(3)वर्णमाला से लंबाई 3 के सभी लगातार उपविजेता प्राप्त करते हैं ?a..?z, फिर e&s.chars==eसेटवाइज चौराहे का उपयोग करके लक्ष्य स्ट्रिंग में सभी वर्णों का चयन करने के लिए उपयोग करें। सूचियों की सूची लौटाता है।

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

इसे ऑनलाइन आज़माएं!

Answer 25

[आर], ११० बाइट्स

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

मुझे यकीन है कि यह अभी भी गोल्फ है

Answer 26

जाप , 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