from itertools import cycle, islice
def fragmentar_ultra(texto):
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
frags = []
buf = ""
for c in texto:
buf += c
if c in delimitadores:
frags.append(buf)
buf = ""
frags.append(buf)
final = []
for f in frags:
final.extend(f.split("\n"))
ciclo = cycle(final)
return "\n".join(f"* {frag}" for frag in islice(ciclo, 50000))
from itertools import cycle, islice
def fragmentar_buffer(texto):
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
frags = []
buf = []
for c in texto:
buf.append(c)
if c in delimitadores:
frags.append("".join(buf))
buf = []
frags.append("".join(buf))
final = []
for f in frags:
final.extend(f.split("\n"))
ciclo = cycle(final)
return "\n".join(f"* {frag}" for frag in islice(ciclo, 50000))
from itertools import cycle, islice
def fragmentar_buffer(texto):
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
frags = []
buf = []
for c in texto:
buf.append(c)
if c in delimitadores:
frags.append("".join(buf))
buf = []
frags.append("".join(buf))
final = []
for f in frags:
final.extend(f.split("\n"))
ciclo = cycle(final)
return "\n".join(f"* {frag}" for frag in islice(ciclo, 50000))
for linha in fragmentar_lazy(texto):
print(linha)
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
#[pyfunction]
fn fragmentar_rust(texto: String) -> PyResult<String> {
let delimitadores = ['.', '?', '!', ';', ':', '—', '…'];
let mut frags = Vec::new();
let mut buf = String::new();
for c in texto.chars() {
buf.push(c);
if delimitadores.contains(&c) {
frags.push(buf.clone());
buf.clear();
}
}
frags.push(buf);
let mut final = Vec::new();
for f in frags {
for part in f.split('\n') {
final.push(part.to_string());
}
}
let mut out = String::new();
let mut count = 0;
for frag in final.iter().cycle() {
out.push_str("* ");
out.push_str(frag);
out.push('\n');
count += 1;
if count == 50000 {
break;
}
}
Ok(out)
}
#[pymodule]
fn fragmentar_rs(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(fragmentar_rust, m)?)?;
Ok(())
}
from itertools import cycle, islice
# ---------------------------------------------------------
# 1. Fragmentação sem regex (pontuação + preservação total)
# ---------------------------------------------------------
def fragmentar_sem_regex(texto):
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
fragmentos = []
buffer = ""
for char in texto:
buffer += char
if char in delimitadores:
fragmentos.append(buffer)
buffer = ""
fragmentos.append(buffer)
return fragmentos
# ---------------------------------------------------------
# 2. Fragmentação adicional por quebras de linha \n
# ---------------------------------------------------------
def fragmentar_por_n(fragmentos):
final = []
for frag in fragmentos:
final.extend(frag.split("\n")) # preserva vazios
return final
# ---------------------------------------------------------
# 3. Versão com módulo (%) — leve, mas não máxima performance
# ---------------------------------------------------------
def gerar_50000_modulo(fragmentos):
resultado = []
total = 50000
for i in range(total):
frag = fragmentos[i % len(fragmentos)]
resultado.append(f"* {frag}")
return "\n".join(resultado)
# ---------------------------------------------------------
# 4. Versão sem módulo (%) — máxima performance com cycle
# ---------------------------------------------------------
def gerar_50000_cycle(fragmentos):
ciclo = cycle(fragmentos)
linhas = [f"* {frag}" for frag in islice(ciclo, 50000)]
return "\n".join(linhas)
# ---------------------------------------------------------
# 5. Função final — pipeline completo ultra‑leve
# ---------------------------------------------------------
def gerar_50000_linhas(texto):
frag1 = fragmentar_sem_regex(texto)
frag2 = fragmentar_por_n(frag1)
return gerar_50000_cycle(frag2)
# ---------------------------------------------------------
# 6. Exemplo de uso
# ---------------------------------------------------------
if __name__ == "__main__":
texto = """
A sustentabilidade financeira depende de vários fatores.
A demografia exerce pressão crescente; o envelhecimento é crítico!
Reformas tornam-se inevitáveis: ajustamentos graduais são essenciais…
"""
saida = gerar_50000_linhas(texto)
print(saida)
from itertools import cycle, islice
def fragmentar_sem_regex(texto):
# Delimitadores lógicos
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
fragmentos = []
buffer = ""
# Fragmentação por pontuação (preserva tudo)
for char in texto:
buffer += char
if char in delimitadores:
fragmentos.append(buffer)
buffer = ""
# Preserva o que sobra
fragmentos.append(buffer)
# Fragmentação adicional por \n (preserva vazios)
fragmentos_final = []
for frag in fragmentos:
fragmentos_final.extend(frag.split("\n"))
return fragmentos_final
def gerar_50000_linhas(texto):
fragmentos = fragmentar_sem_regex(texto)
# ciclo infinito dos fragmentos → zero custo de módulo
ciclo_fragmentos = cycle(fragmentos)
# gerar exatamente 50k linhas com custo mínimo
linhas = [f"* {frag}" for frag in islice(ciclo_fragmentos, 50000)]
return "\n".join(linhas)
# Exemplo de uso:
texto = """
A sustentabilidade financeira depende de vários fatores.
A demografia exerce pressão crescente; o envelhecimento é crítico!
Reformas tornam-se inevitáveis: ajustamentos graduais são essenciais…
"""
saida = gerar_50000_linhas(texto)
print(saida)
def fragmentar_sem_regex(texto):
# Delimitadores lógicos
delimitadores = ['.', '?', '!', ';', ':', '—', '…']
fragmentos = []
buffer = ""
for char in texto:
buffer += char
if char in delimitadores:
fragmentos.append(buffer)
buffer = ""
# Se sobrar conteúdo no buffer, preserva
fragmentos.append(buffer)
# Agora fragmenta também por \n preservando tudo
fragmentos_final = []
for frag in fragmentos:
subfrags = frag.split("\n") # preserva vazios
fragmentos_final.extend(subfrags)
return fragmentos_final
def gerar_50000_linhas(texto):
fragmentos = fragmentar_sem_regex(texto)
resultado = []
total = 50000
for i in range(total):
frag = fragmentos[i % len(fragmentos)]
resultado.append(f"* {frag}")
return "\n".join(resultado)
# Exemplo de uso:
texto = """
A sustentabilidade financeira depende de vários fatores.
A demografia exerce pressão crescente; o envelhecimento é crítico!
Reformas tornam-se inevitáveis: ajustamentos graduais são essenciais…
"""
saida = gerar_50000_linhas(texto)
print(saida)
import re
from itertools import cycle, islice
padrao_pontuacao = re.compile(r'(?<=[\.\?\!;:\—…])\s+')
def fragmentar_logico_50000_pontuacao_e_n(texto):
# Fragmentação por pontuação (preserva tudo)
fragmentos_pontuacao = padrao_pontuacao.split(texto)
# Fragmentação adicional por \n (preserva vazios)
fragmentos_finais = []
for frag in fragmentos_pontuacao:
fragmentos_finais.extend(frag.split("\n"))
# Gera 50k linhas com custo mínimo
linhas = [f"* {frag}" for frag in islice(cycle(fragmentos_finais), 50000)]
return "\n".join(linhas)
padrao_pontuacao = re.compile(r'(?<=[\.\?\!;:\—…])\s+')
fragmentos = padrao_pontuacao.split(texto)
resultado.append(f"* {frag}")
from itertools import cycle, islice
linhas = [f"* {frag}" for frag in islice(cycle(fragmentos), 50000)]
resultado.append(...)
"\n".join(resultado)
with open("texto.txt", "r") as f:
texto = f.read()
