Generatore di Password

# GenPassword.py - generatore di password
# Legge dall'input la lunghezza della password desiderata e la probabilità
# della presenza di caratteri speciali espressa come intero tra 0 e 10.
# Fornisce in output la password
#
# by Andrea Bianchini 2021
#

from random import randint

s = "0123456789abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
sp = "_#:.,;^&%@"

l = int(input("Lunghezza password in caratteri : "))
ps = int(input("Probabilità caratteri speciali (0-10) : "))

pw=""
for i in range(l):
    ln = l * ps/10
    lx = randint(0,l)
    if ps!=0 and lx<=ln:
        pw = pw + sp[randint(0,len(sp)-1)]
    else:
        pw = pw + s[randint(0,len(s)-1)]

print("La password generata è : "+pw)

Esempio:

Lunghezza password in caratteri : 10
Probabilità caratteri speciali (0-10) : 2
La password generata è : A%@Ik.jtm7
>>> 

Piccolo Sistema Esperto

# by Andrea Bianchini 2021
# questa è la base di conoscenza del Sistema Esperto

kb=[["C'è alimentazione di rete in casa ?",1,4],
["Con una lampadina sana si accende ?",2,3],
["La lampadina è fulminata; sostituiscila",-1,-1],
["C'è un problema elettrico o nella spina o nel portalampade",-1,-1],
["Collega la rete; (salvavita o interruttore generale)",-1,-1]]
# by Andrea Bianchini 2021
# questo è il motore inferenziale del sistema esperto

import kb

print("Sistema esperto per risoluzione problema : non si accende lampadina")
print("-------------------------------------------------------------------")
print()

k=0
while k!=-1:
    if k>-1:
        r=input(kb.kb[k][0]+"([s]/n): ")
        if r.upper()=="S" or r=="":
            k=kb.kb[k][1]
        else:        
            k=kb.kb[k][2]

print("fine")

Esempio:

Sistema esperto per risoluzione problema : non si accende lampadina
-------------------------------------------------------------------

C'è alimentazione di rete in casa ?([s]/n): s
Con una lampadina sana si accende ?([s]/n): n
C'è un problema elettrico o nella spina o nel portalampade([s]/n): 
fine
>>> 

Questo è un esempio di Sistema Esperto. La base della conoscenza è volutamente molto semplice. Anche il motore inferenziale è abbastanza semplice ma con questo modello potete costruire un Sistema Esperto veramente capace.

Successione di Fibonacci

def fibonacci(k):
    if k == 0:
        return 0;
    if k == 1:
        return 1;
    if k>1 :
        return fibonacci(k-1)+fibonacci(k-2)

n = int(input("Quanti numeri di fibonacci vuoi stampare ? : "))
for i in range(1,n+1):
    print(fibonacci(i))

Esempio:

Quanti numeri di fibonacci vuoi stampare ? : 10
1
1
2
3
5
8
13
21
34
55

La successione di Fibonacci pare comparire in molti campi scientifici ed in natura, per citarne alcuni, nella musica, nell’arte, nell’informatica. Viene anche chiamata successione naturale.

Di seguito il link ad una trattazione dell’argomento su wikipedia :

https://it.wikipedia.org/wiki/Successione_di_Fibonacci

Leva finanziaria


capitale = int(input("Capitale complessivo detenuto (euro) : "))
passivita = int(input("Totale passività (euro) : "))

if capitale<1.0:
    capitale=1.0
leva = (capitale+passivita)/capitale

print("La tua leva finanziaria è pari a {:.2f}".format(leva))

print("")
print("Legenda:")
print("leva = 1 -> non hai passività (tutto capitale)")
print("leva tra 1 e 2 -> le tue passività non superano il tuo capitale")
print("leva > 2 -> attenzione ! più è alta la leva, più è alto il tuo rischio!")

Nella mia città si dice : ‘chi non risica non rosica’.

Infatti una leva leggermente superiore a 2, che indica sovraindebitamento, può essere stimolante per la crescita per via di effetti compensativi del fisco.

Esempio:

Capitale complessivo detenuto (euro) : 1000
Totale passività (euro) : 2000
La tua leva finanziaria è pari a 3.00

Legenda:
leva = 1 -> non hai passività (tutto capitale)
leva tra 1 e 2 -> le tue passività non superano il tuo capitale
leva > 2 -> attenzione ! più è alta la leva, più è alto il tuo rischio!
>>> 

Nanointelligenza artificiale

import datetime

nascita = datetime.datetime(2000, 5, 17)
c=1
while c!=2:
   print()
   print("------------")
   print("1-la mia età")
   print("2-end")

   c = int(input("Scegli 1 o 2 : "))


   if c==1 :
      d = datetime.datetime.now()
      d = d - nascita
      print()
      print("La mia età è di : {:.2f} anni".format(d.days/365.0))

print()
print(":-) A presto!")

Questo è un semplicissimo programma dotato di intelligenza artificiale (nano e debole…). Se gli chiedete quanti anni ha, lui ve lo sa dire!

Esempio:

------------
1-la mia età
2-end
Scegli 1 o 2 : 1

La mia età è di : 21.32 anni

------------
1-la mia età
2-end
Scegli 1 o 2 : 2

:-) A presto!
>>> 

Calcolo rata finanziamento

import math

def calcolaRataFinanziamento(importo, anni, tasso):
    tasso = tasso/100.0
    mesi = 12 #rate per anno
    numeroRate= mesi* anni #numero delle rate da pagare
    temp = math.pow(1 + (tasso/mesi),(numeroRate))

    return importo*(temp)*(tasso/mesi)/(temp-1)


imp = int(input("Importo finanziamento (euro): "))
an = int(input("Durata finanziamento (anni): "))
tas = float(input("Tasso di interesse (punti %): "))

r=calcolaRataFinanziamento(imp,an,tas)

print()
print("Importo rata mensile : {:.2f} euro".format(r))
print("Importo complessivo pagato : {:.2f} euro".format(an*12*r))
print("Costo del finanziamento : {:.2f} euro".format(an*12*r-imp))

Semplice funzione Python per calcolare l’importo della rata di un finanziamento una volta noti importo prestato, durata ammortamento in anni e tasso di interesse applicato.

Esempio:

Importo finanziamento (euro): 10000
Durata finanziamento (anni): 5
Tasso di ammortamento (punti %): 9

Importo rata mensile : 207.58 euro
Importo complessivo pagato : 12455.01 euro
Costo del finanziamento : 2455.01 euro
>>> 

Punteggio del secondo

    n = int(input())
    arr = map(int, input().split())

    arr.sort()

    k = arr[n-1]
    i = n-1
    while arr[i]==k :
        i-=1
    
    print(arr[i])

Viene fornito in input il numero di atleti sulla prima riga e sulla seconda riga la lista dei punteggi, esempio:

10
44 76 46 45 32 42 16 46 51 37

Il codice python fornito trova il punteggio del secondo atleta e lo stampa. (Attenzione! Potrebbero esserci più primi!)

Comprensione delle liste

    x = int(input())
    y = int(input())
    z = int(input())
    n = int(input())


    l1 = [i for i in range(x+1)]
    l2 = [i for i in range(y+1)]
    l3 = [i for i in range(z+1)]

    cubi = [[x,y,z] for x in l1 for y in l2 for z in l3]
    sol = [a for a in cubi if a[0]+a[1]+a[2]!=n]

    print(sol)

In questo esercizio mostro le list comprehensions.

Risolviamo un problema utilizzando solo le liste e senza loop.

Viene fornito un cubo di dimensioni x,y,z ed un intero n

si tratta di trovare tra tutti i cubi contenuti in x,y,z, tutti quelli la cui somma dei lati sia diversa da n.

Media dei voti degli studenti di una classe

    n = int(input())
    student_marks = {}
    for _ in range(n):
        line = input().split()
        name, scores = line[0], line[1:]
        scores = map(float, scores)
        student_marks[name] = scores
    query_name = input()

    votes = student_marks[query_name]
    
    n=0.0
    for v in votes:
        n=n+v;
    
    n=n/len(votes)

    print("{:.2f}".format(n))

L’input è come segue :

3
andrea 27 21 30
marco 30 28 26
matteo  30 29 28
marco

La prima riga (3) è i numero di studenti;

segue una riga per ciascun studente contenente nome e lista dei voti;

infine il nome dello studente di cui si vuole conoscere la media dei voti.

Rete Neuronale

import numpy as np

class NeuralNetwork():
    
    def __init__(self):
        # seeding for random number generation
        np.random.seed(1)
        
        #converting weights to a 3 by 1 matrix with values from -1 to 1 and mean of 0
        self.synaptic_weights = 2 * np.random.random((3, 1)) - 1

    def sigmoid(self, x):
        #applying the sigmoid function
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        #computing derivative to the Sigmoid function
        return x * (1 - x)

    def train(self, training_inputs, training_outputs, training_iterations):
        
        #training the model to make accurate predictions while adjusting weights continually
        for iteration in range(training_iterations):
            #siphon the training data via  the neuron
            output = self.think(training_inputs)

            #computing error rate for back-propagation
            error = training_outputs - output
            
            #performing weight adjustments
            adjustments = np.dot(training_inputs.T, error * self.sigmoid_derivative(output))

            self.synaptic_weights += adjustments

    def think(self, inputs):
        #passing the inputs via the neuron to get output   
        #converting values to floats
        
        inputs = inputs.astype(float)
        output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
        return output


if __name__ == "__main__":

    #initializing the neuron class
    neural_network = NeuralNetwork()

    print("Beginning Randomly Generated Weights: ")
    print(neural_network.synaptic_weights)

    #training data consisting of 4 examples--3 input values and 1 output
    training_inputs = np.array([[0,0,1],
                                [1,1,1],
                                [1,0,1],
                                [0,1,1]])

    training_outputs = np.array([[0,1,1,0]]).T

    #training taking place
    neural_network.train(training_inputs, training_outputs, 15000)

    print("Ending Weights After Training: ")
    print(neural_network.synaptic_weights)

    user_input_one = str(input("User Input One: "))
    user_input_two = str(input("User Input Two: "))
    user_input_three = str(input("User Input Three: "))
    
    print("Considering New Situation: ", user_input_one, user_input_two, user_input_three)
    print("New Output data: ")
    print(neural_network.think(np.array([user_input_one, user_input_two, user_input_three])))
    print("Wow, we did it!")

by  Dr. Michael J. Garbade

https://www.kdnuggets.com/2018/10/simple-neural-network-python.html