fork download 
  1. import re
  2.  
  3.  
  4. def main():
  5.     ass_main = le_assinatura()
  6.     textos_main = le_textos()
  7.     matriz_ass = calcula_assinatura(textos_main)
  8.     ass_comparadas = compara_assinatura(ass_main, matriz_ass)
  9.     copiah = avalia_textos(textos_main, ass_comparadas) + 1
  10.     return print("O autor do texto", copiah, "está infectado com COH-PIAH.")
  11.  
  12.  
  13. def le_assinatura():
  14.     """
  15.     A funcao le os valores dos tracos linguisticos do modelo e devolve uma
  16.     assinatura a ser comparada com os textos fornecidos.
  17.     """
  18.     print("Bem-vindo ao detector automático de COH-PIAH.")
  19.  
  20.     tam_m_pal = float(input("Entre o tamanho medio de palavra:"))
  21.     type_token = float(input("Entre a relação Type-Token:"))
  22.     h_lego = float(input("Entre a Razão Hapax Legomana:"))
  23.     tam_m_sent = float(input("Entre o tamanho médio de sentença:"))
  24.     compx_med = float(input("Entre a complexidade média da sentença:"))
  25.     tam_m_frase = float(input("Entre o tamanho medio de frase:"))
  26.  
  27.     return [tam_m_pal, type_token, h_lego, tam_m_sent, compx_med, tam_m_frase]
  28.  
  29.  
  30. def le_textos():
  31.     i = 1
  32.     textos = []
  33.     texto = input("Digite o texto " + str(i) + "(aperte enter para sair):")
  34.     while texto:
  35.         textos.append(texto)
  36.         i += 1
  37.         texto = input("Digite o texto " + str(i) + "(aperte enter para sair):")
  38.  
  39.     return textos
  40.  
  41.  
  42. def calcula_assinatura(texto):
  43.     """
  44.     Essa funcao recebe um texto e deve devolver a assinatura
  45.     do texto.
  46.     """
  47.     if type(texto) != list:
  48.         aux = texto
  49.         texto = []
  50.         texto.append(aux)
  51.     matriz_ass_input = []
  52.     for i in texto:
  53.         sentencas = []
  54.         sentencas = separa_sentencas(str(i))  # sent.. = lista comum, ~matriz
  55.         frases = []
  56.         num_tot_sentencas = 0
  57.         soma_cat_sentencas = 0
  58.         for i in range(len(sentencas)):
  59.             frase_i = separa_frases(str(sentencas[i]))
  60.             frases.append(frase_i)  # frases = matriz, lista de listas
  61.             num_tot_sentencas += 1
  62.             soma_cat_sentencas = soma_cat_sentencas + len(sentencas[i])
  63.         palavras = []
  64.         num_tot_frases = 0
  65.         soma_cat_frases = 0
  66.         for lin in range(len(frases)):
  67.             for col in range(len(frases[lin])):
  68.                 palavra_i = separa_palavras(str(frases[lin][col]))
  69.                 palavras.append(palavra_i)  # palav.. = matriz, lista de listas
  70.                 num_tot_frases += 1
  71.                 soma_cat_frases = soma_cat_frases + len(str(frases[lin][col]))
  72.         mtrx_para_lista = []  # transform.. palavras de matriz para lista
  73.         for lin in range(len(palavras)):
  74.             for col in range(len(palavras[lin])):
  75.                 mtrx_para_lista.append(palavras[lin][col])
  76.         palavras = mtrx_para_lista[:]
  77.         soma_comp_palavras = 0
  78.         num_tot_palavras = 0
  79.         for lin in range(len(palavras)):
  80.             for col in range(len(palavras[lin])):
  81.                 soma_comp_palavras = soma_comp_palavras + len(str(palavras[lin][col]))
  82.             num_tot_palavras += 1
  83.         ass_txt = []
  84.         ass_txt.append(tam_m_pal(soma_comp_palavras, num_tot_palavras))
  85.         ass_txt.append(type_token(palavras, num_tot_palavras))
  86.         ass_txt.append(h_lego(palavras, num_tot_palavras))
  87.         ass_txt.append(tam_m_sent(soma_cat_sentencas, num_tot_sentencas))
  88.         ass_txt.append(compx_med(num_tot_frases, num_tot_sentencas))
  89.         ass_txt.append(tam_m_frase(soma_cat_frases, num_tot_frases))
  90.         matriz_ass_input.append(ass_txt)
  91.     return matriz_ass_input  # matriz, lista de listas dos valores das assina..
  92.  
  93.  
  94.  
  95. def tam_m_pal(soma_comp_palavras, num_tot_palavras):
  96.     if num_tot_palavras != 0:
  97.         tam_m_pal = soma_comp_palavras / num_tot_palavras
  98.     else:
  99.         tam_m_pal = 0
  100.     return tam_m_pal
  101.  
  102.  
  103. def type_token(lista_palavras, num_tot_palavras):
  104.     num_pal_dif = n_palavras_diferentes(lista_palavras)
  105.     if num_tot_palavras != 0:
  106.         type_token = num_pal_dif / num_tot_palavras
  107.     else:
  108.         type_token = 0
  109.     return type_token
  110.  
  111.  
  112. def h_lego(lista_palavras, num_tot_palavras):
  113.     num_pal_uni = n_palavras_unicas(lista_palavras)
  114.     if num_tot_palavras != 0:
  115.         h_lego = num_pal_uni / num_tot_palavras
  116.     else:
  117.         h_lego = 0
  118.     return h_lego
  119.  
  120.  
  121. def tam_m_sent(soma_num_cat, num_sent):
  122.     if num_sent != 0:
  123.         tam_m_sent = soma_num_cat / num_sent
  124.     else:
  125.         tam_m_sent = 0
  126.     return tam_m_sent
  127.  
  128.  
  129.  
  130. def compx_med(num_tot_frases, num_tot_sentencas):
  131.     if num_tot_sentencas != 0:
  132.         compx_med = num_tot_frases / num_tot_sentencas
  133.     else:
  134.         compx_med = 0
  135.     return compx_med
  136.  
  137.  
  138. def tam_m_frase(soma_cat_frases, num_tot_frases):
  139.     if num_tot_frases != 0:
  140.         tam_m_frase = soma_cat_frases / num_tot_frases
  141.     else:
  142.         tam_m_frase = 0
  143.     return tam_m_frase
  144.  
  145.  
  146. def separa_sentencas(texto):
  147.     """
  148.     A funcao recebe um texto e devolve uma lista das sentencas dentro
  149.     do texto.
  150.     """
  151.     sentencas = re.split(r'[.!?]+', texto)
  152.     if sentencas[-1] == '':
  153.         del sentencas[-1]
  154.     return sentencas
  155.  
  156.  
  157. def separa_frases(sentenca):
  158.     """
  159.     A funcao recebe uma sentenca e devolve uma lista das frases dentro
  160.     da sentenca.
  161.     """
  162.     return re.split(r'[,:;]+', sentenca)
  163.  
  164.  
  165. def separa_palavras(frase):
  166.     """
  167.     A funcao recebe uma frase e devolve uma lista das palavras dentro
  168.     da frase.
  169.     """
  170.     return frase.split()
  171.  
  172.  
  173. def n_palavras_unicas(lista_palavras):
  174.     """
  175.     Essa funcao recebe uma lista de palavras e devolve o numero de palavras
  176.     que aparecem uma unica vez.
  177.     """
  178.     freq = dict()
  179.     unicas = 0
  180.     for palavra in lista_palavras:
  181.         p = palavra.lower()
  182.         if p in freq:
  183.             if freq[p] == 1:
  184.                 unicas -= 1
  185.             freq[p] += 1
  186.         else:
  187.             freq[p] = 1
  188.             unicas += 1
  189.  
  190.     return unicas
  191.  
  192.  
  193. def n_palavras_diferentes(lista_palavras):
  194.     """
  195.     Essa funcao recebe uma lista de palavras e devolve o numero de palavras
  196.     diferentes utilizadas.
  197.     """
  198.     freq = dict()
  199.     for palavra in lista_palavras:
  200.         p = palavra.lower()
  201.         if p in freq:
  202.             freq[p] += 1
  203.         else:
  204.             freq[p] = 1
  205.  
  206.     return len(freq)
  207.  
  208.  
  209. def compara_assinatura(ass_main, matriz_ass_input):
  210.     """
  211.     Essa funcao recebe duas assinaturas de texto e deve devolver o grau de
  212.     similaridade nas assinaturas.
  213.     """
  214.     lista_Sab = []
  215.     soma_mod = 0
  216.     if type(matriz_ass_input[0]) is list:
  217.         for lin in range(len(matriz_ass_input)):
  218.             for col in range(len(matriz_ass_input[lin])):
  219.                 soma_mod += abs(ass_main[col] - matriz_ass_input[lin][col])
  220.             Sab = soma_mod / 6
  221.             lista_Sab.append(Sab)
  222.         return lista_Sab
  223.     else:
  224.         for i in range(len(matriz_ass_input)):
  225.             soma_mod += abs(ass_main[i] - matriz_ass_input[i])
  226.         Sab = soma_mod / 6
  227.         return Sab
  228.  
  229.  
  230. def avalia_textos(textos_main, ass_comparadas):
  231.     """
  232.     Essa funcao recebe uma lista de textos e deve devolver o numero (0 a n-1)
  233.     do texto com maior probabilidade de ter sido infectado por COH-PIAH.
  234.     """
  235.     aux_ass_com = ass_comparadas[:]
  236.     aux_ass_com.sort()
  237.     for indice in range(len(ass_comparadas)):
  238.         if aux_ass_com[0] == ass_comparadas[indice]:
  239.             copiah = indice
  240.     return copiah
  241.  
  242. main()
Success #stdin #stdout 0.02s 27752KB
comments (?)
stdin 
4.79
0.72
0.56
80.5
2.5
31.6
Navegadores antigos tinham uma frase gloriosa:"Navegar é preciso; viver não é preciso". Quero para mim o espírito [d]esta frase, transformada a forma para a casar como eu sou: Viver não é necessário; o que é necessário é criar. Não conto gozar a minha vida; nem em gozá-la penso. Só quero torná-la grande,ainda que para isso tenha de ser o meu corpo e a (minha alma) a lenha desse fogo. Só quero torná-la de toda a humanidade;ainda que para isso tenha de a perder como minha. Cada vez mais assim penso.Cada vez mais ponho da essência anímica do meu sangueo propósito impessoal de engrandecer a pátria e contribuirpara a evolução da humanidade.É a forma que em mim tomou o misticismo da nossa Raça.
Voltei-me para ela; Capitu tinha os olhos no chão. Ergueu-os logo, devagar, e ficamos a olhar um para o outro... Confissão de crianças, tu valias bem duas ou três páginas, mas quero ser poupado. Em verdade, não falamos nada; o muro falou por nós. Não nos movemos, as mãos é que se estenderam pouco a pouco, todas quatro, pegando-se, apertando-se, fundindo-se. Não marquei a hora exata daquele gesto. Devia tê-la marcado; sinto a falta de uma nota escrita naquela mesma noite, e que eu poria aqui com os erros de ortografia que trouxesse, mas não traria nenhum, tal era a diferença entre o estudante e o adolescente. Conhecia as regras do escrever, sem suspeitar as do amar; tinha orgias de latim e era virgem de mulheres.
NOSSA alegria diante dum sistema metafisico, nossa satisfação em presença duma construção do pensamento, em que a organização espiritual do mundo se mostra num conjunto lógico, coerente a harmônico, sempre dependem eminentemente da estética; têm a mesma origem que o prazer, que a alta satisfação, sempre serena afinal, que a atividade artística nos proporciona quando cria a ordem e a forma a nos permite abranger com a vista o caos da vida, dando-lhe transparência.
stdout 
Bem-vindo ao detector automático de COH-PIAH.
Entre o tamanho medio de palavra:Entre a relação Type-Token:Entre a Razão Hapax Legomana:Entre o tamanho médio de sentença:Entre a complexidade média da sentença:Entre o tamanho medio de frase:Digite o texto 1(aperte enter para sair):Digite o texto 2(aperte enter para sair):Digite o texto 3(aperte enter para sair):Digite o texto 4(aperte enter para sair):O autor do texto 1 está infectado com COH-PIAH.
https://ideone.com/Euejbh
language:
Python 3 (python  3.12)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!