introduzione

Secondo il post di Rand Al'Thor nel Puzzle enigmatico , una parola affiatata è qualsiasi parola che contiene tre lettere in ordine alfabetico (in qualsiasi ordine).

Parole come l'istruzione , corno da nebbia e cabaret sono tutti considerati parole affiatate, mentre parole come l'apprendimento , clacson e svolgono non sono parole molto unita.

Sfida

La sfida è quella di programmare un golf in grado di prendere una singola parola come input (assunto in minuscolo, a tutti gli effetti) e di restituire un output che (se disponibile) elenca tutti i set di lettere consecutivi (anche in minuscolo) se è una parola affiatata e vuota se non è una parola affiatata.

Esempi

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

Regole

1. Mentre l'input deve essere assunto come una singola parola in minuscolo e l'output deve essere in minuscolo, la natura dell'output varierà in base alla scelta del linguaggio di codifica. Seleziona una forma di output che si adatti meglio alla natura della sfida, che si tratti di STDOUT, output del file, array, ecc.
2. Poiché si tratta di code-golf, sarà il caso in cui il numero più basso di byte sarà il chiaro vincitore.
3. Nessuna scappatoia sciocca .
4. Non accetterò le risposte che hanno le lettere consecutive in ordine non alfabetico ... Quindi cabnon saranno considerate un risultato adatto cabaret, per esempio.
5. Nota speciale, mentre le "terzine" non devono necessariamente essere in ordine alfabetico, ma i caratteri all'interno delle terzine devono essere ... quindi nel caso della parola "performance", ad esempio, l'output mno,nopsarà accettato, come sarà nop,mno. Nel caso della parola "dirottamento", ci sono sei modi che le triplette di ghi, hije ijkpossono essere disposti in un elenco, e tutti e sei permutazioni sono accettabili come uscita.

A parte questo, sui tuoi marchi, preparati, golf!

05AB1E , 7 6 5 byte

Codice:

3ãAŒÃ

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo 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)

Stampa le stringhe di output e termina con errori quando il valore del carattere diventa troppo grande.

Genera tutte le stringhe di tre consecutive e stampa quelle che sono un sottoinsieme della parola di input.

Pyth - 11 10 8 7 byte

Metodo della forza super bruta.

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

Gelatina , 7 byte

ØaẆfṗ3$

Questo è un collegamento monadico. Provalo online!

Come funziona

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

I valori mancanti vengono concatenati come undefined, quindi la stringa risultante contiene più di 3 caratteri. Ho preso in prestito il !c[3]trucco da @ETHproductions per salvare 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,";

accetta input come argomento della riga di comando; stampa una virgola finale. corri con -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);}

rientrato:

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

Durante l'ordinamento sostituisce i valori duplicati con 0, questi 0 vengono ordinati all'inizio della parola. Cercare i valori consecutivi è quindi banale.

MATL , 13 byte

2Y23YCtjmAZ)!

Provalo 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'..]]

Genera tutte le triple di tre caratteri consecutivi, prende quelle che usano solo lettere nell'input.

53 byte:

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

L'elenco ['c'..]contiene tutti i caratteri Unicode da in 'c'poi. La comprensione dell'elenco [[pred$pred c..c]|c<-['c'..]]li trasforma in tutte le stringhe di 3 caratteri consecutivi da quel momento in "abc"poi. Facciamo un passo indietro con [pred$pred c..c]invece di avanti con [c..succ$succ c]per evitare un errore quando si prende il successore del carattere unicode più alto.

Queste triple sono filtrate per quelle che usano solo lettere nell'input.

Perl, 36 byte

Include +1 per -n

Dare input su STDIN:

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

Solo il codice:

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

T-SQL, 153 byte

Ho dovuto reagire al commento di WallyWest, in quanto è passato molto tempo dall'ultima risposta TSQL. La risposta è stata in parte ispirata dalla risposta di Brian J.

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

Violino

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

Haskell, 63 60 52 byte

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

Esempio di utilizzo: f "hijacking"-> ["ghi","hij","ijk"].

scanr(:)"_"['a'..]crea un elenco con le code dell'elenco di tutti i caratteri unicode che iniziano con 'a'e lo fa terminare con un '_', cioè ["abcde...\1114111_", "bcde...\1114111_", "cde...\1114111_", ..., "\1114109\1114110\1114111_", "\1114110\1114111_", "\1114111_", "_"]. Quindi prendiamo fino a tre caratteri di ogni stringa e lo leghiamo a x. Mantieni tutte le xlettere che si trovano nel parametro di input w.

Modifica: @xnor ha salvato 3 7 byte. Grazie!

T-SQL (SQL Server 2014), 217 byte

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)

uso

Per prima cosa dichiarare la variabile @a come carattere di qualche tipo e assegnare l'input in questo modo

declare @a varchar(max) = 'pneumoultramicroscopicsilicovolcanoconiosis'

Non ho conteggiato la dichiarazione come parte del mio codice, ma non ho trovato uno standard sql per l'input, quindi sono disposto a cambiare il mio conteggio

L'output sarà una riga per ogni tripla o nessuna riga se la parola non è molto simile

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)

R, 220 byte

La mia soluzione è piuttosto semplice. Passa attraverso le possibili combinazioni di tre lettere, passa attraverso e controlla i caratteri della stringa inserita rispetto alle tre lettere consecutive e li aggiunge a una stringa. La stringa viene quindi stampata solo quando vengono trovate tre lettere (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:])]

Una funzione lambda anonima. Accetta l'input come una stringa maiuscola e genera una matrice di tuple, con quelle piene di tre caratteri maiuscoli che rappresentano tutti i set di 3lettere consecutive che compaiono nell'input. Per esempio,

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

sarebbe l'output per l'input HIJACKING. Questo formato di output è stato confermato come corretto da OP. Quindi ha l'unico formato di input maiuscolo. Tuttavia, se si desidera inserire solo lettere minuscole, è sufficiente sostituirlo range(65,91)con range(97,123), aggiungendo un altro byte.

Repl.it con tutti i casi di test!

Spiegazione:

Fondamentalmente ciò che sta accadendo qui è:

1. Viene Wcreato un elenco, W=[*map(chr,range(65,91))]che contiene tutte le lettere maiuscole dell'alfabeto inglese. Per questo motivo, è sempre richiesto un input maiuscolo .

2. Per ogni tupla, iin un elenco, che chiameremo U, contenente tutte e tre le tuple di lettere consecutive, ovvero:

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

   creato da zip(W,W[1:],W[2:]), ognuno iviene completamente aggiunto all'elenco di output fintanto che tutti gli elementi nella versione impostata di i( {*i}) si trovano nella versione impostata di input X( {*X}), ovvero {*X}>={*i}, cioè Xè un superset di i. Altrimenti, la versione vuota di i( ()) viene aggiunta all'elenco.

3. Una volta che tutte le tuple sono state completate con le corrispondenze completamente aggiunte, l'elenco viene restituito come output finale.

Scala, 59 byte

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

Spiegazione:

(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

In realtà, 13 byte

Suggerimenti di golf benvenuti. Provalo online!

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

Molto probabilmente questo può essere giocato a golf, ma la sfida è stata molto più dura di quanto pensassi inizialmente in Java ..

Casi non testati e test:

Provalo qui.

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

Produzione:

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

Sembra molto più lungo del necessario, ma non riesco a giocarlo più.

Accetta input $n. Loops da 97a 120, costruzione di contigui stringhe di tre lettere - che è, fino alla |?, avremo abc, bcd, cde, ecc sul gasdotto. Quindi viene inserito attraverso un Where-Object(il |?) per estrarre solo quegli elementi in cui la clausola è vera. Qui, la clausola è 1) la stringa di input $n, lanciata come un chararray, sorted e select -unique'd, quindi -joinrimessa in una stringa, 2) -matched rispetto alle stringhe di tre lettere (cioè, regex matching). Se è una corrispondenza, la stringa di tre lettere è nella parola e quindi filtra attraverso |?. I risultati vengono lasciati in cantiere e l'output è implicito.

Esempi

(Nota che qui l'output è separato dallo spazio, poiché stiamo restringendo l'output per concatenazione.)

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`.*¶?

Deduplica, ordina. Aggiungi abc. Cerca se la sottostringa viene trovata e aggiungi in tal caso. Traduci alla sottostringa successiva. Ripetere. Quindi rimuovere le prime due righe.

Provalo online

Soluzione ingenua:

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

Deduplica, ordina, quindi genera corrispondenze sovrapposte di 3 lettere sequenziali.

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

Questo si presta a una versione ES6 a 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)

Come funziona

Il primo grosso pezzo della funzione è questo:

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

new Set(string)crea un oggetto Set che contiene uno di ogni carattere univoco nella stringa. Ad esempio, new Set("foghorn")tornerà Set ["f", "o", "g", "h", "r", "n"]. Possiamo convertirlo in un array con [... ], quindi ordinarlo con il built-in .sort(). Questo si trasforma "foghorn"in ["f", "g", "h", "n", "o", "r"].

Il prossimo passo è questo:

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

Questo mappa ogni arpione cnella aserie al personaggio concatenato con i due elementi successivi. Ad esempio ["f", "g", "h", "n", "o", "r"] => ["fgh", "ghn", "hno", "nor", "orundefined", "rundefinedundefined"],. ( undefinedViene visualizzato quando si tenta di accedere a un membro inesistente dell'array.

Il passaggio finale è il filtro:

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

Innanzitutto, !c[3]&è di escludere eventuali stringhe che contengono undefined. Ciò è necessario perché un bug fa sì che il seguente algoritmo venga conteggiato, ad esempio, gmundefinedcome una tripletta consecutiva.

Tutte le stringhe di tre caratteri consecutivi, quando interpretate come numeri in base 36, sono 38 modulo 1333. L'ho capito dal seguente calcolo:

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

Pertanto, se una stringa di tre caratteri è 38 mod 1333 in base-36, i tre caratteri sono consecutivi nell'alfabeto.

Test snippet

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>

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

test:

(f "education")

Produzione:

cde

Versione dettagliata:

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

Rubino , 50 byte

each_cons(3)ottiene tutte le liste secondarie consecutive di lunghezza 3 dall'alfabeto ?a..?z, quindi usa e&s.chars==eper selezionare solo quelle che hanno tutti i caratteri nella stringa target usando l'intersezione tra due. Restituisce un elenco di elenchi.

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

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

Sono sicuro che è ancora golfabile

Japt , 10 9 byte

;Cã3 fUá3

Provalo o esegui tutti i casi di 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