## Il file contiene varie soluzioni. Venfgono anche descritti
## diversi esempi per le funzioni da usare
## e sono dati i riferimenti al materiale sul sito docente 
## da cui si puo' copiare o ricavare il codice utile a risolvere l'esercizio.

************ versione semplificata senza check su alcuni valori ************



# E' opportuno definire delle funzioni per controllare 
# le parole con doppie e con ripetute
# per ora si da un'interpretazione ridotta per cio' 
# che e' richieto dall'es. 4; nella soluzione completa
# serve una terza funzione; l'esercizio e' considerato 
# valido in entrambi i casi


# esempio di funzione per verificare se una parola ha doppie
# piu' giu' altri esempi

def doppie(parola): # restituisce true se la parola ha doppie
    for i in parola:
        if i+i in parola:
            return True
    return False

    
# si usa la funzione di libreria string.count('carattere') per le stringhe vista a lezione e riportata in 
# http://people.unica.it/robertotonelli/files/2018/10/metodiStringa2.7.txt
# se almeno una lettera da count > 1 la parola ha lettere ripetute. 
# Appena trovo count > 1 restituisco True

def ripetute(parola): # restituisce True se la parola ha ripetute (anche doppie)
    for i in parola:
        if parola.count(i) > 1:
            return True
    return False

# si puo' anche usare il codice che crea un dizionario e riportato in 
# http://people.unica.it/robertotonelli/files/2018/10/operareConDizionari.txt
# se tra i valori del dizionario il massimo e' > 1 si ha almeno una lettera ripetuta
#
#
# def ripetute(parola): 
#   dic= {}
#   for Lettera in parola:
#       dic [Lettera] =dic.get(Lettera, 0) + 1
#   if max(dic.values()) > 1:
#       return True
#   else:
#       return False


# serve una funzione che esamini ad una ad una tutte le parole della frase inserita
# e mandi il risultato in output
# il conto e' fatto solo per doppie e ripetute.
# le parole che hanno doppie ma non altre lettere ripetute vengono 
# comunque contate tra le ripetute!

def countDoppieEripetute(frase):
    ndoppie = 0
    nripetute = 0
    for parola in frase.split():
        if doppie(parola):
            ndoppie+=1
        if ripetute(parola):
            nripetute+=1

    print "parole doppie",ndoppie,"parole con lettere ripetute",nripetute

    
# inizia il programma 
# usiamo gli esempi visti a lezione per il controllo 
# dell'inserimento e disponibili nel sito docente:
# http://people.unica.it/robertotonelli/files/2018/10/altriComandiUtili.txt
# nella sezione "Error handle:"

# dichiariamo dei contatori per calcolare 
# il numero di iserimenti di positivi e di negativi all'atto 
# stesso dell'inserimento. Si usano in contemporanea anche
# diue accumulatori per fare le due somme nello stesso 
# pezzo di codice. I primi tre punti sono risolti insieme. 

n = 1      # inizializzata per far partire il ciclo while
#zeri = gli zeri non li consideriamo perche' non richiesti..

sum_pos=0
count_pos=0
sum_neg=0
count_neg=0



while(n != 'F' and n != 'f'):

    n = (raw_input("inserisci solo numeri. F o f per terminare: "))
    try:
        x = float(n)

    # se l'assegnamento ad x del 'try' riesce si segna x tra i positivi o i negativi. 
    # Se x=0 non viene eseguito nulla. Finiti i calcoli riparte il ciclo while
    
        if x > 0:
            sum_pos = sum_pos + x
            count_pos += 1
        if x < 0:
            sum_neg = sum_neg + x
            count_neg += 1
            
    # se l'assegnamento non riesce riparte il ciclo while
    except:
        print "solo numeri please"

    
# a questo punto si ha il numero di positivi e la loro somma e 
# il n. di negativi e la loro somma.
# possiamo rispondere ai n. 1,2 e 3

if count_neg > count_pos :
    print "hai inserito piu' numeri negativi"
elif count_neg < count_pos:
    print "hai inserito piu' numeri positivi"
else:
    print "hai inserito tanti numeri negativi quanti positivi"

# proseguiamo senza verifiche su cosa e' stato introdotto; vedi sol. successiva per i check
    
print "la media dei postivi e'", sum_pos/count_pos
print "la media dei negativi e'", sum_neg/count_neg


# ciclo che chiede la frase se abs media pos < abs media neg
# controlla se frase ha almeno 8 parole e invita a reinserire in caso negativo

if mediapos < -medianeg:
        frase = raw_input("introduci una frase di almeno 8 parole:")
        
        while len(frase) < 8:
            frase = raw_input("la frase deve avere almeno 8 parole, reinserisci:")
    
        # finito il while si ha la frase di almeno 8 parole su cui fare i conti
        
        countDoppieEripetute(frase)  # si invoca la funzione per 






*************************** versione completa con controlli *************************

n = 1
#zeri = gli zeri non li consideriamo perche' non richiesti..
sum_pos=0
count_pos=0
sum_neg=0
count_neg=0

while(n != 'F' and n != 'f'):
    n = (raw_input("inserisci solo numeri. F o f per terminare: "))  
    try:
        x = float(n)
        if x > 0:
            sum_pos = sum_pos + x
            count_pos += 1
            print count_pos
        if x < 0:
            sum_neg = sum_neg + x
            count_neg += 1
            print count_neg
    except:
        print "solo numeri please"

if count_neg > count_pos :
    print "hai inserito piu' numeri negativi"
elif count_neg < count_pos:
    print "hai inserito piu' numeri positivi"
else:
    print "hai inserito tanti numeri negativi quanti positivi o non ne hai inserito"

    
if count_pos > 0:     #check per evitare di dividere per zero calcolando la media
    mediapos = (sum_pos/count_pos)
    print "la media dei postivi e'", mediapos
else:
    print "non hai inserito positivi"
    mediapos = 0

if count_neg > 0:     #check per evitare di dividere per zero calcolando la media
    medianeg = (sum_neg/count_neg)
    print "la media dei negativi e'", medianeg
else:
    print "non hai inserito negativi"
    medianeg = 0

def doppie(parola): # rende true se la parola ha doppie
    for i in parola:
        if i+i in parola:
            return True
    return False

def ripetute(parola): # rende True se la parola ha ripetute (anche doppie)
    for i in parola:
        if parola.count(i) > 1:
            return True
    return False


def countDoppieEripetute(frase):
    ndoppie = 0
    nripetute = 0
    for parola in frase.split():
        if doppie(parola):
            ndoppie+=1
        if ripetute(parola):
            nripetute+=1

    print "parole doppie",ndoppie,"parole con lettere ripetute",nripetute


if mediapos < -medianeg:
        frase = raw_input("introduci una frase di almeno 8 parole:")
        while len(frase) < 8:
            frase = raw_input("la frase deve avere almeno 8 parole, reinserisci:")

        countDoppieEripetute(frase)



 
################################################
# altro es. di funzione per parole con doppie
def doppie(parola):
    for i in parola:
        if parola.count('i+i') > 0:
            return True
    return False
    
# altro esempio scorrendo con indice numerico 
# le lettere nella parola. Si parte da uno e si confronta 
# ogni lettera con la precedente. Se coincidono sono doppie.

def doppie(parola):
    for i in range(1,len(parola)):
        if parola[i]==parola[i-1]:
            return True
    return False

    
************* altra soluzione piu' completa ***************
************* interpretando meglio l'esempio alla fine ****
####### in ogni caso si valutano corrette entrambe ********

n = 1
#zeri = gli zeri non li consideriamo perche' non richiesti..
sum_pos=0
count_pos=0
sum_neg=0
count_neg=0

while(n != 'F' and n != 'f'):
    n = (raw_input("inserisci solo numeri. F o f per terminare: "))  
    try:
        x = float(n)
        if x > 0:
            sum_pos = sum_pos + x
            count_pos += 1
            print count_pos
        if x < 0:
            sum_neg = sum_neg + x
            count_neg += 1
            print count_neg
    except:
        print "solo numeri please"

if count_neg > count_pos :
    print "hai inserito piu' numeri negativi"
elif count_neg < count_pos:
    print "hai inserito piu' numeri positivi"
else:
    print "hai inserito tanti numeri negativi quanti positivi o non ne hai inserito"

    
if count_pos > 0:     #check per evitare di dividere per zero calcolando la media
    mediapos = (sum_pos/count_pos)
    print "la media dei postivi e'", mediapos
else:
    print "non hai inserito positivi"
    mediapos = 0

if count_neg > 0:     #check per evitare di dividere per zero calcolando la media
    medianeg = (sum_neg/count_neg)
    print "la media dei negativi e'", medianeg
else:
    print "non hai inserito negativi"
    medianeg = 0

def doppie(parola): # rende true se la parola ha doppie
    for i in parola:
        if i+i in parola:
            return True
    return False


# funzione che elimina le doppie da una parola 
# e la restituisce con i due punti che poi non 
# verranno esaminati nel calcolo (si puo' scegliere di metterne solo un o altro...
# servira' a determinare se la parola ha ripetute oltre le doppie

def replaceDoppie(parola):
    for i in parola:
        if i+i in parola:
           parola = parola.replace(i+i,'..')
    return parola
    
    
def ripetute(parola): # rende True se la parola ha ripetute (anche doppie)
    for i in parola:        
        ## if parola.count(i) > 1:   ## va sostituito per non contare i due punti come doppia
        if (parola.count(i) > 1 and (i!='.')):  ## conto doppia solo se 'i' non e' il punto
            return True
    return False

def countDoppieEripetute(frase):
    ndoppie = 0
    nripetuteSenzaDoppie = 0
    nConDoppieEConRipetute = 0

    for parola in frase.split():

        if doppie(parola):
        
            ndoppie += 1                   ## la parola ha doppie ,la conto comunque tra le doppie
            
            p1 = replaceDoppie(parola)     ## elimino le doppie e le rimpiazzo con ..
            
            if ripetute(p1):               ## passo la parola coi due punti alla funzione ripetute
            
                nConDoppieEConRipetute += 1    ## questa parola ha sia doppie che ripetute, 
                                               ## e va contata in entrambe; in doppie e' gia' contata

        elif ripetute(parola):             ## altrimenti, se non ha doppie, controllo se ha solo ripetute
            nripetuteSenzaDoppie += 1
            
    print ndoppie, nConDoppieEConRipetute + nripetuteSenzaDoppie

    
    
    
if mediapos < -medianeg:
        frase = raw_input("introduci una frase di almeno 8 parole:")
        while len(frase) < 8:
            frase = raw_input("la frase deve avere almeno 8 parole, reinserisci:")

        countDoppieEripetute(frase)