Mots serrés


22

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!


La sortie peut-elle être un tableau de caractères 2D avec chaque ensemble de trois lettres consécutives dans une colonne ?
Luis Mendo

@LuisMendo Pouvez-vous me donner un exemple juste pour que je puisse le visualiser?
WallyWest

Essayez mon code sans la finale !Et avec un autre mot, car l'actuel donne le même résultat :-)
Luis Mendo

@LuisMendo est la colonne MATL majeure ou quelque chose?
Maltysen

1
Une sortie au format d'un tableau de tuples est-elle correcte, c'est-à-dire que la sortie pour pneumoniapeut l'être [('m','n','o'),('n','o','p')])?
R. Kap

Réponses:


8

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!


Ce n'est qu'un pur génie ... Je vais devoir essayer de créer un défi qui pousse cette langue à la limite ...;)
WallyWest

10

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.


8

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

7

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.

7

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.


2
Par coïncidence, undefinedc'est un mot très
uni

Pourquoi parseInt(c,36)au lieu de c.charCodeAt()?
Titus

@Titus Je suppose que cela ne fait aucune différence, je suis juste habitué à utiliser parseIntdu code golf.
Neil

4

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)

4

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.


1
for($s=join(range(Z,z));$a=substr($s,++$i,3);)est un moyen plus court de créer $ a. Il vérifie certes un tas de ponctuation et aussi certaines séries de 2 caractères, mais comme l'entrée est en lettres minuscules uniquement et il nécessite qu'il trouve 3 caractères, ce qui est bien.
user59178

for($a="ab ", $ i = 98; $ i <123;)! strstr (count_chars ($ argv [1], 3), $ a = substr ($ a, 1) .chr (++ $ i))?: imprimer "$ a,"; `économise 2 octets. Très belle façon, j'ai essayé d'autres méthodes en PHP mais je n'arrive pas à atteindre les octets de votre code. Je ne sais pas si vous avez besoin d'un espace après la virgule
Jörg Hülsermann

4

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.


1
Bienvenue sur le site!
DJMcMayhem

1
Oui, bienvenue chez PPCG! Excellent travail sur votre réponse, C n'est pas l'un des plus faciles à jouer au golf!
WallyWest

3

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

3

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.


3

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$&})^/

3

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

1
C'est malin! Je ne connaissais même pas cette table. Heureusement qu'il n'y a pas de mots de plus de 2048 lettres!
Brian J

2

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!


Est-ce que quelqu'un sait si je peux capturer les trois premiers éléments de la liste a:b:c:_avec un @-motif?
nimi

Je ne connais pas le @-motif, mais vous pouvez supprimer la 'z'limite supérieure et laisser simplement essayer tous les caractères.
xnor

Capturer ces 3 premiers éléments est vraiment ennuyeux. Le mieux que je puisse voir est simplement d'utiliser takeet de supprimer la chaîne vide:f w=[x|x<-init$take 3<$>scanr(:)""['a'..],all(`elem`w)x]
xnor

@xnor: sympa. nous pouvons commencer le scanr"." au lieu de ""et omettre le init$.
nimi

2

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)

la déclaration ne serait pas comptée vu que nous avons affaire au code qui serait requis pour exécuter la fonctionnalité requise post-déclaration dans ce cas. Excellent travail, cela fait un moment que je n'ai pas vu de solution SQL pour un défi. Bon travail!
WallyWest

J'ai joué votre script à 185 caractères, voici la version non golfée. Vous pouvez consulter ma réponse aussi bien
t-clausen.dk

2

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

2

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.


2

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

2

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.

1

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 

Il suffit de demander pourquoi Java? Ce n'est pas la langue la plus jouable ...? +1 pour l'effort bien sûr ...
WallyWest

1
@WallyWest Eh bien, je suis un développeur Java au quotidien. Et je sais que je ne gagnerai jamais aucun défi avec la façon dont Java est verbeux, mais c'est toujours amusant de coder le golf en Java à mon humble avis. :)
Kevin Cruijssen

1
Je suppose que je vais devoir proposer quelques défis créatifs de code dans un avenir proche pour que vous puissiez participer :) bon travail quand même!
WallyWest

1

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

Grande explication. Je vous donnerais deux votes si possible.
WallyWest

1

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


La solution naïve semble assez simple ... bien que j'aime mieux votre solution golfée ... bravo!
WallyWest

1

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


Cela échoue pour des mots tels que gemet mage.
Neil

Vous dites donc que tous les triplets de lettres consécutifs lorsqu'ils sont reconvertis à partir d'hexatrigesimal (base 36) sont 38 lorsqu'ils sont modifiés contre 1333 ... c'est vraiment génial!
WallyWest

@Neil Fixé au coût de six octets.
ETHproductions

Je me suis approprié votre !c[3]astuce qui a réduit ma réponse ES6 à la longueur de votre réponse ES6 précédente, alors maintenant je surpasse même votre réponse Firefox 30+. Désolé pour ça.
Neil

@Neil ça ne me dérange pas :)
ETHproductions

1

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

1

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!


1

[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


En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.