Calcolatore LCS
Trovi la sequenza di caratteri più lunga che due stringhe condividono nello stesso ordine, anche con salti: ABCBDAB e BDCABA ne condividono 4, per esempio BCBA. Ottiene la lunghezza e una sottosequenza valida da controllare a occhio. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Stringa A
- ABCBDAB
- Stringa B
- BDCABA
- Len a
- 7
- Len b
- 6
- Lunghezza
- 4
- Sottosequenza
- BCBA
Il problema della sottosequenza comune più lunga chiede la sequenza di caratteri più lunga che compare nello stesso ordine in due stringhe di ingresso, senza richiedere contiguità. È il fondamento di programmazione dinamica degli strumenti di diff per righe, degli aiuti di merge nel controllo di versione, dei rilevatori di plagio che tollerano riordini rumorosi e del confronto di sequenze biologiche quando inserzioni e cancellazioni contano più di una sottostringa esatta. Questo calcolatore di sottosequenza comune più lunga accetta due stringhe, riempie una tabella classica delle lunghezze in tempo lineare rispetto al prodotto delle lunghezze, ricostruisce un LCS valido con backtracking e restituisce sia la lunghezza numerica sia la stringa della sottosequenza. Gli input vuoti sono validi e producono lunghezza zero.
Cos'è (e cosa non è) una sottosequenza comune più lunga
Una sottosequenza di una stringa è qualsiasi stringa ottenuta cancellando zero o più caratteri senza riordinare i superstiti. Una sottosequenza comune di due stringhe è una stringa che è sottosequenza di entrambe. Una sottosequenza comune più lunga, o LCS, è qualsiasi sottosequenza comune la cui lunghezza è massima tra tutte le sottosequenze comuni.
A differenza di una sottostringa comune più lunga, un LCS non deve occupare un blocco contiguo in nessuno degli input: la coppia classica ABCBDAB e BDCABA ammette diverse stringhe LCS di lunghezza quattro, come BCBA e BDAB, a seconda dei pareggi scelti dalla ricostruzione. Gli algoritmi di diff e gli strumenti di allineamento del DNA si basano su questa nozione non contigua perché le modifiche reali inseriscono e cancellano simboli invece di far scorrere solo una finestra fissa.
La lunghezza di un LCS è un punteggio di similarità utile; i caratteri ricostruiti servono quando Lei vuole uno scheletro di allineamento esplicito accanto al punteggio. Non restituisce ogni LCS possibile, script di modifica o percentuali di similarità—sono problemi separati costruiti sulla stessa idea di tabella DP.
Dove la sottosequenza comune è davvero utile
I corsi di informatica e i giudici online hanno bisogno di un oracolo di riferimento che restituisca una lunghezza corretta e una sottosequenza valida per stringhe corte arbitrarie senza che gli studenti incollino soluzioni in un IDE completo. Le funzioni di prodotto vicine al diff—riepiloghi di modifiche, indizi di conflitto di merge, allineamento di righe di log—spesso vogliono la lunghezza LCS come segnale di similarità economico prima di un passaggio più pesante di distanza di edit.
Le demo didattiche di bioinformatica usano stringhe dell'alfabeto DNA giocattolo (A, C, G, T) per mostrare come inserzioni e cancellazioni lasciano comunque un lungo scheletro condiviso. Tenga le stringhe sotto il tetto di lunghezza, fissi la sottosequenza ricostruita nei test se le interessa quale tra più risposte ugualmente lunghe ottiene, e otterrà risultati LCS riproducibili senza montare una libreria numerica propria.
Casi d'uso
Compiti di algoritmi e demo di lezione
Fornisca agli studenti due stringhe corte e verifichi sia la lunghezza LCS sia che la sottosequenza restituita compaia davvero in ordine in ciascun input.
Valutazione automatica LMS e gare
Corregga compiti di DP con un oracolo deterministico che rifiuta input non validi e non inventa mai una sottosequenza più lunga di quanto consenta la tabella classica.
Pre-controlli di diff e similarità di sequenze
Valuti la struttura ordinata condivisa tra due testi o stringhe DNA giocattolo prima di una pipeline più pesante di distanza di edit o allineamento.
Domande frequenti
LCS è la stessa cosa della sottostringa comune più lunga?
No. Una sottostringa deve essere contigua; una sottosequenza può saltare caratteri. Questo calcolatore risolve il problema di sottosequenza con programmazione dinamica classica.
Quali sono i limiti di lunghezza e le regole per le stringhe vuote?
Ogni stringa può avere al massimo 500 caratteri. Le stringhe vuote sono consentite e producono length 0 con sottosequenza vuota.
Perché due stringhe possono avere più sottosequenze comuni più lunghe?
Perché i pareggi sono frequenti. ABCBDAB e BDCABA ne condividono diverse di lunghezza 4, come BCBA e BDAB. Il calcolatore ne restituisce una e scioglie i pareggi sempre allo stesso modo, quindi la stessa coppia dà sempre la stessa risposta.
A cosa serve la lunghezza della LCS?
Funziona come misura di somiglianza economica. Riepiloghi delle modifiche, suggerimenti di fusione e allineamento dei log possono usarla prima di un calcolo di distanza più pesante, e le dimostrazioni con le lettere del DNA mostrano come sopravvive un lungo tratto comune.
Come verifico che la sottosequenza restituita sia corretta?
Controlli che i suoi caratteri compaiano nello stesso ordine in entrambe le stringhe, saltando gli altri, e che la lunghezza coincida con quella indicata. BCBA supera la prova in ABCBDAB e in BDCABA, ed è così che si correggono le risposte.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/dev/longest-common-subsequence \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"string_a":"ABCBDAB","string_b":"BDCABA"}'const res = await fetch("https://api.kit.forhosting.com/dev/longest-common-subsequence", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"string_a": "ABCBDAB",
"string_b": "BDCABA"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/longest-common-subsequence",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"string_a": "ABCBDAB",
"string_b": "BDCABA"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/longest-common-subsequence", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"string_a":"ABCBDAB","string_b":"BDCABA"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"string_a":"ABCBDAB","string_b":"BDCABA"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/longest-common-subsequence", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"string_a": "ABCBDAB",
"string_b": "BDCABA"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.longest_common_subsequence",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Contratto di input, algoritmo, forma della risposta e limiti
La complessità è O(m·n) in tempo e O(m·n) in memoria nella forma ingenua di tabella usata qui—adatta al tetto di lunghezza, volutamente semplice per la didattica e goldens deterministici. Invii con POST un corpo JSON con due campi stringa obbligatori: string_a e string_b (sono accettati gli alias a, s1, first, text_a e b, s2, second, text_b). Entrambi possono essere vuoti; entrambi devono essere vere stringhe JSON, non numeri o array. Campi mancanti, tipi non stringa e input troppo lunghi falliscono con invalid_input e non vengono fatturati. In caso di successo il corpo ripete string_a e string_b, riporta len_a e len_b e include length (la lunghezza LCS) più subsequence (una stringa LCS, eventualmente vuota). Internamente il solver alloca una tabella di interi (m+1) per (n+1), imposta dp[i][j] a dp[i-1][j-1]+1 quando i prefissi coincidono sull'ultimo carattere, altrimenti il massimo delle celle sopra e a sinistra, poi cammina dall'angolo in basso a destra: una coppia coincidente aggiunge quel carattere e avanza in diagonale; in caso di pareggio preferisce salire (scartare da string_a) così l'istanza ricostruita è stabile tra i runtime.
Dove un'API LCS produce valore concreto
I correttori automatici LMS possono chiamare l'API con coppie fisse e affermare sia la lunghezza sia che la sottosequenza restituita è sottosequenza di ciascun input, catturando bug di tabella di uno che falliscono solo su casi vuoti o di un solo carattere. Poiché l'implementazione è parse pura di livello A, ogni chiamata riuscita costa il prezzo base pubblicato $0.002 senza token di modello e senza rete in uscita.
Domande tecniche
Come si calcola la sottosequenza comune più lunga di due stringhe?
Invii string_a e string_b come stringhe JSON. L'API restituisce length (lunghezza LCS) e subsequence (una sottosequenza comune massimale), oltre agli input ripetuti e alle loro lunghezze.
Quale LCS viene restituito quando ne esistono diversi?
Qualsiasi LCS di lunghezza massimale è corretto. Questa implementazione usa un backtrack fisso (preferire di scartare da string_a in caso di pareggio) così gli stessi input producono sempre la stessa stringa di sottosequenza.
Quanto costa il calcolatore di sottosequenza comune più lunga?
Lo strumento nel browser è gratis. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l'input non valido non viene fatturato.