Finding a Protein Motif

File FormatsProteomics

Descrizione

Un motivo proteico può essere rappresentato con una notazione abbreviata: [XY] significa "X oppure Y", {X} significa "qualsiasi amminoacido tranne X". Il motivo di N-glicosilazione è scritto come N{P}[ST]{P}. Le sequenze proteiche vanno recuperate dal database UniProt a partire dagli ID forniti.

Given

Al massimo 15 ID di accesso UniProt.

Return

Per ogni proteina che possiede il motivo di N-glicosilazione, l'ID di accesso seguito dall'elenco delle posizioni nella stringa proteica in cui il motivo è stato trovato.

Sample Dataset

A2Z669
B5ZC00
P07204_TRBM_HUMAN
P20840_SAG1_YEAST

Sample Output

B5ZC00
85 118 142 306 395
P07204_TRBM_HUMAN
47 115 116 382 409
P20840_SAG1_YEAST
79 109 135 248 306 348 364 402 485 501 614

Nota tecnica (aggiornamento rispetto alla pagina originale)

La pagina Rosalind fa riferimento al vecchio endpoint http://www.uniprot.org/uniprot/{id}.fasta, ormai deprecato. Lo script in questa cartella è stato aggiornato per usare il nuovo endpoint REST: https://rest.uniprot.org/uniprotkb/{accession}.fasta, estraendo solo la parte prima dell'eventuale underscore dall'ID (es. "P07204" da "P07204_TRBM_HUMAN"), perché il nuovo endpoint accetta solo l'accession pura.

La mia esecuzione

08/24/2026 11:24:47

Input · dataset.txt

P01878_ALC_MOUSE
P01880_DTC_HUMAN
P81447_MPP3_CAPHI
Q8P5E4
P80069_A45K_MYCBO
Q1E9Q9
Q706D1
P17967
P24000
Q3BRP8
P29460_I12B_HUMAN
Q0TMT1
P49286
P01189_COLI_HUMAN
P02974_FMM1_NEIGO

Output · run_log.txt

P01878_ALC_MOUSE
38 99 314 329
P01880_DTC_HUMAN
225 316 367
P81447_MPP3_CAPHI
96
P80069_A45K_MYCBO
7 161
Q1E9Q9
185 255 347 640 1326
P17967
82 117 155 174 425
P29460_I12B_HUMAN
125 135 222 303
P49286
4 130
P01189_COLI_HUMAN
91
P02974_FMM1_NEIGO
67 68 121

Esegui nel browser

Non disponibile per questo problema: Usa "regex", non disponibile (o inaffidabile per rete/CORS) in un runtime Python nel browser.

Mostra il codice sorgente (problem.py)

#http://rosalind.info/problems/mprt/

#pip install regex 
import regex
import requests


def lettura(filename):
    data = []
    with open(filename) as f:
        for riga in f:
            if len(riga) > 1:
                riga = riga.rstrip("\n")
                data.append(riga)
    return data

def get_text(prot):
    accession = prot.split("_")[0]
    url = f"https://rest.uniprot.org/uniprotkb/{accession}.fasta"
    r = requests.get(url)
    if r.status_code == 200:
       text = r.text
       start = text.index("\n")
       text = text[start:].replace("\n", "")
       return text

def find_all(text):
    #[result = [str(m.start()+1) for m in regex.finditer(r"N[^P][ST][^P]", text)]

    p = regex.compile(r"N[^P][ST][^P]")
    result = []
    index = 0
    while True:
       m = p.search(text[index:])
       if m is not None:
          index += m.span()[0] + 1
          result.append(str(index))
       else:
          break   
    return result

data = lettura("dataset.txt")
for prot in data:
    text = get_text(prot)
    result = find_all(text)
    if len(result) > 0:
       print(prot)
       print(" ".join(result))

Soluzione JavaScript

Esegui ora, live

Mostra il codice sorgente

// Finding a Protein Motif (Rosalind ID: MPRT) - soluzione JavaScript
// indipendente, non una trascrizione di problem.py: stessa logica (per
// ogni accession UniProt, scarica la sequenza FASTA e cerca tutte le
// occorrenze - anche sovrapposte - del motivo N-glicosilazione
// N{P}[ST]{P}), riscritta in modo idiomatico per JS.
//
// Due differenze tecniche rispetto all'originale:
// 1. fetch() al posto di requests - stessa richiesta HTTP, ma nel
//    browser dipende dal supporto CORS di rest.uniprot.org. Se
//    l'endpoint blocca richieste cross-origin, questa soluzione fallirà
//    con un errore di rete (non è un bug della logica, è un limite
//    dell'ambiente browser rispetto a un client Python locale).
// 2. Ricerca di match sovrapposti: problem.py cerca "a mano" scorrendo
//    l'indice di 1 posizione alla volta dopo ogni match; qui uso una
//    regex con lookahead (?=...) e flag globale, che trova le stesse
//    posizioni sovrapposte in un solo passaggio - risultato identico,
//    tecnica diversa.
//
// Contratto: riceve il contenuto testuale di dataset.txt, restituisce
// l'output testuale (stessa forma dell'output Python).
const MOTIVO = /(?=N[^P][ST][^P])/g;

function lettura(datasetText) {
  return datasetText
    .split("\n")
    .map((r) => r.replace(/\r$/, ""))
    .filter((riga) => riga.length > 0);
}

async function getText(prot) {
  const accession = prot.split("_")[0];
  const url = `https://rest.uniprot.org/uniprotkb/${accession}.fasta`;
  const r = await fetch(url);
  if (!r.ok) return null;
  const text = await r.text();
  const start = text.indexOf("\n");
  return text.slice(start).replace(/\n/g, "");
}

function findAll(text) {
  if (!text) return [];
  const result = [];
  for (const m of text.matchAll(MOTIVO)) {
    result.push(String(m.index + 1));
  }
  return result;
}

export default async function solve(datasetText) {
  const data = lettura(datasetText);

  if (data.length === 0) {
    throw new Error("Input non valido: nessuna accession UniProt trovata");
  }

  const righeOutput = [];
  for (const prot of data) {
    const text = await getText(prot);
    const result = findAll(text);
    if (result.length > 0) {
      righeOutput.push(prot);
      righeOutput.push(result.join(" "));
    }
  }

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