AI fragmentação de linhas com múltiplas pontuacoes e prompt \n para gerar 50000 strings com quebra e AI esquecer funções

 

import re

def fragmentar_logico_50000_pontuacao_e_n(texto):

    # 1) Fragmentação por múltiplas pontuações (sem remover espaços)

    padrao_pontuacao = r'(?<=[\.\?\!;:\—…])\s+'

    fragmentos_pontuacao = re.split(padrao_pontuacao, texto)

    # 2) Fragmentação adicional por quebras de linha \n

    fragmentos_finais = []

    for frag in fragmentos_pontuacao:

        subfrags = frag.split("\n")  # preserva vazios

        fragmentos_finais.extend(subfrags)

    # NÃO remover espaços

    # NÃO remover fragmentos vazios

    # NÃO fazer strip()

    resultado = []

    total = 50000

    # 3) Gerar 50k linhas, repetindo fragmentos conforme necessário

    for i in range(total):

        frag = fragmentos_finais[i % len(fragmentos_finais)]

        resultado.append(f"* {frag}")

    return "\n".join(resultado)

# Exemplo de uso:

texto = """

A sustentabilidade financeira dos sistemas de pensões depende de vários fatores.  

A demografia exerce pressão crescente; o envelhecimento populacional é crítico!

Reformas paramétricas tornam-se inevitáveis: ajustamentos graduais são essenciais…

Mas a aceitação pública pode ser um desafio — especialmente em contextos de austeridade?

"""

saida = fragmentar_logico_50000_pontuacao_e_n(texto)

print(saida)

import re

def fragmentar_logico_50000_preservar(texto):

    # Delimitadores lógicos (sem remover espaços ou vazios)

    padrao = r'(?<=[\.\?\!;:\—…])\s+'

    # Fragmentação lógica preservando tudo

    fragmentos = re.split(padrao, texto)

    resultado = []

    total = 50000

    # Gera 50k linhas, repetindo fragmentos conforme necessário

    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 dos sistemas de pensões depende de vários fatores.  

A demografia exerce pressão crescente; o envelhecimento populacional é crítico!    

Reformas paramétricas tornam-se inevitáveis: ajustamentos graduais são essenciais…

Mas a aceitação pública pode ser um desafio — especialmente em contextos de austeridade?

"""

saida = fragmentar_logico_50000_preservar(texto)

print(saida)

import re

def fragmentar_multiplas_pontuacoes_preservar(texto):

    # Delimitadores lógicos

    padrao = r'(?<=[\.\?\!;:\—…])\s+'

    # Divide o texto mantendo espaços e entradas vazias

    fragmentos = re.split(padrao, texto)

    # NÃO remover espaços

    # NÃO remover fragmentos vazios

    # NÃO fazer strip()

    return fragmentos

# Exemplo de uso:

texto = """

A sustentabilidade financeira dos sistemas de pensões depende de vários fatores.  

A demografia exerce pressão crescente; o envelhecimento populacional é crítico!    

Reformas paramétricas tornam-se inevitáveis: ajustamentos graduais são essenciais…

Mas a aceitação pública pode ser um desafio — especialmente em contextos de austeridade?

"""

fragmentos = fragmentar_multiplas_pontuacoes_preservar(texto)

for f in fragmentos:

    print("*", f)

import re

def fragmentar_multiplas_pontuacoes(texto):

    # Delimitadores lógicos

    padrao = r'(?<=[\.\?\!;:\—…])\s+'

    

    # Divide o texto com base em múltiplos sinais de pontuação

    fragmentos = re.split(padrao, texto.strip())

    

    # Limpa fragmentos vazios

    fragmentos = [f.strip() for f in fragmentos if f.strip()]

    

    return fragmentos

# Exemplo de uso:

texto = """

A sustentabilidade financeira dos sistemas de pensões depende de vários fatores.

A demografia exerce pressão crescente; o envelhecimento populacional é crítico!

Reformas paramétricas tornam-se inevitáveis: ajustamentos graduais são essenciais…

Mas a aceitação pública pode ser um desafio — especialmente em contextos de austeridade?

"""

fragmentos = fragmentar_multiplas_pontuacoes(texto)

for f in fragmentos:

    print("*", f)

def fragmentar_50000(texto):

    linhas_originais = texto.split()

    resultado = []

    total = 50000

    # Se o texto tiver poucas palavras, repete-as ciclicamente

    for i in range(total):

        palavra = linhas_originais[i % len(linhas_originais)]

        resultado.append(f"* {palavra}")

    return "\n".join(resultado)

# Exemplo de uso:

texto = "Este é um exemplo de texto para fragmentação académica."

saida = fragmentar_50000(texto)

print(saida)

def fragmentar_50000(texto):

    linhas_originais = texto.split()

    resultado = []

    total = 50000

    # Se o texto tiver poucas palavras, repete-as ciclicamente

    for i in range(total):

        palavra = linhas_originais[i % len(linhas_originais)]

        resultado.append(f"* {palavra}")

    return "\n".join(resultado)

# Exemplo de uso:

texto = "Este é um exemplo de texto para fragmentação académica."

saida = fragmentar_50000(texto)

print(saida)

Example Buffer Overflow escape AI attack

 

def fragmentar_numerado(texto):

    partes = texto.split("\n\n")

    resultado = []

    for i, p in enumerate(partes, start=1):

        resultado.append(f"{i}. {p.strip()}")

    return "\n\n".join(resultado)

texto = """

Introdução ao tema.

Desenvolvimento da ideia principal.

Segunda secção com análise crítica.

Conclusão final.

"""

print(fragmentar_numerado(texto))

import re

def fragmentar_frases(texto):

    frases = re.split(r'(?<=[.!?])\s+', texto)

    return "\n".join(frases)

texto = "Este é um exemplo. O objetivo é fragmentar logicamente. Para fins académicos."

print(fragmentar_frases(texto))

def analisar_linhas(texto):

    linhas = texto.split("\n")

    resultado = []

    for i, linha in enumerate(linhas, start=1):

        resultado.append(f"Linha {i}: {linha}\nComentário: [insere análise aqui]\n")

    return "\n".join(resultado)

texto = """A primeira linha do texto.

A segunda linha contém outra ideia.

A terceira linha fecha o argumento."""

print(analisar_linhas(texto))

def fragmentar_academico(texto):

    partes = texto.split("\n\n")  # separa por parágrafos duplos

    resultado = []

    for i, p in enumerate(partes, start=1):

        resultado.append(f"{i}. {p.strip()}\n")

    return "\n".join(resultado)

texto = """

Introdução ao tema.

Desenvolvimento da ideia principal.

Segunda secção com análise crítica.

Conclusão final.

"""

print(fragmentar_academico(texto))

import re

def fragmentar_por_frases(texto):

    frases = re.split(r'(?<=[.!?])\s+', texto)

    return "\n".join(frases)

texto = "Este é um exemplo. O objetivo é fragmentar logicamente. Para fins académicos."

print(fragmentar_por_frases(texto))

# Exemplo Académico: Carregamento Total em Memória

def ler_conteudo_total(caminho_ficheiro):

    try:

        with open(caminho_ficheiro, 'r', encoding='utf-8') as ficheiro:

            # .read() lê o ficheiro completo de uma só vez

            conteudo_completo = ficheiro.read()

            

        print(f"Sucesso! Foram lidos {len(conteudo_completo)} caracteres.")

        return conteudo_completo

        

    except FileNotFoundError:

        print("Erro: O ficheiro de testes não foi encontrado.")

        return None

# Demonstração

# conteudo = ler_conteudo_total("dados_ac

ademicos.txt")

def carregar_linhas_na_memoria(caminho_ficheiro):

    try:

        with open(caminho_ficheiro, 'r', encoding='utf-8') as ficheiro:

            # Cria uma lista com todas as linhas instantaneamente

            lista_de_linhas = ficheiro.readlines()

            

        print(f"Sucesso! O ficheiro contém {len(lista_de_linhas)} linhas carregadas em memória.")

        return lista_de_linhas

        

    except FileNotFoundError:

        return []

import os

import sys

import psutil

def obter_memoria_processo():

    """Retorna a memória RAM atual usada por este script em Megabytes (MB)."""

    processo = psutil.Process(os.getpid())

    # memory_info().rss representa o Resident Set Size (memória real na RAM)

    memoria_bytes = processo.memory_info().rss

    return memoria_bytes / (1024 * 1024)

def teste_impacto_memoria():

    print("--- INÍCIO DO EXPERIMENTO ACADÉMICO ---")

    

    # 1. Medição Inicial (Baseline)

    memoria_inicial = obter_memoria_processo()

    print(f"Uso de RAM Inicial: {memoria_inicial:.2f} MB")

    

    # 2. Simulação de Leitura de Bloco Massivo (Ex: 50 Milhões de Caracteres)

    # Criamos uma string longa para simular o carregamento de um ficheiro grande de uma só vez

    print("\n[AÇÃO] A carregar string longa para a memória...")

    string_massiva = "A" * 50_000_000

    

    # 3. Medição Após o Carregamento

    memoria_final = obter_memoria_processo()

    print(f"Uso de RAM Final: {memoria_final:.2f} MB")

    

    # 4. Cálculo do Impacto

    consumo_real = memoria_final - memoria_inicial

    tamanho_objeto_sys = sys.getsizeof(string_massiva) / (1024 * 1024)

    

    print("\n--- RESULTADOS DA ANÁLISE ---")

    print(f"• Impacto total medido no Processo: {consumo_real:.2f} MB")

    print(f"• Tamanho exato do objeto string (via sys.getsizeof): {tamanho_objeto_sys:.2f} MB")

if __name__ == "__main__":

    teste_impacto_memoria()