← Catalogo
LEXF
PyJS

Enumerating k-mers Lexicographically

String Algorithms

Pagina originale su rosalind.info

Descrizione

Dato un alfabeto con un ordine prestabilito, il problema chiede di enumerare tutte le stringhe di lunghezza n formabili da quell'alfabeto, in ordine lessicografico (come nel dizionario).

Given

Una collezione di al massimo 10 simboli che definiscono un alfabeto ordinato, e un intero positivo n (n ≤ 10).

Return

Tutte le stringhe di lunghezza n che possono essere formate dall'alfabeto, in ordine lessicografico (secondo l'ordine standard dei simboli dell'alfabeto inglese).

Sample Dataset

A C G T
2

Sample Output

AA
AC
AG
AT
CA
CC
CG
CT
GA
GC
GG
GT
TA
TC
TG
TT

La mia esecuzione

08/24/2026 11:24:47

Input · dataset.txt

A B C D E F
3

Output · run_log.txt

OK
AAA
AAB
AAC
AAD
AAE
AAF
ABA
ABB
ABC
ABD
ABE
ABF
ACA
ACB
ACC
ACD
ACE
ACF
ADA
ADB
ADC
ADD
ADE
ADF
AEA
AEB
AEC
AED
AEE
AEF
AFA
AFB
AFC
AFD
AFE
AFF
BAA
BAB
BAC
BAD
BAE
BAF
BBA
BBB
BBC
BBD
BBE
BBF
BCA
BCB
BCC
BCD
BCE
BCF
BDA
BDB
BDC
BDD
BDE
BDF
BEA
BEB
BEC
BED
BEE
BEF
BFA
BFB
BFC
BFD
BFE
BFF
CAA
CAB
CAC
CAD
CAE
CAF
CBA
CBB
CBC
CBD
CBE
CBF
CCA
CCB
CCC
CCD
CCE
CCF
CDA
CDB
CDC
CDD
CDE
CDF
CEA
CEB
CEC
CED
CEE
CEF
CFA
CFB
CFC
CFD
CFE
CFF
DAA
DAB
DAC
DAD
DAE
DAF
DBA
DBB
DBC
DBD
DBE
DBF
DCA
DCB
DCC
DCD
DCE
DCF
DDA
DDB
DDC
DDD
DDE
DDF
DEA
DEB
DEC
DED
DEE
DEF
DFA
DFB
DFC
DFD
DFE
DFF
EAA
EAB
EAC
EAD
EAE
EAF
EBA
EBB
EBC
EBD
EBE
EBF
ECA
ECB
ECC
ECD
ECE
ECF
EDA
EDB
EDC
EDD
EDE
EDF
EEA
EEB
EEC
EED
EEE
EEF
EFA
EFB
EFC
EFD
EFE
EFF
FAA
FAB
FAC
FAD
FAE
FAF
FBA
FBB
FBC
FBD
FBE
FBF
FCA
FCB
FCC
FCD
FCE
FCF
FDA
FDB
FDC
FDD
FDE
FDF
FEA
FEB
FEC
FED
FEE
FEF
FFA
FFB
FFC
FFD
FFE
FFF

Esegui nel browser · Pyodide

Mostra il codice sorgente (problem.py)
from itertools import product


def lettura(filename):
    with open(filename) as f:
         s = f.readline().replace(" ","").replace("\n","")
         k = f.readline().replace(" ","")
         return (s, int(k))
         
         
def main():
    s, k  = lettura("dataset.txt")
    for p in product(s, repeat = k):
        print("".join(p)) 
             
             
if __name__ == "__main__":
    # execute only if run as a script
    main()    

Soluzione JavaScript

Esegui ora, live

Mostra il codice sorgente
// Enumerating k-mers Lexicographically (Rosalind ID: LEXF) - soluzione
// JavaScript indipendente, non una trascrizione di problem.py: stessa
// logica (prodotto cartesiano dell'alfabeto dato, ripetuto k volte,
// nell'ordine dei simboli così come appaiono nell'input), riscritta in
// modo idiomatico per JS.
//
// L'ordine di generazione (ricorsione che, ad ogni livello, scorre i
// simboli nell'ordine dato) riproduce esattamente quello di
// itertools.product(s, repeat=k): l'ultimo carattere varia più
// velocemente, il primo più lentamente.
//
// Contratto: riceve il contenuto testuale di dataset.txt, restituisce
// l'output testuale (stessa forma dell'output Python).
function* prodotto(simboli, k) {
  if (k === 0) {
    yield "";
    return;
  }
  for (const s of simboli) {
    for (const resto of prodotto(simboli, k - 1)) {
      yield s + resto;
    }
  }
}

export default function solve(datasetText) {
  const righe = datasetText.split("\n");
  const simboli = (righe[0] ?? "").trim().split(/\s+/).filter(Boolean);
  const k = Number((righe[1] ?? "").trim());

  if (simboli.length === 0 || !Number.isInteger(k) || k < 1) {
    throw new Error("Input non valido: attesi un alfabeto di simboli e un intero k >= 1");
  }

  const risultati = [];
  for (const p of prodotto(simboli, k)) {
    risultati.push(p);
  }

  return risultati.join("\n") + "\n";
}