Python-Code

array = ([2,1,5,8,4])
print("Maximalwert : " , max(array))
print("Minimalwert : " , min(array))

Python-Code

#!/usr/bin/python
#
#--------------------------------
#   title:      search or sort
#   author:     Excpt0r
#   licence:    use only with attribution, thanks! =)
#--------------------------------
#
# task: program a function which returns the min and max value
# from an integer array.
# solution: O(n) if you don't want to sort the array by yourself
# but you can also do bubblesort (very simple, but O(n^2) )
# or something similar. here is both!

def bubblesort(array):
    n = len(array)
    while True:
        newn = 1
        for i in range(n-1):
            if ( array[i] > array[i+1]):
                temp = array[i+1]
                array[i+1] = array[i]
                array[i] = temp
                newn = i+1
        n = newn
        if ( n <= 1):
            return (array[0],array[len(array)-1])
            break

def minmax(array):
    min, max = None, None
    for x in array:
        if (min == None and max == None):
            min = x
            max = x
        elif ( x < min ):
            min = x
        elif ( x > max ):
            max = x
    return (min,max)

def main():
    array1 = [13,12,11,10,9,8,7,6,5,4,3,2,1]
    array2 = [52,12,23,52,73,72,41,12,5,2,7,11,4124,635,123,15,1616,727,142,1532,3678,215]

    print "\n\tGet minima and maxima from array via search or sort! "

    print "\n Minimum Array 1: ", minmax(array1)[0]
    print " Maximum Array 1: ", minmax(array1)[1]
    print "\n Minimum Array 2: ", minmax(array2)[0]
    print " Maximum Array 2: ", minmax(array2)[1]

    print "\n Minimum Array 1, bubblesort: ", bubblesort(array1)[0]
    print " Maximum Array 1, bubblesort: ", bubblesort(array1)[1]

    print "\n Minimum Array 2, bubblesort: ", bubblesort(array2)[0]
    print " Maximum Array 2, bubblesort: ", bubblesort(array2)[1]

    return 0

if __name__ == "__main__":
    main()

Python-Code

# coding: utf8

def minima_maxima(x):
    mini = min(x)
    maxi = max(x)
    return (mini, maxi)
            
x = [34,23,567,1]
(mini, maxi) = minima_maxima(x)
print "Minimum: " + str(mini) 
print "Maximum: " + str(maxi)

x = [2342,456,657,234,543]
(mini, maxi) = minima_maxima(x)
print "Minimum: " + str(mini) 
print "Maximum: " + str(maxi) 

Python-Code

#!/usr/bin/python
# -*- coding: utf-8 -*-

def min_max(array):
	min = array[0]
	max = array[0]
	for n in array:
		if n < max and n < min:
			min = n
		elif n > max:
			max = n
	print min, max

min_max(input("Gib das array ein: "))

Python-Code

# -*- coding: utf-8 -*-

# Bubblesort
def minmax(a):
    x = len(a)
    while x > 0:
        for i in range(0, len(a)-1):
            if a[i] > a[i + 1]:
                tmp = a[i]
                a[i] = a[i + 1]
                a[i + 1] = tmp
        x = x - 1
    return (a[0], a[len(a)-1])


# Bsp
a1 = [1, 1, 0, 0, 0, 1, 0, 0]
a2 = [50, 1, 78, 24, 1000, 9, 345, 69, 5, 999]

print "Beispiel-Array 1:", a1
print ""
print "Minimalwert:", minmax(a1)[0]
print "Maximalwert:", minmax(a1)[1]
print ""
print "Beispiel-Array 2:", a2
print ""
print "Minimalwert:", minmax(a2)[0]
print "Maximalwert:", minmax(a2)[1]

Python-Code

#!/usr/bin/env python3
from collections import defaultdict
from random import randint

def radixSort(listOfNumbers):
    """ sort a list without to compare the digits """
    generateDic     = defaultdict(list)
    result          = []
    resultNew       = []
    checkListLen    = len(listOfNumbers)
    biggestChar     = 0

    for i in listOfNumbers:
        a = len(str(i))
        if a > biggestChar:
            biggestChar = a

    for m in range(0,biggestChar):
        for i in range(0,checkListLen):
            try:
                stringDigits    = str(listOfNumbers[i])
                stringDigitsLen = len(stringDigits)
                if stringDigitsLen < m+1:
                    generateDic["0"].append(listOfNumbers[i])
                else:
                    generateDic[stringDigits[stringDigitsLen-1-m]].append(listOfNumbers[i])
            except IndexError:
                pass
        #print(generateDic)

        for j in range(0,10):
            if str(j) in generateDic:
                result.append(generateDic[str(j)])

        for k in range(0,len(result)):
            for l in range(0,len(result[k])):
                resultNew.append((result[k])[l])

        generateDic.clear()
        result, listOfNumbers, resultNew = [], resultNew, []
        #print("SortierteListe nach 10^",m,": ",listOfNumbers)
    print("Sortiert:m ",listOfNumbers)
    return listOfNumbers

def getMaxMin(getAList):
    print("Minimum: ",getAList[0],"Maximum",getAList[len(getAList)-1])

def randDigits():
    a = []
    for i in range(0,20):
        a.append(randint(0,1000))
    print("Unsortiert: ",a)
    return a

def main():
    print("Erster Test: ")
    getMaxMin(radixSort(randDigits()))
    print("Zweiter Test: ")
    getMaxMin(radixSort(randDigits()))

if __name__ == "__main__":
    main()

Python-Code

array = [634,3461,93,25,64,25,732]
print(max(array))
print(min(array))

Python-Code

# arraysort.py

def sortList(liste):
    laenge = len(liste)
    swapped = True
    while (swapped == True) or (laenge > 1):
        swapped = False
        if laenge > 1:
            laenge = int(float(laenge)/1.3)
        for i in range(0, (len(liste)-laenge)):
            if liste[i] > liste[i+laenge]:
                liste[i], liste[i+laenge] = liste[i+laenge], liste[i]
                swapped = True

    return liste

if __name__ == "__main__":
    eingabe = input("Gib eine Zahlenmenge (durch Leerzeichen getrennt) ein: ")
    liste = [int(x) for x in eingabe.split()]
    liste = sortList(liste)
    print("Kleinstes Element: " + str(liste[0]))
    print("Größtes Element: " + str(liste[-1]))
    

Python-Code

import random

def _MinMax(listToSort: []):
    listToSort.sort()
    length = len(listToSort)
    return (str("Minimum:")+str(listToSort[0])+str("\nMaximum:")+str(listToSort[length-1]))

array1 = []
for i in range(25):
    randomizer = random.randrange(0,55)
    array1.append(randomizer)
print("Dieses Array wird benutzt:\n",array1)
print(_MinMax(array1))
input()

Python-Code

from random import randrange
loop = True
while loop:
    def minmax(array):
        array2 = sorted(array)
        minimum = array2[0]
        maximum = array2[len(array)-1]
        return "Minimum:", minimum, "\tMaximum:", maximum, "\tListe:", array

    def listen_ersteller(groesse, anfang, ende):
        Array = []
        for i in range(groesse):
            zufallszahl = randrange(anfang, ende)
            Array.append(zufallszahl)
        return Array

    print("Gib die Groesse der Liste ein")
    g = int(input()) 
    print("Gib den Anfangswert für das Intervall ein")
    a = int(input())
    print("Gib den Endwert für das Intervall ein")
    e = int(input())

    print(*(minmax(listen_ersteller(g, a, e))))

Python-Code

# Programmieren Sie eine Funktion welche aus einem Array von Integer-Elementen das Minimum und Maximum zurückgibt.
# Als Übergabe-Parrameter wird das Array übergeben.

# Testen Sie die Funktion mit 2 Abfragen, bzw. mit 2 verschiedenen Arrays.

def min_max(array):
    """
    Sucht nach Min/ Max Wert in der Liste
    :param array: Liste aus der Min/ Max gesucht wird
    :return: min-Wert und max-Wert
    """
    return min(array), max(array)


array_1 = [5, 1, 200, 50, 3]
array_2 = [900, 700, 500, 300, 100]

# Doppelter Aufruf der Funktion min_max
x = min_max(array_1) + min_max(array_2)

# Ausgabe der Min- und Max-Werte
print(f"Das Minimum aus Array 1 lautet {x[0]} und das Maximum lautet {x[1]}")
print(f"Das Minimum aus Array 2 lautet {x[2]} und das Maximum lautet {x[3]}")

Python-Code

def min_max_bubblesort(array):
    """
    Sucht nach Min/ Max Wert in der Liste
    :param array: Liste aus der Min/ Max gesucht wird
    :return: min-Wert und max-Wert
    """
    durchlauf = len(array) - 1
    while durchlauf > 0:
        for n in range(1, durchlauf + 1):
            if array[n - 1] > array[n]:
                zwischen_speicher = array[n - 1]
                array[n - 1] = array[n]
                array[n] = zwischen_speicher
        durchlauf -= 1
    return array[0], array[-1]


array_1 = [5, 1, 200, 50, 3, 0]
array_2 = [900, 700, 500, 300, 100]

# Doppelter Aufruf der Funktion min_max
x = min_max_bubblesort(array_1) + min_max_bubblesort(array_2)

# Ausgabe der Min- und Max-Werte
print(f"Das Minimum aus Array 1 lautet {x[0]} und das Maximum lautet {x[1]}")
print(f"Das Minimum aus Array 2 lautet {x[2]} und das Maximum lautet {x[3]}")