introduction

Selon le post de Rand Al'Thor dans Puzzling SE, un mot à mailles serrées est un mot qui contient trois lettres alphabétiques consécutives (dans n'importe quel ordre).

Des mots comme l' éducation , la corne de brume et le cabaret sont tous considérés comme des mots à mailles serrées alors que des mots comme apprendre , klaxon et performer ne sont pas des mots à mailles serrées.

Défi

Le défi consiste à coder au golf un programme capable de prendre un seul mot en entrée (supposé en minuscules, à toutes fins utiles) et de renvoyer une sortie qui (si disponible) répertorie tous les jeux de lettres consécutifs (également en minuscules) si elle est un mot à mailles serrées, et une sortie vide s'il ne s'agit pas d'un mot à mailles serrées.

Exemples

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

Règles

1. Alors que l'entrée doit être supposée être un seul mot en minuscule et la sortie doit être en minuscule, la nature de la sortie variera selon le choix de votre langue de codage. Veuillez sélectionner une forme de sortie qui conviendra le mieux à la nature du défi, que ce soit STDOUT, sortie de fichier, tableau, etc.
2. Parce qu'il s'agit de code-golf, ce sera le cas du plus petit nombre d'octets qui sera clairement le gagnant.
3. Pas de failles idiotes .
4. Je n'accepterai pas les réponses qui ont les lettres consécutives dans un ordre non alphabétique ... Donc, cabje ne serai pas considéré comme une sortie appropriée pour cabaret, par exemple.
5. Remarque spéciale, alors que les "triplets" ne doivent pas nécessairement être dans l'ordre alphabétique, mais les caractères à l'intérieur des triplets doivent être ... donc dans le cas du mot "performance", par exemple, la sortie mno,nopsera acceptée, comme il le fera nop,mno. Dans le cas du mot « détournement d' avion », il y a six façons que les triplets de ghi, hijet ijkpourraient être organisées dans une liste, et les six permutations sont acceptables en sortie.

A part ça, à vos marques, prêt, golf!

05AB1E , 7 6 5 octets

Code:

3ãAŒÃ

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Python 3.5, 68 octets

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

Imprime les chaînes de sortie et se termine avec une erreur lorsque la valeur de caractère devient trop grande.

Génère toutes les chaînes de trois consécutives et imprime celles qui sont un sous-ensemble du mot d'entrée.

Pyth - 11 10 8 7 octets

Méthode de super force brute.

@^z3.:G

Suite de tests .

@            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

Gelée , 7 octets

ØaẆfṗ3$

Ceci est un lien monadique. Essayez-le en ligne!

Comment ça marche

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

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>

Les valeurs manquantes concaténent en tant que undefined, donc la chaîne résultante contient plus de 3 caractères. J'ai emprunté l' !c[3]astuce à @ETHproductions pour économiser 5 octets.

Python 3.5, 78 octets

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 octets

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

prend l'entrée comme argument de ligne de commande; imprime une virgule de fin. courir avec -r.

C, 175 174 octets

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

dentelé:

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

Lors du tri, il remplace les valeurs en double par des 0, ces 0 sont triés au début du mot. La recherche des valeurs consécutives est alors triviale.

MATL , 13 octets

2Y23YCtjmAZ)!

Essayez-le en ligne!

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 octets

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

Génère tous les triplets de trois caractères consécutifs, prend ceux qui n'utilisent que des lettres en entrée.

53 octets:

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

La liste ['c'..]contient tous les caractères Unicode à 'c'partir de maintenant. La compréhension de la liste les [[pred$pred c..c]|c<-['c'..]]transforme en toutes les chaînes de 3 caractères consécutifs à "abc"partir de maintenant. Nous reculons avec [pred$pred c..c]au lieu d'avancer avec [c..succ$succ c]pour éviter une erreur lors de la prise du successeur du caractère unicode le plus élevé.

Ces triplets sont filtrés pour ceux qui n'utilisent que des lettres dans l'entrée.

Perl, 36 octets

Comprend +1 pour -n

Donnez votre avis sur STDIN:

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

Juste le code:

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

T-SQL, 153 octets

J'ai dû réagir au commentaire de WallyWest, à savoir que cela faisait longtemps depuis la dernière réponse TSQL. La réponse a été en partie inspirée par la réponse de 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

Violon

Non golfé:

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 octets

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

Exemple d'utilisation: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]construit une liste avec la queue de la liste de tous les caractères unicode commençant par 'a'et la laisse se terminer par a '_', c'est-à-dire ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Ensuite, nous prenons jusqu'à trois caractères de chaque chaîne et la lions à x. Gardez tout xoù se trouve chaque lettre dans le paramètre d'entrée w.

Modifier: @xnor a enregistré 3 7 octets. Merci!

T-SQL (SQL Server 2014), 217 octets

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)

Usage

Déclarez d'abord la variable @a comme un caractère quelconque et affectez l'entrée comme ceci

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Je n'ai pas compté la déclaration comme faisant partie de mon code, mais je n'ai pas trouvé de standard sql pour la saisie, donc je suis prêt à changer mon comptage

La sortie sera soit une ligne pour chaque triple, soit aucune ligne si le mot n'est pas serré

Non golfé

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 octets

Ma solution est assez simple. Il parcourt les combinaisons de trois lettres possibles, parcourt et vérifie les caractères de la chaîne entrée par rapport aux trois lettres consécutives et les ajoute à une chaîne. La chaîne n'est alors imprimée que lorsque trois lettres sont trouvées (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))}}}}

entrée sortie

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

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

Une fonction lambda anonyme. Prend l'entrée en tant que chaîne majuscule et génère un tableau de tuples, ceux remplis de trois caractères majuscules représentant tous les ensembles de 3lettres consécutives qui apparaissent dans l'entrée. Par exemple,

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

serait la sortie pour l'entrée HIJACKING. Ce format de sortie a été confirmé par OP. A donc le seul format d'entrée en majuscules. Cependant, si vous souhaitez entrer uniquement en minuscules, remplacez simplement range(65,91)par range(97,123)en ajoutant un octet de plus.

Repl.it avec tous les cas de test!

Explication:

Fondamentalement, ce qui se passe ici est:

1. Une liste,, West créée à l'aide de W=[*map(chr,range(65,91))], qui contient toutes les lettres majuscules de l'alphabet anglais. Pour cette raison, une entrée en majuscule est toujours requise.

2. Pour chaque tuple, idans une liste, que nous appellerons U, contenant les trois tuples de lettres consécutifs, c'est-à-dire:

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

   créé par zip(W,W[1:],W[2:]), chacun iest entièrement ajouté à la liste de sortie tant que tous les éléments de la version définie de i( {*i}) sont dans la version définie de input X( {*X}), c'est {*X}>={*i}-à-dire que Xc'est un sur - ensemble de i. Sinon, la version vide de i( ()) est ajoutée à la liste.

3. Une fois que tous les tuples ont été traités avec les correspondances entièrement ajoutées, la liste est renvoyée en tant que sortie finale.

Scala, 59 octets

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

Non golfé:

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

Explication:

(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

En fait, 13 octets

Suggestions de golf bienvenues. Essayez-le en ligne!

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 octets

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

Cela peut très probablement être joué au golf, mais le défi était beaucoup plus difficile que je ne le pensais à l'origine à Java ..

Cas non testés et testés:

Essayez-le ici.

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

Sortie:

cde 
fgh 
abc 
ghi hij ijk 
mno nop 



abc bcd cde def efg fgh ghi hij ijk jkl klm 

PowerShell v2 +, 93 octets

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

Je me sens beaucoup plus longtemps que nécessaire, mais je n'arrive pas à jouer au golf plus loin.

Prend des informations $n. Les boucles de 97la 120, la construction des chaînes contiguës de trois lettres - qui est, jusqu'à la |?, nous aurons abc, bcd, cde, etc. sur le pipeline. Ensuite, cela passe par un Where-Object(le |?) pour ne retirer que les éléments où la clause est vraie. Ici, la clause est 1) la chaîne d'entrée $n, charconvertie en un tableau, sorted et select -unique'd, puis éditée de -joinnouveau dans une chaîne, 2) -matchéditée contre les chaînes de trois lettres (c.-à-d. Correspondance regex). Si c'est une correspondance, alors la chaîne de trois lettres est dans le mot, et donc elle filtre à travers le|? . Les résultats sont laissés sur le pipeline et la sortie est implicite.

Exemples

(Notez qu'ici, la sortie est séparée par des espaces, car nous stringifions la sortie par concaténation.)

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

Rétine, 106 56 octets

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

Dédupliquer, trier. Ajouter abc. Trouvez si la sous-chaîne est trouvée et ajoutez-la si oui. Traduire à la sous-chaîne suivante. Répéter. Supprimez ensuite les deux premières lignes.

Essayez-le en ligne

Solution naïve:

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

Dédupliquer, trier, puis produire des correspondances superposées de 3 lettres séquentielles

Essayez-le en ligne

JavaScript (Firefox 48), 93 octets

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]

Cela se prête à une version ES6 de 96 octets :

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)

Comment ça marche

Le premier bloc majeur de la fonction est le suivant:

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

new Set(string)crée un objet Set qui contient un de chaque caractère unique dans la chaîne. Par exemple, new Set("foghorn")reviendra Set ["f", "o", "g", "h", "r", "n"]. Nous pouvons convertir cela en un tableau avec [... ], puis le trier avec le intégré .sort(). Cela se transforme "foghorn"en["f", "g", "h", "n", "o", "r"] .

La prochaine étape est la suivante:

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

Cela met en correspondance chaque personnage cdu agroupe avec le personnage concaténé avec les deux éléments suivants. Par exemple ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"],. (Leundefined s s'affichent lorsque vous essayez d'accéder à un membre inexistant du tableau.

La dernière étape consiste à filtrer:

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

Tout d'abord, le !c[3]&est d'exclure toutes les chaînes qui contiennent undefined. Ceci est nécessaire car un bogue fait que l'algorithme suivant compte par exemple gmundefinedcomme un triplet consécutif.

Toutes les chaînes de trois caractères consécutifs, lorsqu'elles sont interprétées comme des nombres en base 36, sont 38 modulo 1333. Je l'ai compris par le calcul suivant:

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

Par conséquent, si une chaîne de trois caractères est 38 mod 1333 en base-36, les trois caractères sont consécutifs dans l'alphabet.

Extrait de test

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>

Raquette 237 octets

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

Essai:

(f "education")

Sortie:

cde

Version détaillée:

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

Rubis , 50 octets

each_cons(3)obtient toutes les sous-listes consécutives de longueur 3 de l'alphabet ?a..?z, puis utilisez e&s.chars==epour sélectionner uniquement celles qui ont tous les caractères dans la chaîne cible en utilisant l'intersection setwise. Renvoie une liste de listes.

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

Essayez-le en ligne!

[R], 110 octets

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

Je suis sûr que c'est toujours jouable au golf

Japt , 10 9 octets

;Cã3 fUá3

Essayez-le ou exécutez tous les cas de test

;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