Enable Javascript in your browser and then refresh this page, for a much enhanced experience.
a spoonful of oop solution in Clear category for Sequence Analyzer by rybld2
from typing import List, Tuple, Optional
class Chaine:
ALPHABET_SIZE: int = 26
ASCII_Z: int = 90
def __init__(self, seq: str):
self.seq: str = seq
self._pas: int
self._raison: int
self._pas, self._raison = self.progression()
self._blocs: List[str] = self._determiner_blocs()
self._dep: str = self._blocs[-1]
self._progs: List[int] = self._determiner_progs()
@property
def pas(self) -> int:
return self._pas
@property
def raison(self) -> int:
return self._raison
@property
def dep(self) -> str:
return self._dep
@dep.setter
def dep(self, value: str) -> None:
self._dep = value
def progression(self) -> Tuple[int, int]:
if len(set(self.seq)) == 1:
return 1, 0
lis: List[int] = [ord(c) for c in self.seq]
for k in range(1, 6):
r: Optional[int] = self._calculer_raison(lis, k)
if r is not None:
return k, r
raise ValueError("Aucune progression arithmétique trouvée")
def _calculer_raison(self, s: List[int], pas: int = 1) -> Optional[int]:
raison: int = s[pas] - s[0] if s[pas] - s[0] > 0 else s[pas] - s[0] + self.ALPHABET_SIZE
for i in range(pas, len(s) - pas, pas):
diff: int = s[i + pas] - s[i]
if diff <= 0:
diff += self.ALPHABET_SIZE
if diff != raison:
return None
return raison
def _determiner_blocs(self) -> List[str]:
return [self.seq[i * self._pas:(i + 1) * self._pas] for i in range(len(self.seq) // self._pas)]
def _determiner_progs(self) -> List[int]:
progs: List[int] = []
for j in range(self._pas):
diff: int = ord(self._blocs[1][j]) - ord(self._blocs[0][j])
if diff <= 0:
diff += self.ALPHABET_SIZE
progs.append(diff)
return progs
def extrait(self, pas: int) -> str:
if pas == 1:
return ""
return ''.join([self.seq[i] for i in range(0, len(self.seq), pas)])
def suivant(self) -> str:
res: str = ""
for i, t in enumerate(self._dep):
plu: int = ord(t) + self._progs[i]
if plu > self.ASCII_Z:
plu -= self.ALPHABET_SIZE
res += chr(plu)
self._dep = res
return res
def generer_suite(self, longueur: int) -> str:
res: str = ""
for _ in range(longueur):
res += self.suivant()
return res
def analyzer(seq: str) -> str:
chaine: Chaine = Chaine(seq)
return chaine.generer_suite(len(seq) // chaine.pas)
Feb. 9, 2025
