def betrag(x):
    if x>=0:
        y=x
    else:
        y=-x
    return y


def istPrimzahl(n):
    if n==1:
        return False
    z=2
    while(z<=n**(1/2)):
        if(n%z==0):
            return False
        else:
            z+=1
    return True

	
	
	
def Collatz(n):
    zaehler=0
    while(n!=1):
        zaehler+=1
        if n%2==0:
            n=n//2
        else:
            n=3*n+1
    return zaehler

def collatzMax(m):
    maxi=0
    maxiNumber=0
    for i in range(1,m+1):
        t= Collatz(i)
        if t>maxi:
            maxi =t
            maxiNumber=i
    
    print(maxi)
    print(maxiNumber)




#euklidischer Algorithmus
def euklidggT(a,b):
    if a<b:
        b,a=a,b
    r= a%b
    if (r==0):
        return b
    else:
        return(euklidggT(b,r))

#Euler Project 1
Summe=0
for Zahl in range(1000):
    if Zahl%3==0 or Zahl%5==0:
        Summe=Zahl+Summe
print(Summe)




#erwEuklid gibt das Tripel (ggt, s, t) zurück, wobei ggT = s*a + t*b.
def erwEuklid(a,b):
    if a<b:
        a,b=b,a #tausche a und b

    if b==0: #abbruchbedingung
        return (a,1,0)
    else:
        q=a//b
        r=a%b
        (ggt, s1,t1)=erwEuklid(b,r)
        s= t1
        t= s1- q* t1

        return(ggt, s, t)



def durchschnitt(my_liste):
    Summe = 0
    for i in range(len(my_liste)):
        Summe = Summe + my_liste[i]
    return Summe / len(my_liste)

durchschnitt([4,5,1,3,2])


# Wir möchten eine Zahl ins Dezimalsystem umrechnen. DIe Zahl ist gegeben als Liste mit ihrer Basis.

#1. Ansatz: [a_n, ..., a_1, a_0] -> a_n * basis^n + ... + a_1* basis + a_0
def umrechnungInDezimal(my_liste, basis):
    dezimal = 0
    for i in range(len(my_liste)):
        dezimal = dezimal + my_liste[i]* basis**(len(my_liste)-i-1)
    return dezimal

umrechnungInDezimal([3,2,4],6)


def umrechnungInDezimal2(my_liste, basis):
    my_liste.reverse() #dreh die Liste um
    dezimal = 0
    for i in range(len(my_liste)):
        dezimal = dezimal + my_liste[i]* basis**i
    return dezimal

umrechnungInDezimal2([3,2,4],6)



#2. Ansatz: [a_n, ..., a_1, a_0] -> ((((a_n) * basis + a_n-1)* basis + ... a_1)* basis + a_0   Horner-Shema
def umrechnungInDezHorner(my_liste, basis):
    dezimal = 0
    for i in range(len(my_liste)):
        dezimal = dezimal*basis + my_liste[i]
    return dezimal

umrechnungInDezHorner([3,2,4],6)


def umrechnungVonDezimal(num, basis):
    zahl = []
    current = num

    while current != 0:
        rest = current % basis
        zahl.append(rest)
        current = current // basis

    zahl.reverse()
    return zahl, basis

print(umrechnungVonDezimal(13,6))

def umrechnungInBasis(zahl, basis):
	liste = []
	y = zahl
	while y>0:
		x = y % basis #Rest
		liste.append(x) 
		y = y // basis 
	liste = list(reversed(liste))
	return(liste)
	
print(umrechnungInBasis(13, 2))















































































































































































































#FALSCH
def umrechnungInBasisFalsch(zahl, basis):
    my_liste=[] 
    
    while zahl>4:
        x = zahl%basis
        zahl = zahl//basis
        my_liste.append(x)    
    return my_liste

umrechnungInBasisFalsch(13,2)