fork(13) download 
  1. import re
  2.  
  3.  
  4. def le_assinatura():
  5.     """
  6.     A funcao le os valores dos tracos linguisticos do modelo e devolve uma
  7.     assinatura a ser comparada com os textos fornecidos.
  8.     """
  9.     print("Bem-vindo ao detector automático de COH-PIAH.")
  10.  
  11.     tam_m_pal = float(input("Entre o tamanho medio de palavra:"))
  12.     type_token = float(input("Entre a relação Type-Token:"))
  13.     h_lego = float(input("Entre a Razão Hapax Legomana:"))
  14.     tam_m_sent = float(input("Entre o tamanho médio de sentença:"))
  15.     compx_med = float(input("Entre a complexidade média da sentença:"))
  16.     tam_m_frase = float(input("Entre o tamanho medio de frase:"))
  17.  
  18.     return [tam_m_pal, type_token, h_lego, tam_m_sent, compx_med, tam_m_frase]
  19.  
  20.  
  21. def le_textos():
  22.     i = 1
  23.     textos = []
  24.     texto = input("Digite o texto " + str(i) + "(aperte enter para sair):")
  25.     while texto:
  26.         textos.append(texto)
  27.         i += 1
  28.         texto = input("Digite o texto " + str(i) + "(aperte enter para sair):")
  29.     return textos
  30.  
  31.  
  32. def calcula_assinatura(texto):
  33.     """
  34.     Essa funcao recebe um texto e deve devolver a assinatura
  35.     do texto.
  36.     """
  37.     if type(texto) != list:
  38.         aux = texto
  39.         texto = []
  40.         texto.append(aux)
  41.     for i in texto:
  42.         sentencas = []
  43.         sentencas = separa_sentencas(str(i))  # sent.. = lista comum, ~matriz
  44.         frases = []
  45.         num_tot_sentencas = 0
  46.         soma_cat_sentencas = 0
  47.         for i in range(len(sentencas)):
  48.             frase_i = separa_frases(str(sentencas[i]))
  49.             frases.append(frase_i)  # frases = matriz, lista de listas
  50.             num_tot_sentencas += 1
  51.             soma_cat_sentencas = soma_cat_sentencas + len(sentencas[i])
  52.         palavras = []
  53.         num_tot_frases = 0
  54.         soma_cat_frases = 0
  55.         for lin in range(len(frases)):
  56.             for col in range(len(frases[lin])):
  57.                 palavra_i = separa_palavras(str(frases[lin][col]))
  58.                 palavras.append(palavra_i)  # palav.. = matriz, lista de listas
  59.                 num_tot_frases += 1
  60.                 soma_cat_frases = soma_cat_frases + len(str(frases[lin][col]))
  61.         mtrx_para_lista = []  # transform.. palavras de matriz para lista
  62.         for lin in range(len(palavras)):
  63.             for col in range(len(palavras[lin])):
  64.                 mtrx_para_lista.append(palavras[lin][col])
  65.         palavras = mtrx_para_lista[:]
  66.         soma_comp_palavras = 0
  67.         num_tot_palavras = 0
  68.         for lin in range(len(palavras)):
  69.             for col in range(len(palavras[lin])):
  70.                 soma_comp_palavras = soma_comp_palavras + len(str(palavras[lin][col]))
  71.             num_tot_palavras += 1
  72.         matriz_ass_input = []
  73.         matriz_ass_input.append(tam_m_pal(soma_comp_palavras, num_tot_palavras))
  74.         matriz_ass_input.append(type_token(palavras, num_tot_palavras))
  75.         matriz_ass_input.append(h_lego(palavras, num_tot_palavras))
  76.         matriz_ass_input.append(tam_m_sent(soma_cat_sentencas, num_tot_sentencas))
  77.         matriz_ass_input.append(compx_med(num_tot_frases, num_tot_sentencas))
  78.         matriz_ass_input.append(tam_m_frase(soma_cat_frases, num_tot_frases))
  79.     return matriz_ass_input  # matriz, lista de listas dos valores das assina..
  80.  
  81.  
  82. def tam_m_pal(soma_comp_palavras, num_tot_palavras):
  83.     if num_tot_palavras != 0:
  84.         tam_m_pal = soma_comp_palavras / num_tot_palavras
  85.     else:
  86.         tam_m_pal = 0
  87.     return tam_m_pal
  88.  
  89.  
  90. def type_token(lista_palavras, num_tot_palavras):
  91.     num_pal_dif = n_palavras_diferentes(lista_palavras)
  92.     if num_tot_palavras != 0:
  93.         type_token = num_pal_dif / num_tot_palavras
  94.     else:
  95.         type_token = 0
  96.     return type_token
  97.  
  98.  
  99. def h_lego(lista_palavras, num_tot_palavras):
  100.     num_pal_uni = n_palavras_unicas(lista_palavras)
  101.     if num_tot_palavras != 0:
  102.         h_lego = num_pal_uni / num_tot_palavras
  103.     else:
  104.         h_lego = 0
  105.     return h_lego
  106.  
  107.  
  108. def tam_m_sent(soma_num_cat, num_sent):
  109.     if num_sent != 0:
  110.         tam_m_sent = soma_num_cat / num_sent
  111.     else:
  112.         tam_m_sent = 0
  113.     return tam_m_sent
  114.  
  115.  
  116. def compx_med(num_tot_frases, num_tot_sentencas):
  117.     if num_tot_sentencas != 0:
  118.         compx_med = num_tot_frases / num_tot_sentencas
  119.     else:
  120.         compx_med = 0
  121.     return compx_med
  122.  
  123.  
  124. def tam_m_frase(soma_cat_frases, num_tot_frases):
  125.     if num_tot_frases != 0:
  126.         tam_m_frase = soma_cat_frases / num_tot_frases
  127.     else:
  128.         tam_m_frase = 0
  129.     return tam_m_frase
  130.  
  131.  
  132. def separa_sentencas(texto):
  133.     """
  134.     A funcao recebe um texto e devolve uma lista das sentencas dentro
  135.     do texto.
  136.     """
  137.     sentencas = re.split(r'[.!?]+', texto)
  138.     if sentencas[-1] == '':
  139.         del sentencas[-1]
  140.     return sentencas
  141.  
  142.  
  143. def separa_frases(sentenca):
  144.     """
  145.     A funcao recebe uma sentenca e devolve uma lista das frases dentro
  146.     da sentenca.
  147.     """
  148.     return re.split(r'[,:;]+', sentenca)
  149.  
  150.  
  151. def separa_palavras(frase):
  152.     """
  153.     A funcao recebe uma frase e devolve uma lista das palavras dentro
  154.     da frase.
  155.     """
  156.     return frase.split()
  157.  
  158.  
  159. def n_palavras_unicas(lista_palavras):
  160.     """
  161.     Essa funcao recebe uma lista de palavras e devolve o numero de palavras
  162.     que aparecem uma unica vez.
  163.     """
  164.     freq = dict()
  165.     unicas = 0
  166.     for palavra in lista_palavras:
  167.         p = palavra.lower()
  168.         if p in freq:
  169.             if freq[p] == 1:
  170.                 unicas -= 1
  171.             freq[p] += 1
  172.         else:
  173.             freq[p] = 1
  174.             unicas += 1
  175.  
  176.     return unicas
  177.  
  178.  
  179. def n_palavras_diferentes(lista_palavras):
  180.     """
  181.     Essa funcao recebe uma lista de palavras e devolve o numero de palavras
  182.     diferentes utilizadas.
  183.     """
  184.     freq = dict()
  185.     for palavra in lista_palavras:
  186.         p = palavra.lower()
  187.         if p in freq:
  188.             freq[p] += 1
  189.         else:
  190.             freq[p] = 1
  191.  
  192.     return len(freq)
  193.  
  194.  
  195. def compara_assinatura(ass_main, matriz_ass_input):
  196.     """
  197.     Essa funcao recebe duas assinaturas de texto e deve devolver o grau de
  198.     similaridade nas assinaturas.
  199.     """
  200.     lista_Sab = []
  201.     soma_mod = 0
  202.     if type(matriz_ass_input[0]) is list:
  203.         for lin in range(len(matriz_ass_input)):
  204.             for col in range(len(matriz_ass_input[lin])):
  205.                 soma_mod += abs(ass_main[col] - matriz_ass_input[lin][col])
  206.             Sab = soma_mod / 6
  207.             lista_Sab.append(Sab)
  208.         return lista_Sab
  209.     else:
  210.         for i in range(len(matriz_ass_input)):
  211.             soma_mod += abs(ass_main[i] - matriz_ass_input[i])
  212.         Sab = soma_mod / 6
  213.         return Sab
  214.  
  215.  
  216. def avalia_textos(textos_main, ass_comparadas):
  217.     """
  218.     Essa funcao recebe uma lista de textos e deve devolver o numero (0 a n-1)
  219.     do texto com maior probabilidade de ter sido infectado por COH-PIAH.
  220.     """
  221.     aux_ass_com = (ass_comparadas[:])
  222.     aux_ass_com.sort()
  223.     for indice in range(len(ass_comparadas)):
  224.         if aux_ass_com[0] == ass_comparadas[indice]:
  225.             copiah = indice
  226.     return copiah -1
  227.  
  228. # your code goes here
Success #stdin #stdout 0.02s 28384KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
https://ideone.com/LNWOgp
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!