UNCHDIPSS/ praktikum Daspro

blog undip

Praktikumpython dasar Programming Universitas Diponegoro Semester 1

Published On: August 12, 2024

← back to me blog

NAMA FILE : Praktikum 1.py

Deskropsi : Menghitung nilai pangkat

Pemuat : myudakk - NIM

buku/pdf/link etc

btw kalo ada salah dm ae

CONTOH =>

komen

# ini namany komen fungsiny ya buat komen"
"""
ini juga komen panjangg
bisa
multi line
"""
a = "kalo ini bukan komen"

# cara buat fungsi di python
def {nama_fungsi}({parameter}):
    {kode}

# fungsi buat kuadrat
def kuadrat(x: int) -> int:
    """
    x: int artinya x adalah integer
    -> int artinya return dari fungsi adalah integer
    optional btw
    """
    return x * x

def kubik(x: int) -> int:
    return x * kuadrat(x)

def duaKali(x: int) -> int:
    return x + x

def max2(x: int, y: int) -> int:
    return ((x + y) + abs(x - y)) // 2

def max3(x: int, y: int, z: int) -> int:
    return max2(max2(x, y), z)

def is_origin(x: int, y: int) -> bool:
    return x == 0 and y == 0

LATIHAN ==>>

day1 github https://github.com/myudak/praktikum_undip_daspro/tree/main/day1

Terjemakanlah contoh notasi fungsional pada Diktat berikut ke dalam bahasa pemrograman Python (perhatikan aturan standar penulisan program):

1. Contoh-4 Ekspresi numeric: Mean Olympique (MO)

Definisikan sebuah fungsi yang menerima 4 bilangan bulat positif, menghasilkan harga rata-rata dari dua di antara empat buah bilangan tersebut, dengan mengabaikan nilai terbesar dan nilai terkecil.

Contoh :

Input: 10, 8, 12, 14 → Output: 11
Input: 12, 12, 12, 12 → Output: 12

def mean_olympikGue(w: int, x: int, y: int, z: int) -> float:
    a = sorted([w, x, y, z]) # <- ini array cok trs di sort
    return (a[1] + a[2]) / 2

ATAU

def max2(a: int, b: int) -> int:
    return (a + b + abs(a - b)) // 2
 
def min2(a: int, b: int) -> int:
    return (a + b - abs(a - b)) // 2
 
def max4(i: int, j: int, k: int, l: int) -> int:
    return max2(max2(i, j), max2(k, l))
 
def min4(i: int, j: int, k: int, l: int) -> int:
    return min2(min2(i, j), min2(k, l))
 
def MO(u: int, v: int, w: int, x: int) -> float:
    return (u + v + w + x - max4(u, v, w, x) - min4(u, v, w, x)) / 2
 
# contoh pengguanaan
print(MO(10, 8, 12, 14))

2. Contoh-5 Ekspresi Boolean: POSITIF

Buatlah definisi, spesifikasi dan realisasi dari sebuah predikat yang menerima sebuah bilangan bulat dan bernilai benar jika bilangan tersebut positif. Lebih spesifik : menghasilkan sebuah nilai boolean yang bernilai true jika bilangan tersebut positif, atau false jika bilangan tersebut negatif.

def isPositive(x: int) -> bool:
    return x > 0

3. Contoh-6 Ekspresi Boolean: APAKAH HURUF A

Buatlah definisi, spesifikasi dan realisasi dari sebuah predikat yang menerima sebuah karakter dan bernilai benar jika karakter tersebut adalah huruf ‘A’.

def isHurufA(x: str) -> bool:
    return x == "A"

4. Contoh-7 Ekspresi Boolean: APAKAH VALID

Buatlah definisi, spesifikasi dan realisasi dari sebuah predikat yang menerima sebuah besaran integer, dan menentukan apakah bilangan tersebut valid. Bilangan disebut valid jika nilainya lebih kecil dari 5 atau lebih besar dari 500. Jadi bilangan di antara 5 dan 500 tidak valid.

def isValid(x: int) -> bool:
    return x < 5 or x > 500

5. Ekspresi numeric: Least Square (Jarak 2 Titik)

Buatlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menrima empat buah bilangan riil yang pengertiannya adalah dua pasang titik pada koordinat kartesian, dan menghasilkan sebuah bilangan riil yang merupakan jarak dari kedua titik tersebut (atau panjang garis yang dibentuk oleh kedua titik tersebut), dengan melakukan aplikasi terhadap dua buah fungsi antara yang harus didefinisikan terlebih dulu sebagai berikut :

dif2 adalah sebuah fungsi yang menerima dua buah bilangan riil dan menghasilkan pangkat dua dari selisih kedua bilangan riil tersebut. Pangkat dua dilakukan oleh fungsi quad yang menerima sebuah bilangan riil dan menghasilkan pangkat dua dari bilangan riil tersebu

import math
 
def FX2(x: float) -> float:
    return x * x
 
def dif2(x: float, y: float) -> float:
    return FX2(x - y)
 
def LS(x1: float, y1: float, x2: float, y2: float) -> float:
    return math.sqrt(dif2(x2, x1) + dif2(y2, y1))
 
# contoh penggunaan
x1, y1 = 1.0, 2.0
x2, y2 = 4.0, 6.0
jarak = LS(x1, y1, x2, y2)
print(f"jarak antara titik ({x1}, {y1}) dan ({x2}, {y2}) adalah {jarak}")

EKSPRESI KONDISIONAL

IL/Diktat IF1281 Dasar Pemrograman/Bagian I - Notasi Fungsional.doc – Page 29 of 127

1. Contoh-1 Ekspresi kondisional : MAKSIMUM 2 NILAI

Buatlah definisi, spesifikasi dan realisasi dari fungsi yang menghasilkan nilai maksimum dari dua buah nilai integer yang diberikan

def max2(x: int, y: int) -> int:
    return (x if x > y else y)

2. Contoh-2 Ekspresi kondisional : MAKSIMUM 3 NILAI

Buatlah definisi, spesifikasi dan realisasi dari fungsi yang menghasilkan nilai maksimum dari tiga buah nilai integer yang berlainan.

def max3(x: int, y: int, z: int) -> int:
    return max2(max2(x, y), z)

ATAU

def max3(x: int, y: int, z: int) -> int:
    if x > y and x > z : return x
    if y > x and y > z : return y
    if z > x and z > y : return z

3. Contoh3 Ekspresi kondisional : PENANGGALAN

Tanggal, bulan dan tahun pada perioda tahun 1900 s/d 1999 dapat dituliskan dalam "tuple" dari tiga buah bilangan integer < d,m,y > sebagai berikut :

< 3,4,93 > : hari ke 3, pada bulan ke 4 (April), pada tahun 1993

Hitunglah hari ke... pada suatu tahun 1900+y mula-mula tanpa memperhitungkan adanya tahun kabisat, kemudian dengan memperhitungkan tahun kabisat.

Contoh :

< 1,1,82 > → 1
< 31,12,72 > → 366
< 3,4,93 > → 93

def dpm(m: int) -> int:
    if m == 1:
        return 1
    if m == 2:
        return 32
    if m == 3:
        return 60
    if m == 4:
        return 91
    if m == 5:
        return 121
    if m == 6:
        return 152
    if m == 7:
        return 182
    if m == 8:
        return 213
    if m == 9:
        return 244
    if m == 10:
        return 274
    if m == 11:
        return 305
    if m == 12:
        return 335
    raise ValueError("salah bulan cuk")
 
def HariKe1900(d: int, m: int, y: int) -> int:
    return dpm(m) + d - 1 + (1 if IsKabisat(y) else 0)
 
# contoh penggunaan
print(HariKe1900(1, 1, 82))
print(HariKe1900(31, 12, 72))
print(HariKe1900(3, 4, 93))

TYPE BENTUKAN

(Produk, Type Komposisi, Type Terstruktur)

IL/Diktat IF1281 Dasar Pemrograman/Bagian I - Notasi Fungsional.doc – Page 37 of 127

Kasus 1 : Type POINT

Didefinisikan suatu type bernama Point, yang mewakili suatu titik dalam koordinat kartesian, terdiri dari absis dan ordinat. Berikut ini adalah teks dalam notasi fungsional untuk type Point tersebut, dengan selektor yang hanya dituliskan dalam bentuk fungsi.

import math
class Point: # python gk ad type jadi pake class sj
    def __init__(self, x: float, y: float):
        self.x = x  # absis
        self.y = y  # ordinat
 
def Absis(P: Point) -> float:
    return P.x
 
def Ordinat(P: Point) -> float:
    return P.y
 
def MakePoint(a: float, b: float) -> Point:
    return Point(a, b)
 
def IsOrigin(P: Point) -> bool:
    return Absis(P) == 0 and Ordinat(P) == 0
 
def FX2(x: float) -> float:
    return x * x
 
def Jarak(P1: Point, P2: Point) -> float:
    return math.sqrt(FX2(Absis(P1) - Absis(P2)) + FX2(Ordinat(P1) - Ordinat(P2)))
 
def Jarak0(P: Point) -> float:
    return math.sqrt(FX2(Absis(P)) + FX2(Ordinat(P)))
 
def Kuadran(P: Point) -> int:
    if Absis(P) > 0 and Ordinat(P) > 0:
        return 1
    if Absis(P) < 0 and Ordinat(P) > 0:
        return 2
    if Absis(P) < 0 and Ordinat(P) < 0:
        return 3
    if Absis(P) > 0 and Ordinat(P) < 0:
        return 4
    raise ValueError("salahh")
 
# contoh penggunaan
P1 = MakePoint(3, 4)
P2 = MakePoint(-1, 2)
print(f"absis P1 → {Absis(P1)}, Ordinat P1 → {Ordinat(P1)}")
print(f"is P1 origin? {IsOrigin(P1)}")
print(f"jarak P1 dan P2 → {Jarak(P1, P2)}")
print(f"jarak P1 dari origin → {Jarak0(P1)}")
print(f"P1 ada di kuadran → {Kuadran(P1)}")

Kasus-2: Type PECAHAN

Didefinisikan suatu type bernama Pecahan, yang terdiri dari pembilang dan penyebut. Berikut ini adalah teks dalam notasi fungsional untuk type pecahan tersebut. Perhatikanlah bahwa realisasi fungsi hanya dilakukan untuk operator aritmatika dan relasional terhadap pecahan. Realisasi selektor hanya diberikan secara konseptual, karena nantinya akan diserahkan implementasinya ke bahasa pemrograman

class Pecahan:
    def __init__(self, n: int, d: int):
        self.n = n  # pembilang (numerator)
        self.d = d  # penyebut (denumerator)
 
def Pemb(P: Pecahan) -> int:
    return P.n
 
def Peny(P: Pecahan) -> int:
    return P.d
 
def MakeP(n: int, d: int) -> Pecahan:
    return Pecahan(n, d)
 
def AddP(P1: Pecahan, P2: Pecahan) -> Pecahan:
    return MakeP(Pemb(P1) + Pemb(P2), Peny(P1) + Peny(P2))
 
def SubP(P1: Pecahan, P2: Pecahan) -> Pecahan:
    return MakeP(Pemb(P1) - Pemb(P2), Peny(P1) - Peny(P2))
 
def MulP(P1: Pecahan, P2: Pecahan) -> Pecahan:
    return MakeP(Pemb(P1) * Pemb(P2), Peny(P1) * Peny(P2))
 
def DivP(P1: Pecahan, P2: Pecahan) -> Pecahan:
    return MakeP(Pemb(P1) // Pemb(P2), Peny(P1) // Peny(P2))
 
def RealP(P: Pecahan) -> float:
    return Pemb(P) // Peny(P)
 
def IsEqP(P1: Pecahan, P2: Pecahan):
    return Pemb(P1) * Peny(P2) == Pemb(P2) * Peny(P1)
 
def IsLtP(P1: Pecahan, P2: Pecahan):
    return Pemb(P1) * Peny(P2) < Pemb(P2) * Peny(P1)
 
def IsGtP(P1: Pecahan, P2: Pecahan):
    return Pemb(P1) * Peny(P2) > Pemb(P2)

KASUS-3 : PENANGGALAN

Didefinisikan suatu type Date yang terdiri dari thari, bulan dan tahun dan membentuk komposisi < Hr,Bln,Thn >. Dalam contoh ini, sebuah nama type bukan merupakan nama type bentukan, melainkan sebuah subdomain (sebagian dari nilai domain). Penamaan semacam ini akan mempermudah pembacaan teks

class Hr(int):
    def __new__(cls, value):
        if not (1 <= value <= 31):
            raise ValueError("salah harii cuk, harus antara 1 dan 31")
        return int.__new__(cls, value) # extend integer biar bisa ditambah etc
 
class Bln(int):
    def __new__(cls, value):
        if not (1 <= value <= 12):
            raise ValueError("salah bulan cuk, harus antara 1 dan 12")
        return int.__new__(cls, value)
 
class Thn(int):
    def __new__(cls, value):
        if value <= 0:
            raise ValueError("salah tahun cuk, harus lebih dari 0")
        return int.__new__(cls, value)
 
class Date:
    def __init__(self, day: Hr, month: Bln, year: Thn):
        self.day = day
        self.month = month
        self.year = year
 
def Day(d: Date) -> Hr:
    return d.day
 
def Month(d: Date) -> Bln:
    return d.month
 
def Year(d: Date) -> Thn:
    return d.year
 
def MakeDate(day: int, month: int, year: int):
    return Date(Hr(day), Bln(month), Thn(year))
 
def IsKabisat(year: int):
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
 
def NextDay(D: Date):
    day, month, year = Day(D), Month(D), Year(D)
 
    if month in [1, 3, 5, 7, 8, 10, 12]:
        if day < 31:
            return MakeDate(day + 1, month, year)
        elif month == 12:
            return MakeDate(1, 1, year + 1)
        else:
            return MakeDate(1, month + 1, year)
 
    elif month in [4, 6, 9, 11]:
        if day < 30:
            return MakeDate(day + 1, month, year)
        else:
            return MakeDate(1, month + 1, year)
 
    elif month == 2:
        if IsKabisat(year):
            if day < 29:
                return MakeDate(day + 1, month, year)
            else:
                return MakeDate(1, month + 1, year)
        else:
            if day < 28:
                return MakeDate(day + 1, month, year)
            else:
                return MakeDate(1, month + 1, year)
 
def Yesterday(D: Date):
    day, month, year = Day(D), Month(D), Year(D)
 
    if day == 1:
        if month in [3, 5, 7, 8, 10, 12]:
            return MakeDate(30, Month(D) - 1, Year(D))
        elif month in [4, 6, 9, 11]:
            return MakeDate(31, Month(D), Year(D))
        elif month == 2:
            if IsKabisat(year):
                return MakeDate(29, 2, Year(D))
            else:
                return MakeDate(28, 2, Year(D))
        elif month == 1:
            return MakeDate(31, 12, Year(D) - 1)
    else:
        return MakeDate(Day(D) - 1, Month(D), Year(D))
 
def IsEqD(D1: Date, D2: Date):
    return HariKe1900(D1) == HariKe1900(D2)
 
def IsBefore(D1: Date, D2: Date):
    return HariKe1900(D1) < HariKe1900(D2)
 
def IsAfter(D1: Date, D2: Date):
    return HariKe1900(D1) > HariKe1900(D2)
 
def NextNDay(D: Date, N: int):
    for i in range(N):
        D = NextDay(D)
    return D
 
def HariKe1900(D: Date) -> int:
    return dpm(Month(D)) + Day(D) - 1 + (1 if Month(D) > 2 and IsKabisat(Year(D)) else 0)
 
def dpm(m: int) -> int:
    if m == 1:
        return 1
    if m == 2:
        return 32
    if m == 3:
        return 60
    if m == 4:
        return 91
    if m == 5:
        return 121
    if m == 6:
        return 152
    if m == 7:
        return 182
    if m == 8:
        return 213
    if m == 9:
        return 244
    if m == 10:
        return 274
    if m == 11:
        return 305
    if m == 12:
        return 335
    raise ValueError("salah bulan cuk")
 
# contoh penggunaan
def buatPrint(d: Date):
    return Day(d), Month(d), Year(d)
 
d = MakeDate(31, 8, 2024)
nextdaycok = NextDay(d)
yesterdaycok = Yesterday(d)
nextNdaycok = NextNDay(d,5)
 
print(f"next hari → {buatPrint(nextdaycok)}")
print(f"kmarenn → {buatPrint(yesterdaycok)}")
print(f"is equall {IsEqD(d, MakeDate(31, 12, 2023))}")
print(f"is before → {IsBefore(d, MakeDate(1, 1, 2025))}")
print(f"is after → {IsAfter(d, MakeDate(1, 1, 2023))}")
print(f"next 5 hari → {buatPrint(nextNdaycok)}")

Fungsi dengan range type bentukan tanpa nama

Pada contoh yang diberikan di atas, semua type bentukan diberi nama. Pemberian nama type akan berguna jika type tersebut dipakai berkali-kali dan memang membutuhkan operator untuk mengoperasikan nilai-nilainya. Bahkan seringkali, diperlukan fungsi yang menghasilkan suatu nilai bertype komposisi, tanpa perlu mendefinisikan nama tsb (jika kita mendefinisikan nama, maka kita wajib membuat konstruktor, selektor, dsb yang pernah dijelaskan). Nama type tidak perlu didefinisikan misalnya karena kita harus merancang suatu fungsi yang hanya di-aplikasi sekali untuk menghasilkan beberapa nilai yang komposisinya mengandung arti.

Kasus : Ekivalensi detik de jam, menit, detik

Diberikan sebuah besaran integer positif yang mewakili nilai detik, tuliskanlah sebuah fungsi HHMMDD yang memberikan nilai hari, jam, m, detik dari besaran detik tersebut.

Contoh: Diberikan 309639, menghasilkan < 3,14,0,39 >

Range dari HHMMDD tipe bentukan yang kebetulan terdiri 4 buah integer. Pada kasus lain, mungkin sebenarnya dapat juga berbeda-beda, misalnya kalau terdefinisi type Hr, Bln, Th seperti pada contoh DATE.

Realisasi fungsi ini membutuhkan sebuah fungsi yang mampu untuk menghitung hasil dan sekaligus sisa pembagian bulat dari dua buah bilangan integer yang dinamakan QR Range dari QR adalah sebuah pasangan nilai integer (type terkomposisi) namun tidak diberi nama

from typing import Tuple
 
def QR(N: int, D: int) -> Tuple[int, int]:
    return (N // D, N % D)
 
def HHMMDD(x: int) -> Tuple[int, int, int, int]:
    H, sisaH = QR(x, 86400)
    J, sisaJ = QR(sisaH, 3600)
    M, D = QR(sisaJ, 60)
    return (H, J, M, D)
 
# contoh penggunaan
print(HHMMDD(309639))

TABEL

Contoh 1: Pemakaian tabel : Persoalan : Harike dari suatu tanggal

Tuliskanlah sebuah fungsi yang menerima sebuah tanggal < d,m,y > dan menghasilkan Harike pada tanggal tersebut, terhitung mulai 1 Januari tahun yang bersangkutan. Contoh masukan dan hasil :

< 1,1,1993 > → 1
< 4,2,1979 > → 35
< 31,12,1935 > → 365

from typing import Tuple
 
# baru tau rill gini jug bisa
Hr = int
Bln = int
Thn = int
NHari = int
 
class Date:
    def __init__(self, day: Hr, month: Bln, year: Thn):
        self.day = day
        self.month = month
        self.year = year
 
def Day(d: Date) -> Hr:
    return d.day
 
def Month(d: Date) -> Bln:
    return d.month
 
def Year(d: Date) -> Thn:
    return d.year
 
Koreksi = [0, 1, -1, 0, 0, 1, 1, 2, 3, 3, 4, 4]
 
def IsKabisat(a: Thn) -> bool:
    return (a % 4 == 0 and a % 100 != 0) or (a % 400 == 0)
 
def NH(D:Date) -> NHari:
 
    return 30 * (Month(D) - 1) + Day(D) +  Koreksi[Month(D) - 1] + (1 if Month(D) > 2 and IsKabisat(Year(D)) else 0)
 
# contoh penggunaan
date_1 = Date(Hr(1), Bln(1), Thn(1993))
date_2 = Date(Hr(4), Bln(2), Thn(1979))
date_3 = Date(Hr(31), Bln(12), Thn(1935))
print(f"{date_1} → {NH(date_1)}")
print(f"{date_2} → {NH(date_2)}")
print(f"{date_3} → {NH(date_3)}")

EKSPRESI REKURSIF

IL/Diktat IF1281 Dasar Pemrograman/Bagian I - Notasi Fungsional.doc – Page 53 of 127

Definisi entitas (type, fungsi) disebut rekursif jika definisi tersebut mengandung terminologi dirinya sendiri.

Ekspresi rekursif dalam pemrograman fungsional didasari oleh Analisa rekurens, yaitu penalaran berdasarkan definisi fungsi rekursif, yang biasanya juga berdasarkan “type” yang juga terdefinisi secara rekursif-induktif.

Contoh-1 Ekspresi rekursif : FACTORIAL

Tuliskanlah sebuah fungsi yang menghitung factorial dari n sesuai dengan definisi rekursif faktorial.

def fac(n: int) -> int:
    if n == 0:
        return 1
    return n * fac(n - 1)

Contoh-3 Ekspresi rekursif : FIBONACCI

Tuliskanlah sebuah fungsi yang menghitung Fibonacci dari n , dengan definisi rekursif fungsi Fibonacci.:

def fibonacci(n: int) -> int:
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

Ekspresi Rekursif terhadap Bilangan bulat

Pada bagian ini akan diberkan contoh, bagaimana menuliskan ekspresi rekursif yang dibangun berdasarkan analisa rekurens, terhadap bilangan integer, untuk merealisasi penjumlahan, perkalian dan pemangkatan bilangan integer.

Contoh yang dibahas dalam sub bab ini hanyalah memberikan pola berpikir rekursif terhadap type sederhana (integer). Dalam kenyataannya, memang pemrogram tidak menuliskan lagi fungsi rekursif untuk penjumlahan, pengurangan, pembagian karena sudah dianggap operator dasar.

Contoh-1 Penjumlahan bilangan bulat dengan ekspresi rekursif

Tuliskanlah sebuah fungsi yang menjumlahkan dua buah integer, dan menghasilkan sebuah integer, dengan membuat definisi rekursif dari penjumlahan

def Plus(x: int, y: int) -> int:
    if x == 0:
        return y
    else:
        return Plus(x - 1, y + 1)

Contoh-2 Perkalian bilangan bulat dengan ekspresi rekursif

Tuliskanlah definisi, spesifikasi dan realisasi sebuah fungsi yang mengalikan dua buah integer, dan menghasilkan sebuah integer, dengan membuat definisi rekursif dari perkalian.

def Mul(x: int, y: int) -> int:
    if y == 0:
        return 0
    else:
        return x + Mul(x, y - 1)

Contoh-2 Pemangkatan bilangan bulat dengan ekspresi rekursif

Tuliskanlah definisi, spesifikasi dan realisasi sebuah fungsi yang memangkatkan sebuah integer dengan sebuah integer, dan menghasilkan sebuah integer, dengan membuat definisi rekursif dari pemangkatan.

def Exp(x: int, y: int) -> int:
    if y == 0:
        return 1
    return x * Exp(x, y - 1)

LIST

IL/Diktat IF1281 Dasar Pemrograman/Bagian I - Notasi Fungsional.doc – Page 63 of 127

Definisi

LIST adalah sekumpulan elemen list yang bertype sama. Jadi list adalah koleksi objek. Elemen list mempunyai keterurutan tertentu (elemen-ke…, ada pengertian suksesor, predesesor), nilai satu elemen boleh muncul lebih dari satu kali.

def IsEmpty(L: list) -> bool:
    return len(L) == 0
 
def IsOneElmt(L: list) -> bool:
    return len(L) == 1
 
def FirstElmt(L: list) -> any:
    return L[0]
 
def Tail(L: list) -> list:
    tail_list = []
    for i in range(1, len(L)):
        tail_list.append(L[i])
 
    return tail_list
 
def Konso(e: any, L: list) -> list:
    new_list = [e]
    for item in L:
        new_list.append(item)
    return new_list
 
def KonsoGue(e: any, L: list) -> list:
    return [e] + L
 
def Kons(L: list, e: any) -> list:
    new_list = []
    for item in L:
        new_list.append(item)
 
    new_list.append(e)
    return new_list
 
def KonsGw(L: list, e: any) -> list:
    return L + [e]

Contoh1 : Banyaknya elemen sebuah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menghasilkan banyaknya elemen sebuah list. Contoh aplikasi dan hasilnya:

NbElmt ([ ]) = 0 ; NBElmt ([ a, b, c]) = 3

def NbElmt(L: list) -> int:
    if IsEmpty(L):
        return 0
    else:
        return 1 + NbElmt(Tail(L))

Contoh 2: keanggotaan elemen

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah predikat yang memeriksa apakah sebuah elemen x merupakan anggota dari list. Contoh aplikasi dan hasilnya:

IsMember (x, [ ]) = false; IsMember (x, [a, b, c] ) = false
IsMember (b, [a, b, c] ) = true

def IsMember(x: any, L: list) -> bool:
    if IsEmpty(L):
        return False
    return x == FirstElmt(L) or IsMember(x, Tail(L))

Contoh 3 : menyalin sebuah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menghasilkan salinan (copy) dari sebuah list, yaitu semua elemennya sama. Contoh aplikasi dan hasilnya adalah :

Copy ( [ ]) = [ ]; Copy ([a, b, c] ) = [a, b, c]

def CopyGw(L: list) -> list:
    return L.copy()
 
def Copy(L: list) -> list:
    if IsEmpty(L):
        return []
    return Konso(FirstElmt(L), Copy(Tail(L)))

Contoh 4: Membalik sebuah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menerima sebuah list, dan menghasiilkan list yang urutan elemennya terbalik dibandingkan urutan elemen pada list masukan. Contoh aplikasi dan hasilnya:

Inverse ( [ ] ) = [ ] ; Inverse ([a, b, c] ) = [c, b, a]

def Inverse(L: list) -> list:
    if IsEmpty(L):
        return []
    return Kons(Inverse(Tail(L)), FirstElmt(L))

Contoh 5: Kesamaan dua buah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah predikat yang memeriksa apakahdua buah elemen list sama. Dua buah list sama jika semua elemennya sama, dan urutan kemunculannya sama.. Contoh aplikasi dan hasilnya:

IsEqual ([], [ ]) = true ; IsEqual ([], [a ]) = false;
IsEqual([a,b,c], [a, b, c] ) = true

def IsEqual(L1: list, L2: list) -> bool:
    if IsEmpty(L1) and IsEmpty(L2):
        return True
    if IsEmpty(L1) or IsEmpty(L2):
        return False
    if FirstElmt(L1) == FirstElmt(L2):
        return IsEqual(Tail(L1), Tail(L2))
    return False

Contoh 6: Elemen ke N sebuah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menghasilkan elemen ke N dari sebuah list. N lebih besar dari Nol, dan list tidak boleh kosong dan N ≤ banyaknya elemen list. . Contoh aplikasi dan hasilnya:

ElmtKeN (0, [] ) = tidak terdefinisi karena list kosong tidak dapat menghasilkan elemen;
maka analisa rekurens harus berbasis satu dan list tidak kosong
ElmtKeN (1, [a,b,c] ) = a; Rekurens dilakukan terhadap N, dan juga terhadap list:

def ElmtKeN(N: int, L: list) -> any:
    if N == 1 :
        return FirstElmt(L)
    ElmtKeN(N - 1, Tail(L))

Contoh 7: Konkatenasi dua buah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menerima dua buah list, dan menghasilkan konkatenasi dari kedua list tersebut. Contoh aplikasi dan hasilnya:

Concat ([ ], [ ]) = [ ]; Concat ([a], [b,c]) = [a,b,c]

def Konkat(L1: list, L2: list) -> list:
    if IsEmpty(L1):
        return L2
    return Konso(FirstElmt(L1), Konkat(Tail(L1), L2))

Contoh 8: Apakah banyaknya elemen sebuah list adalah N

Tuliskanlah definisi, spesifikasi dan relaisasi sebuah predikat yang memeriksa apakah banyaknya elemen sebuah list = N, dengan N>=0. Contoh aplikasi dan hasilnya:

IsNBElmtN (0,[]) = true ; IsNBElmtN (3,[a,b,c]) = true;
IsNBElmtN (0,[a]) = false

def IsNBElmtN(N: int, L: list) -> bool:
    if N == 0:
        if IsEmpty(L):
            return True
        else:
            return False
    return IsNBElmtN(N - 1, Tail(L))

Contoh 9: Apakah X adalah Elemen ke N sebuah list

Tuliskanlah sebuah predikat yang memeriksa apakah X adalah elemen ke N dari sebuah list. N lebih besar dari Nol, dan list tidak boleh kosong. N positif, dan bernilai 1 s/d banyaknya elemen list

def IsXElmtN(x: any, N: int, L: list) -> bool:
    if N == 0:
        if IsEmpty(L):
            return False
        else:
            return x == FirstElmt(L)
    return IsXElmtN(x, N - 1, Tail(L))

Contoh 10: Apakah inverse

Tuliskanlah definisi, spesifikasi dan realisasi dari dari sebuah predikat yang memeriksa apakah sebuah list adalah inverse dari list lain

def IsInverse(L1: list, L2: list) -> bool:
    if IsEmpty(L1) and IsEmpty(L2):
        return True
    if IsEmpty(L1) or IsEmpty(L2):
        return False
    if FirstElmt(L1) == FirstElmt(L2):
        return IsInverse(Tail(L1), Tail(L2))
    return False

List of Character (Teks)

Teks adalah list yang elemennya terdiri dari karakter. Karakter adalah himpunan terhingga dari ‘a’..’z’, ‘A..’Z’, ‘0..9’

Contoh-1 Teks : Hitung A

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menghitung kemunculan huruf ‘a’ pada suatu teks.

def nba(x: str) -> int:
    if IsEmpty(x) :
        return 0
    return nba(Head(x) + if Lastchar(x) == 'a' then 1 else 0)

Contoh-2 Teks : Banyaknya kemunculan suatu karakter pada teks T

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang menghitung banyaknya kemunculan sebuah karakter dalam teks.

def nbx(C: str, x: str) -> int:
    if IsEmpty(C):
        return 0
    if LastChar(T) == C :
        return 1 + nbx(C,Head(T))
    return nbx(C,Head(T))

Himpunan (Set)

Definisi: Himpunan (set) adalah sebuah list yang setiap elemennya hanya muncul sekali (unik). List "kosong" adalah himpunan kosong. Contoh :

[apel, jeruk, pisang] adalah himpunan

[apel, jeruk, mangga, jeruk] bukan himpunan

Contoh 1: Menghapus SEBUAH elemen sebagai anggota list

Predikat ini dibutuhkan untuk membentuk himpunan

def rember(x, L: List) -> List:
    if IsEmpty(L):
        return []
    if x == FirstElmt(L):
        return Tail(L)
    return Konso(FirstElmt(L), rember(x, Tail(L)))

Contoh 2: Menghapus SEMUA elemen e sebagai anggota list :

def MultiRember(x: any, L: List) -> List:
    """MultiRember (x,L)  menghapus semua elemen bernilai x dari list"""
    if IsEmpty(L):
        return []
    if x == FirstElmt(L):
        return MultiRember(x, Tail(L))
    return Konso(FirstElmt(L), MultiRember(x, Tail(L)))

Contoh 3: Mentest apakah sebuah list adalah himpunan

def IsSet(L: List) -> bool:
    if IsEmpty(L):
        return True
    return IsMember(FirstElmt(L), L) and IsSet(Tail(L))

Contoh 4: Membuat sebuah set dari sebuah list

Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah fungsi yang akan membentuk sebuah Himpunan dari elemen-elemennya, yaitu dengan meniadakan duplikasi elemen

def MakeSet(L: List) -> List:
    if IsEmpty(L):
        return []
    if IsMember(FirstElmt(L), Tail(L)):
        return MakeSet(Tail(L))
    return Konso(FirstElmt(L), MakeSet(Tail(L)))
 
def MakeSet2(L: List) -> List:
    if IsEmpty(L):
        return []
    return Konso(FirstElmt(L), MakeSet2(MultiRember(FirstElmt(L), Tail(L))))

Contoh 5: Mentest apakah sebuah set merupakan subset dari set yang lain

def IsSubset(H1: List, H2: List) -> bool:
    """true jika H1 merupakan subset dari H2"""
    if IsEmpty(H1):
        return True
    if not IsMember(FirstElmt(H1), H2):
        return False
    return IsSubset(Tail(H1), H2)

sisanya liat di github aj

List of List (List List [[]])

Definisi Rekursif List of List

List of list adalah sebuah list yang:

Mungkin kosong,
Mungkin terdiri dari sebuah elemen yang disebut atom dan sisanya adalah list of list,
Mungkin terdiri dari sebuah elemen berupa list dan sisanya adalah list of list.

Jadi, List of List adalah sebuah list S yang elemennya adalah list. Dalam bahasa LISP, tipe ini disebut sebagai S-expression.

Membedakan Antara List dan Atom

List dituliskan di antara tanda kurung ().
Atom dituliskan tanpa tanda kurung.

Contoh List

[] adalah list kosong.
[ad, a, b] adalah list dengan elemen berupa 3 atom.
[[], [a, b, c], [d, e], f] adalah list yang berisi:
- sebuah list kosong,
- L1 (sebuah list dengan 3 atom yaitu a, b, dan c),
- L2 (sebuah list dengan 2 atom yaitu d dan e),
- dan sebuah atom f.

Konstruktor dan Selektor

Untuk list khusus ini, nama konstruktor dan selektor tidak dibedakan dengan list yang hanya mengandung elemen dasar. Namun, diperlukan predikat tambahan untuk menentukan apakah sebuah ekspresi adalah Atom atau List.

Jenis Atom

Atom dapat berupa:

Atom numerik (dapat digunakan sebagai operan dalam ekspresi aritmatika),
Atom simbolik.

TYPE LIST-OF-LIST

DEFINISI DAN SPESIFIKASI PREDIKAT KHUSUS UNTUK LIST OF LIST

def IsEmpty(S: list[list]) -> bool:
    """IsEmpty(L) benar jika S adalah list of list kosong"""
    return S == [] or S == [[]]

def IsAtom(S: list[list]) -> bool:
    """IsAtom(S) menghasilkan true jika list adalah atom, yaitu terdiri dari sebuah atom"""
    return not isinstance(S, list)

def IsList(S: list[list]) -> bool:
    """IsList(S) menghasilkan true  jika S adalah sebuah list (bukan atom)"""
    return isinstance(S, list)

DEFINISI DAN SPESIFIKASI KONSTRUKTOR

def Konslo(e: List, L: List[List]) -> List[List]:
    """Konslo(e,L) mengisi list of list L dengan elemen e sebagai elemen pertama jika e tidak ada di dalam list of list L"""
    return e + L

def Konsli(L: List[List], e: List) -> List[List]:
    """Konsli(L,e) mengisi list of list L dengan elemen e sebagai elemen terakhir jika e tidak ada di dalam list of list L"""
    return L + e

DEFINISI DAN SPESIFIKASI SELEKTOR

def FirstElmt(S: List[List]) -> List:
    """FirstElmt(S) menghasilkan elemen pertama dari list of list S"""
    return S[0]

def Tail(S: List[List]) -> List[List]:
    """Tail(S) menghasilkan list of list yang berisi elemen-elemen selanjutnya dari list of list S"""
    return S[1:]

def HeadList(S: List[List]) -> list:
    """{HeadList(S) Menghasilkan  "sisa" list of list S  tanpa elemen terakhir list  S"""
    return S[:-1]

def LastList(S: List[List]) -> list:
    """LastList(L) mengembalikan elemen terakhir list of list"""
    return S[-1]

Contoh-1 : Mencek kesamaan dua buah list of list:

Persoalan: Tuliskanlah definisi, spesifikasi dan realisasi dari sebuah predikat yang mencek kesamaan dua buah list of list

def IsEqS(S1: List[List], S2: List[List]) -> bool:
    """IsEqS(S1,S2) mengembalikan True jika S1 dan S2 sama"""
    if IsEmpty(S1) and IsEmpty(S2):
        return True
    if not IsEmpty(S1) and IsEmpty(S2):
        return False
    if IsEmpty(S1) and not IsEmpty(S2):
        return False
    if IsAtom(FirstList(S1)) and IsAtom(FirstList(S2)):
        if FirstList(S1) == FirstList(S2):
            return IsEqS(TailList(S1), TailList(S2))
        return False
    if IsList(FirstList(S1)) and IsList(FirstList(S2)):
        return IsEqS(FirstList(S1), FirstList(S2)) and IsEqS(TailList(S1), TailList(S2))
    return False

Contoh-2 : Contoh-2 : Mencek apakah sebuah atom merupakan elemen sebuah list yang elemennya list:

IsMemberS(A,S)

def IsMemberS(A: any, S: List[List]) -> bool:
    """IsMember(A,L) mengembalikan True jika A adalah anggota elemen list of list L"""
    if IsEmpty(S):
        return False
    if IsAtom(FirstList(S)):
        return A == FirstList(S)
    if IsList(FirstList(S)):
        return IsMember(A, FirstList(S)) or IsMemberS(A, TailList(S))

Contoh-3 : Mencek apakah sebuah List merupakan elemen sebuah list yang elemennya list

def IsMemberLS(L, S):
    """true jika L adalah anggota S"""
    if IsEmpty(L) and IsEmpty(S):
        return True
    if not IsEmpty(L) and IsEmpty(S):
        return False
    if IsEmpty(L) and not IsEmpty(S):
        return False
    if IsAtom(FirstList(S)):
        return IsMemberLS(L, TailList(S))
    if IsEqS(L, FirstList(S)):
        return True
    return IsMemberLS(L, TailList(S))

← back to me blog