COMPUTER SCIENCE AL21 by Susilawati

susilawati — 2022-06-15 06:33:53 UTC

susilawati — 2022-06-15 06:55:28 UTC

Exercise 24 June 2022(Friday)

susilawati — 2022-06-24 00:39:12 UTC

HARUN - Exercise 24 June

2022-06-24 01:21:02 UTC

Adlee - Exercise 24 June

AdleeHakimi — 2022-06-24 01:23:49 UTC

DIYANA - Exercise 24 June

2022-06-24 01:41:29 UTC

2022-06-24 01:48:57 UTC

Julia-Exercise 24th June

2022-06-24 01:57:23 UTC

Rania - Exercise 24th June

2022-06-24 02:00:06 UTC

HAMZAH - 24th June

2022-06-24 02:18:58 UTC

Najmi

2022-06-24 02:22:15 UTC

Aiman - Exercise 24th june

2022-06-24 03:06:57 UTC

susilawati — 2022-06-26 15:19:05 UTC

susilawati — 2022-06-26 15:19:28 UTC

susilawati — 2022-06-26 15:20:06 UTC

susilawati — 2022-06-26 15:20:19 UTC

susilawati — 2022-06-26 15:22:16 UTC

susilawati — 2022-06-26 15:23:23 UTC

HARUN - Exercise 28 June

2022-06-28 12:37:24 UTC

Aiman - Exercise 28/6

aimandaud — 2022-06-28 12:50:21 UTC

DIYANA - EXERCISE 28 JUNE

2022-06-29 02:50:45 UTC

Rania

2022-06-29 04:05:01 UTC

Hamzah part1

2022-06-29 05:14:18 UTC

Hamzah Part 2

2022-06-29 05:15:04 UTC

Adlee - Exercise 28 June

AdleeHakimi — 2022-06-29 07:32:03 UTC

AL Najmi

2022-06-29 07:55:02 UTC

EXERCISE 1 JULY 2022(FRIDAY)

susilawati — 2022-06-30 01:42:38 UTC

HARUN - Exercise 1 July

2022-07-01 01:49:47 UTC

DIYANA - EXERCISE 1 JULY

2022-07-03 13:30:08 UTC

Rania- exercise floating point num

2022-07-03 15:33:05 UTC

AL Najmi ( 1 July)

2022-07-03 16:36:22 UTC

susilawati — 2022-07-04 08:10:35 UTC

susilawati — 2022-07-04 08:13:00 UTC

AIMAN - Exercise 1 July

aimandaud — 2022-07-05 04:49:32 UTC

susilawati — 2022-07-06 16:20:12 UTC

susilawati — 2022-07-06 16:26:11 UTC

susilawati — 2022-07-06 16:26:54 UTC

susilawati — 2022-07-06 16:28:03 UTC

HTTP Protocol - Video - Adlee

AdleeHakimi — 2022-07-07 12:51:33 UTC

HTTP - Mind map - Adlee

AdleeHakimi — 2022-07-07 12:52:22 UTC

POP3

2022-07-07 13:18:36 UTC

Rania

2022-07-07 13:26:06 UTC

SMTP - AIMAN

aimandaud — 2022-07-07 13:32:34 UTC

https://www.youtube.com/watch?v=PJo5yOtu7o8

IMAP-Julia

2022-07-14 00:18:28 UTC

https://youtu.be/_XD9uWeliLY

susilawati — 2022-07-19 04:20:20 UTC

susilawati — 2022-07-19 04:31:02 UTC

susilawati — 2022-07-21 00:08:30 UTC

HAMZAH-8 Marks

mnhamzah — 2022-07-21 00:20:31 UTC

susilawati — 2022-07-21 00:33:33 UTC

Rania's answer (10/13)

2022-07-21 00:33:47 UTC

Julia 10/13

2022-07-21 00:36:30 UTC

HARUN FILE 1

2022-07-21 00:37:15 UTC

Al Najmi

2022-07-21 00:37:16 UTC

HARUN FILE 2

2022-07-21 00:37:55 UTC

susilawati — 2022-07-21 00:42:01 UTC

Hamzah - 6

mnhamzah — 2022-07-21 00:43:02 UTC

Sorry teacher, I didn't finish this exercise because I am sick yesterday

Aiman's

aimandaud — 2022-07-21 00:43:53 UTC

susilawati — 2022-07-21 01:52:38 UTC

DIYANA - EXERCISE 1 (10/13)

2022-07-21 05:00:29 UTC

DIYANA - EXERCISE 2

2022-07-21 05:00:44 UTC

2022-07-22 01:27:16 UTC

susilawati — 2022-08-01 15:22:23 UTC

susilawati — 2022-08-09 05:05:54 UTC

susilawati — 2022-08-11 00:19:48 UTC

susilawati — 2022-08-12 00:45:08 UTC

susilawati — 2022-08-14 16:42:19 UTC

SYSTEM SOFTWARE GROUP PRESENTATION

2022-08-18 00:09:15 UTC

susilawati — 2022-08-23 04:26:36 UTC

16.3.2 : Stages in Compilation of Program

AdleeHakimi — 2022-08-23 04:36:14 UTC

susilawati — 2022-08-29 03:44:38 UTC

susilawati — 2022-08-29 04:01:54 UTC

susilawati — 2022-08-29 04:27:59 UTC

susilawati — 2022-09-13 04:05:28 UTC

susilawati — 2022-09-19 08:34:15 UTC

susilawati — 2022-09-20 06:31:46 UTC

susilawati — 2022-09-22 01:01:57 UTC

susilawati — 2022-09-23 00:14:29 UTC

susilawati — 2022-09-27 03:19:15 UTC

AI GROUP 1

2022-10-04 03:36:53 UTC

AI slide - second group

AdleeHakimi — 2022-10-04 03:37:20 UTC

susilawati — 2022-10-04 04:53:11 UTC

susilawati — 2022-10-17 04:38:22 UTC

Rania punyaaaa

2022-10-18 05:16:29 UTC

myList = [2,3,5,7,9,12,15,23,27,32]
UI=9
LI=0
item=int(input("whatchu want? "))
found=False
while found==False and LI <=UI:
    i=int((UI+LI)/2)
    if (item == myList[i]):
        found=True
    elif(item>myList[i]):
        LI=i+1
    elif(item

Diyana

2022-10-18 05:19:28 UTC

myList = [16,19,21,27,36,42,55,67,76,89]

highest = len(myList)-1
lowest = 0
num = int(input("Enter a number "))
found = False

while found == False and lowest<=highest :
    i = int((highest + lowest) / 2)
    if num > myList[i]:
        lowest = i+1
    elif num < myList[i]:
        highest = i-1
    else :
        found = True

if found :
    print("Value is found at index",i)
else :
    print("Value is not found")

HARUN

2022-10-18 05:32:12 UTC

myList = [16,19,21,27,36,42,55,67,76,89]

highest = len(myList) - 1
lowest = 0

item = int(input("enter target number: "))
found = False

while not found and highest >= lowest:
    index = int((highest+lowest)/2)
    if item == myList[index]:
        found = True
    if item > myList[index]:
        lowest = index + 1
    if item < myList[index]:
        highest = index - 1

if found:
    print("found at: ", index + 1)
else:
    print("not found")

najmi

2022-10-18 05:35:46 UTC

myList=[1,2,3,4,5,6,7,8,9]
num=int(input('input item to search'))
found=False
lowerBound=0
upperBound=len(myList)-1
while lowerBound<=upperBound and not found:
    #get middle elements
    mid=(lowerBound+upperBound)//2

    #if found
    if num==myList[mid]:
        found=True
    #mid>num, remove right half.else remove left half
    if num myList[mid]:
        lowerBound=mid+1
if found:
    print("found")
else:
    print("not found")

Adlee

2022-10-18 05:35:54 UTC

#DECLARE List : ARRAY[1:10] OF #INTEGER
#DECLARE Number, i, Search, UpperBound, LowerBound : INTEGER
DECLARE Found : BOOLEAN'''

index = 0
LowerBound = 0
UpperBound = 9
Found = False
Item = 0
MyList = [1,2,3,4,5,6,7,8,9,10]

Item = int(input("Find a number : "))
while (not Found) or (UpperBound == LowerBound):
    index = int(((LowerBound + UpperBound) / 2))
    if Item == MyList[index]:
        Found = True
    if Item > (MyList[index]):
        LowerBound = index + 1
    elif Item < (MyList[index]):
        UpperBound = index - 1

if Found:
    print("Found")
else:
    print("Not Found")

Aiman

2022-10-18 05:37:08 UTC

Julia Punya

2022-10-18 05:37:21 UTC

myList=[1,2,5,7,8,9,11,13,18,19]
Highest=9
Lowest=0
item=int(input("Enter item to be found"))
found=False
while found==False and Highest <= Lowest:
    index=int((Highest+Lowest)/2)
    if (item==myList[index]):
        found=True
    if (item>myList[index]):
        Lowest=index+1
    if (item

Hamzah punya

2022-10-18 05:39:21 UTC

'''
DECLARE MyList : ARRAY {1,9} OF INTEGER
DECLARE found : BOOLEAN
DECLARE highIndex , lowIndex , index , item : BOOLEAN
'''
mylist = [1,2,3,4,5,6,7,8,9,10]
highIndex = 9
lowIndex = 0
item = int(input("Search item "))
found = False
while found == False and highIndex >= lowIndex:
    index = int((highIndex + lowIndex)/2)
    if item == mylist[index]:
        found = True
    elif item > mylist[index]:
        lowIndex = index + 1
    elif item < mylist[index]:
        highIndex = index - 1

if found == True:
    print("item found")
    print(index)
else:
    print("item not found")

Aiman 2

2022-10-20 01:36:35 UTC

Diyana

2022-10-20 01:49:20 UTC

myList = [27,19,36,42,16,89,21,16,55]

i = 0
UB = len(myList)
print(myList)
swap = True
while swap == True or UB > 0 :
    for i in range (UB-1) :
        swap = False
        if myList[i] > myList[i+1] :
            temp = myList[i]
            myList[i] = myList[i+1]
            myList[i+1] = temp
            swap = True
        i = i+1
    UB = UB-1
print(myList)

Rania punyaaa (bubble)

2022-10-20 01:49:28 UTC

myList=[2,34,5,11,8,7,12,56]
UB=len(myList)
LB=0
top=UB
swap=False
while swap==True or top !=0:
    for i in range (top-1):
        swap=False
        if myList[i]>myList[i+1]:
            temp=myList[i]
            myList[i]=myList[i+1]
            myList[i+1]=temp
            swap=True
    top -=1

print(myList)

Aiman - Bubble Sort

2022-10-20 01:49:32 UTC

Bubble Sort - Harun

2022-10-20 01:50:50 UTC

myList = [4,2,8,17,9,3,7,12,34,21]
#myList = [4,3,2,1]
upBound = len(myList) - 1
noSwap = False
while not noSwap:
    index = 0
    noSwap = True
    for index in range(upBound):
        if myList[index] > myList[index + 1]:
            temp = myList[index]
            myList[index] = myList[index + 1]
            myList[index + 1] = temp
            noSwap = False
        index += 1
    upBound -= 1
print(myList)

jULIA

2022-10-20 01:51:30 UTC

myList=[7,2,9,4,8,1,5,3,6]
UB=len(myList)
swap=True
while swap or (top>0):
    swap=False
    for index in range(top-1):
        if myList[index]>myList[index+1]:
            temp=myList[index]
            myList[index]=myList[index+1]
            myList[index+1]=temp
            swap=True
    UB=UB-1
print("Array is sorted")
print(myList)

Adlee

2022-10-20 01:52:19 UTC

myList = [43,4,32,6,87654,23,555,63,2,0]
lowerBound = 0
upperBound = 9
inBetweenNumber = 0
j = 0
swap = False


while swap or (j <= upperBound):
    highestNumber = 0
    swap = False
    for index in range(upperBound - j):
        if myList[index] > highestNumber:
            highestNumber = myList[index]
            inBetweenNumber = myList[upperBound - j]
            myList[upperBound - j] = highestNumber
            myList[index] = inBetweenNumber
            swap = True
    j += 1

print(myList)

najmi(BS)

2022-10-20 01:53:07 UTC

myList=[5,2,7,9,3,6,5]
sorted=myList
sortFlag=True
while sortFlag==True:
    sortFlag=False
    for i in range(len(sorted)-1):
        if sorted[i]>sorted[i+1]:
            temp=sorted[i]
            sorted[i]=sorted[i+1]
            sorted[i+1]=temp
            sortFlag=True
print(sorted)

Hamzah Bubble

2022-10-20 01:55:14 UTC

'''DECLARE myList : ARRAY[0:14] of INTEGER
DECLARE upperbound , lowerbound , index , temp , top: INTEGER
DECLARE swap : BOOLEAN'''

myList = [8, 6, 4, 2, 56, 10, 98, 32, 21, 89, 48, 47, 35, 14, 42]
top = len(myList)
swap = True

while swap or top > 0:
    swap = False
    for index in range(top-1):
        if myList[index] > myList[index+1]:
            temp = myList[index]
            myList[index] = myList[index+1]
            myList[index+1] = temp
            swap = True
    top = top - 1
print(myList)

Rania punyaaa (insertion)

2022-10-21 01:50:19 UTC

#LL: lower list
#UL: upper list
#x: current item

myList=[44,8,52,15,90,21,34,12,7]
print("before: ",myList)
LL=0
UL=len(myList)

for i in range (LL+1,UL):
    x=myList[i]
    left=i-1
    if myList[left]>x:
        while left>=LL and myList[left]>x:
            temp = myList[left + 1]
            myList[left + 1] = myList[left]
            myList[left] = temp
            left -= 1

print("after: ",myList)

Aiman - Insertion sort

2022-10-21 01:52:13 UTC

myList = [2, 56, 76, 32, 33, 11, 23, 53, 43, 22]

for i in range(len(myList)):
    j = i
    while j > 0 and myList[j-1] > myList[j]:
        temp = myList[j]
        myList[j] = myList[j-1]
        myList[j-1] = temp
        j -= 1
print(myList)

Insertion Sort - Harun

2022-10-21 01:54:14 UTC

myList = [4,2,8,17,9,3,7,12,34,21]
print("before sorted: ", myList)
index = 1
for index in range(len(myList)):
    left = index - 1
    insertElement = myList[index]

    while left >= 0 and myList[left] > insertElement:
        myList[left+1] = myList[left]
        left -= 1

    myList[left + 1] = insertElement

print("after sorted: ", myList)

Hamzah cem Insertion

2022-10-21 01:58:01 UTC

# DECLARE mylist : ARRAY[0:5] OF INTEGER
# DECLARE Noitem : INTEGER
# DECLARE index : INTEGER
# DECLARE current : INTEGER
# DECLARE left : BOOLEAN

myList = [54, 86, 34, 49, 37]
Noitem = len(myList)#5
print("Ori list",myList)

for index in range(Noitem):#0,1,2,3,4
    current = myList[index]
    left = index - 1
    while myList[left] > current and left > -1:
        myList[left + 1] = myList[left]
        left = left - 1
    myList[left+1] = current

print("sort list" ,myList)

Lee

2022-10-21 02:02:08 UTC

myList = [43,2,65,4,765,43,325,63,44,9]
tempNum = 0
upperBound = len(myList)
lowerBound = 0
index = 1
counter = 1

for counter in range(upperBound):
    index = counter
    left = index - 1
    while myList[index] < myList[left] and index != 0:
        tempNum = myList[index]
        myList[index] = myList[left]
        myList[left] = tempNum
        index = left
        left = left - 1

print(myList)

Adlee

AdleeHakimi — 2022-10-25 03:57:11 UTC

najmi(IS)

2022-10-25 04:00:46 UTC

mylist=[23,7,4,8,43,23,48,1,29,15]
for index in range(len(mylist)):
    item = mylist[index]
    leftindex=index-1

    while item=0:
        mylist[leftindex+1]=mylist[leftindex]
        leftindex-=1
    mylist[leftindex+1]=item
print(mylist)

susilawati — 2022-10-25 05:12:46 UTC

Stack - Harun

2022-10-25 05:14:53 UTC

stack = [None for index in range(0,10)]
topPointer = -1
basePointer = 0
stackFull = 10
item = None

def push(item):
    global topPointer
    if topPointer < stackFull-1:
        topPointer += 1
        stack[topPointer] = item
    else:
        print("stack is full, cannot push", item)

def pop():
    global topPointer
    if topPointer >= basePointer:
        item = stack[topPointer]
        stack[topPointer] = None
        topPointer -= 1
        return item
    else:
        print("no more item, cannot pop")

print("initial values of stack:")
print(stack)

print("inserting 7 and 32 in stack")
push(7)
push(32)
print(stack)

print("popping 7 and 32")
pop()
pop()
print(stack)

print("trying to pop item in stack")
pop()
print(stack)

print("pushing 10 elements into stack")
for i in range(1,11):
    push(i)
print(stack)

print("trying to push 11 into stack")
push(11)
print(stack)

najmi (stack)

2022-10-25 05:18:14 UTC

stack=[None for index in range(10)]
basePointer=0
topPointer=-1
stackFull=10
item=None

def push(newItem):
    global topPointer
    if topPointer

Lee

2022-10-25 05:18:39 UTC

basePointer = 0
topPointer = 0
maxItem = 10
stack = [None for index in range(0,maxItem - 1)]
item = 0

def pushItem():
    global topPointer
    if topPointer <= maxItem - 1:
        item = input("Add a number into the stack : ")
        topPointer += 1
        stack.append(item)
        print(stack)
    else:
        print("Stack is full!")

def popItem():
    global topPointer
    global basePointer
    if topPointer > basePointer:
        topPointer -= topPointer
        stack.remove(stack[basePointer])
        print(stack)
    else:
        print("Stack is Empty!")

status = input("Continue (Y/N) : ")
actionStack = input("Push or Pop : ")
while status == "Y":
    if actionStack == "Push":
        pushItem()
    elif actionStack == "Pop":
        popItem()
    status = input("Continue (Y/N) : ")
    actionStack = input("Push or Pop : ")

susilawati — 2022-10-26 16:00:13 UTC

Hamzah stack

2022-10-27 00:32:40 UTC

stack = [None for index in range(0,10)]
topPointer = -1
NullPointer = 0
StackSize = 10
item = None

def push(item):
    global topPointer
    if topPointer < StackSize - 1:
        topPointer = topPointer + 1
        stack[topPointer] = item
    else:
        print("No more room, cant push", item)

def pop():
    global topPointer
    if topPointer >= NullPointer:
        item = stack[topPointer]
        stack[topPointer] = None
        topPointer = topPointer - 1
        return item
    else:
        print("Stack empty, can't pop")

print("initial value of stack:")
print(stack)

print("pushing 7 and 32")
push(7)
push(32)
print(stack)

print("popping 7 and 32")
pop()
pop()
print(stack)

print("Popping empty stack")
pop()

print("Pushing 1-10 into stack")
for index in range(1,11):
    push(index)
print(stack)

print("Pushing 11 into stack")
push(11)

susilawati — 2022-10-27 00:32:45 UTC

Diyana - Stack

2022-10-27 00:42:32 UTC

stack = [None for index in range (0,10)]
basePointer = 0
topPointer = -1
stackFull = 10
item = None

def push(item) :
    global topPointer
    if topPointer < stackFull - 1 :
        topPointer = topPointer + 1
        stack[topPointer] = item
        print("\nValues after pushing",item,":",stack)
    else :
        print("\nStack is full, cannot push")
        print(stack)

def pop(item) :
    global topPointer, basePointer
    if topPointer == basePointer-1 :
        print("\nStack is empty, cannot pop")
        print(stack)
    else :
        stack[topPointer] = None
        topPointer = topPointer - 1
        print("\nValues after popping",item,":",stack)

print("Initial values in stack :",stack)

print("\nPushing 7 and 32")
push(7)
push(32)

print("\nPopping 7 and 32")
pop(7)
pop(32)

print("\nTrying to pop 3rd integer")
pop(8)

print("\nPushing 1,2,3,4,5,6,7,8,9,10")
push(1)
push(2)
push(3)
push(4)
push(5)
push(6)
push(7)
push(9)
push(9)
push(10)

print("\nTrying to push 11")
push(11)

Rania punyaaa

2022-10-27 00:43:49 UTC

Rania punyaaa

2022-10-27 00:46:02 UTC

stack = [None for index in range(0,10)]
topPointer = -1
basePointer = 0
stackFull = 10
item = None

def push(item):
    global topPointer
    if topPointer < stackFull-1:
        topPointer += 1
        stack[topPointer] = item
    else:
        print("stack is full, cannot push", item)

def pop():
    global topPointer
    if topPointer >= basePointer:
        item = stack[topPointer]
        stack[topPointer] = None
        topPointer -= 1
        return item
    else:
        print("no more item, cannot pop")

print("initial values of stack:")
print(stack)

print("inserting 3 in stack")
push(3)
print(stack)

print("popping 3")
pop()
print(stack)

print("trying to pop item in stack")
pop()
print(stack)

print("pushing 10 elements into stack")
for i in range(1,11):
    push(i)
print(stack)

print("trying to push 11 into stack")
push(11)
print(stack)

Julia

juliajunaidi — 2022-10-27 00:52:35 UTC

Harun's Evidence File

2022-10-27 01:13:23 UTC

Aiman's

2022-10-27 01:18:01 UTC

Muhamad Adlee Hakimi bin Mohd Nazlee bin Rasol

2022-10-27 01:18:30 UTC

Nur Diyana Amani Khairuddin

2022-10-27 01:29:52 UTC

Muhammad AL Najmi bin Khairil Yusrizar

2022-10-27 01:38:25 UTC

Muhammad Nur Hamzah Bin Norazam

2022-10-27 01:45:44 UTC

Julia hannah

2022-10-28 01:43:51 UTC

stack=[None for index in range (0,10)]
basePointer=0
topPointer=-1
stackFull=10
item=None
i=0

def push(item):
    global topPointer
    if topPointer=basePointer:
        item=stack[topPointer]
        stack[topPointer]=None
        topPointer=topPointer-1
        return item
    else:
        print("Stack is empty cannot pop")

print(stack)
print("Pushing 7  onto the stack")
push(7)
print(stack)

print("Trying to pop item in stack")
pop()
print(stack)
pop()

print("Pushing 10 elements into stack")
while i<11:
    push(i)
    i=i+1
print(stack)


print("push 11 into stack,cannot push")
push(11)
print(stack)

Queue - Harun Azhar

2022-10-31 04:57:40 UTC

thisQueue = [None for i in range(5)]
frontPointer = 0
rearPointer = -1
queueFull = 5
queueLength = 0

def enqueue(num):
    global thisQueue, queueLength, rearPointer, queueFull

    if queueLength < queueFull:
        if rearPointer < queueFull-1:
            rearPointer += 1
        else:
            rearPointer = 0
        queueLength += 1
        thisQueue[rearPointer] = num
    else:
        print("queue is full, cannot enque")

def dequeue():
    global queueLength, thisQueue, frontPointer, queueFull

    if queueLength == 0:
        print("queue is empty, cannot deque")
        return None
    else:
        num = thisQueue[frontPointer]
        thisQueue[frontPointer] = None
        if frontPointer == queueFull - 1:
            frontPointer = 0
        else:
            frontPointer += 1
        queueLength -= 1
        return num

print(thisQueue)
print("adding 15 and 45 to queue")
enqueue(15)
enqueue(45)
print(thisQueue)

print("removing 15 and 45 from queue")
dequeue()
dequeue()
print(thisQueue)

print("trying to remove third integer from queue")
dequeue()

print("adding integers 1,2,3,4,5 to queue")
enqueue(1)
enqueue(2)
enqueue(3)
enqueue(4)
enqueue(5)
print(thisQueue)

print("trying to add 7 to queue")
enqueue(7)

Nur Diyana Amani - Queue

2022-10-31 05:19:41 UTC

queue = [None for i in range (0,5)]
frontPointer = 0
rearPointer = -1
lengthQ = 0
queueFull = 5

def enqueue(num) :
    global lengthQ, queueFull, rearPointer
    if lengthQ < queueFull :
        if rearPointer < queueFull-1 : #wrap around
            rearPointer = rearPointer+1
        else :
            rearPointer = 0
        lengthQ = lengthQ + 1
        queue[rearPointer] = num
    else :
        print("Queue is full, cannot enqueue.")

def dequeue() :
    global lengthQ, queueFull, frontPointer

    if lengthQ > 0 :
        if frontPointer < queueFull-1 :
            queue[frontPointer] = None
            frontPointer = frontPointer + 1
            lengthQ = lengthQ - 1
        else :
            frontPointer = 0
    else :
        print("Queue is empty, cannot dequeue.")

print("Pushing 15 and 45")
enqueue(15)
enqueue(45)
print("After operation :",queue)

print("\nRemoving both integers")
dequeue()
dequeue()
print("After operation :",queue)

print("\nTrying to remove 3rd integer")
dequeue()
print("After operation :",queue)

print("\nAdding integers 1 until 5")
numAdd = 1
for i in range (5) :
    enqueue(numAdd)
    numAdd = numAdd + 1
    print("After operation :",queue)

print("\nTring to add 7")
enqueue(7)

Queue - Muhamad Adlee Hakimi bin Mohd Nazlee a.k.a Lee

2022-10-31 05:21:53 UTC

myQueue = [None for index in range(1,10)]
rearPointer = -1
frontPointer = 0
queueLength = (rearPointer - frontPointer)
queueFull = 10

def enqueue():
    global myQueue
    global rearPointer
    global frontPointer
    global queueLength
    global queueFull
    if queueLength < queueFull - 1:
        item = input("Enter Item : ")
        if rearPointer > queueFull - 1:
            rearPointer = 0
            myQueue[rearPointer] = item
        else:
            rearPointer += 1
            myQueue[rearPointer] = item
    else:
        print("Queue is full")
    queueLength = (rearPointer - frontPointer)
    return myQueue

def dequeue():
    global myQueue
    global rearPointer
    global frontPointer
    global queueLength
    global queueFull
    if queueLength >= 0:
        myQueue[frontPointer] = None
        frontPointer += 1
    else:
        print("Queue is empty!")
    queueLength = (rearPointer - frontPointer)
    return myQueue

action = input("Enter action : ")
while action != "":
    if action == "1":
        print(enqueue())
    if action == "2":
        print(dequeue())
    action = input("Enter action : ")

Muhammad Nur Hamzah Bin Norazam AL21.6

2022-10-31 05:26:21 UTC

#QUEUE DATA STRUCTURE
queue = [None for index in range(5)]
frontpointer = 0
rearpointer = -1
queuefull = 5
queuelength = 0
item="power"
#ENQUEUE
def enqueue(item):
    global queuelength, rearpointer, queue
    if queuelength < queuefull:
        if rearpointer < queuefull - 1:
            rearpointer = rearpointer + 1
        else:
            rearpointer = 0
        queuelength = queuelength + 1
        queue[rearpointer] = item
    else:
        print("queue is full, cannot enqueue")
#DEQUEUE
def dequeue():
    global queuelength, frontpointer, queue
    if queuelength ==0:
        print("queue is empty, cant dequeue")
        return None
    else:
        item = queue[frontpointer]
        queue[frontpointer]= None
        if frontpointer == len(queue) - 1:
            frontpointer = 0
        else:
            frontpointer += 1
    queuelength -= 1
#Exercise slide 74
print(queue)
enqueue(15)
enqueue(45)
print(queue)
dequeue()
dequeue()
print(queue)
dequeue()
enqueue(1)
enqueue(2),enqueue(3),enqueue(4),enqueue(5)
print(queue)
enqueue(7)

Aiman Daud

2022-10-31 05:28:27 UTC

'''
DECLARE queue : ARRAY [1:5] OF INTEGER
DELCARE rearPointer : INTEGER
DECLARE frontPointer : INTEGER
DECLARE queueFull : INTEGER
DECLARE queueLength : INTEGER
'''
frontPointer = 0
rearPointer = -1
queueFull = 5
queueLength = 0
queue = [None for i in range(5)]



'''
if queueLength < queueFull:
    if rearPointer < queueFull - 1:
        rearPointer = rearPointer + 1
    else:
        rearPointer = 0
    queueLength = queueLength + 1
    queue[rearPointer] = item
else:
    print('Queue is full, cannot enqueue')
'''



'''
if queueLength == 0:
    print ('Queue is empty, cannot dequeue')
else:
    item = queue[frontPointer]
    if frontPointer == queueFull -1:
        frontPointer = 0
    else:
        frontPointer = frontPointer + 1
    queueLength -= 1
'''



def enqueue(item):
    global queueLength
    global rearPointer
    global queueFull
    global queue
    if queueLength < queueFull:
        if rearPointer < queueFull - 1:
            rearPointer = rearPointer + 1
        else:
            rearPointer = 0
        queueLength = queueLength + 1
        queue[rearPointer] = item
    else:
        print('Queue is full, cannot enqueue')

def dequeue():
    global queueLength
    global frontPointer
    global queueFull
    global queue
    if queueLength == 0:
        print('Queue is empty, cannot dequeue')
        return None
    else:
        item = queue[frontPointer]
        queue[frontPointer] = None
        if frontPointer == queueFull - 1:
            frontPointer = 0
        else:
            frontPointer = frontPointer + 1
        queueLength -= 1

print('pushing 15 and 45 to the queue')
enqueue(15)
enqueue(45)
print(queue)

print('removing 15 and 45')
dequeue()
dequeue()
print(queue)

print('removing a third integer')
dequeue()
print(queue)

print('adding 1,2,3,4,5 to the queue')
enqueue(1)
enqueue(2)
enqueue(3)
enqueue(4)
enqueue(5)
print(queue)

print('adding 7 to the queue')
enqueue(7)
print(queue)

Muhammad Al Najmi(queue)

2022-10-31 05:30:34 UTC

queue=[None for index in range(0,5)]
frontpointer=0
rearpointer=-1
queueFull=5
queuelength=0

def enQueue(item):
    global queuelength,rearpointer
    if queuelengthif rearpointerelse:
            rearpointer=0
        queuelength+=1
        queue[rearpointer]=item
    else:
        print('queue full')

def deQueue():
    global queuelength,frontpointer,item,queue
    if queuelength==0:
        print("empty cannot dequeue")
    else:
        item=queue[frontpointer]
        queue[frontpointer]=None
        if frontpointer==len(queue)-1:
            frontpointer=0
        else:
            frontpointer+=1
    queuelength=queuelength-1

enQueue(15)
enQueue(45)
print(queue)
deQueue()
deQueue()
print(queue)
num=1
for i in range(5):
    enQueue(num)
    num+=1
print(queue)
enQueue(7)

Julia Hannah

2022-10-31 11:56:18 UTC

thisQueue=[None for i in range (5)]
frontPointer=0
rearPointer=-1 
queueFull=5
queueLength=0

def queue(item):
    global rearPointer,queueLength,queueFull
    if queueLength

EXERCISE 3 NOV 2022

susilawati — 2022-11-02 08:21:15 UTC

Muhamad Adlee Hakimi - Linked List (Insert, Search, Delete)

2022-11-03 00:29:56 UTC

myLinkedList = [None for i in range(10)]
myPointerList = [(i + 1) for i in range(10)]
myPointerList[9] = -1
startPointer = -1
heapPointer = 0

def insert(insertItem):
    global myLinkedList, myPointerList, startPointer, heapPointer
    if heapPointer != -1:
        temp = startPointer
        startPointer = heapPointer
        heapPointer = myPointerList[heapPointer]
        myLinkedList[startPointer] = insertItem
        myPointerList[startPointer] = temp
    else:
        print("Linked List is Full!")

def search(searchItem):
    global myLinkedList, myPointerList, startPointer, heapPointer
    itemPointer = startPointer
    found = False
    while not found and itemPointer != -1:
        if myLinkedList[itemPointer] == searchItem:
            found = True
        else:
            itemPointer = myPointerList[itemPointer]
    return found

def searchForDelete(searchItem):
    global myLinkedList, myPointerList, startPointer, heapPointer
    itemPointer = startPointer
    found = False
    while not found and itemPointer != -1:
        if myLinkedList[itemPointer] == searchItem:
            found = True
            return itemPointer
        else:
            itemPointer = myPointerList[itemPointer]

def delete(deleteItem):
    global myLinkedList, myPointerList, startPointer, heapPointer
    oldItemPointer = heapPointer
    itemPointer = startPointer
    found = False
    while not found and itemPointer != -1:
        if myLinkedList[itemPointer] == deleteItem:
            found = True
            heapPointer = itemPointer
            myLinkedList[itemPointer] = None
            myPointerList[oldItemPointer] = myPointerList[itemPointer]
            myPointerList[heapPointer] = startPointer
        else:
            oldItemPointer = itemPointer
            itemPointer = myPointerList[itemPointer]

print("Start Pointer:", startPointer)
print(myLinkedList)
print(myPointerList)
print(end="\n")

insert(27)
insert(19)
insert(36)
insert(42)
insert(16)
insert(18)

print("Inserting 27, 19, 36, 42, 16, 18 : ")
print("Start Pointer:", startPointer)
print(myLinkedList)
print(myPointerList)
print(end="\n")

delete(36)

print("Deleting 36 : ")
print("Start Pointer:", startPointer)
print(myLinkedList)
print(myPointerList)
print(end="\n")

insert(77)

print("Inserting 77 : ")
print("Start Pointer:", startPointer)
print(myLinkedList)
print(myPointerList)
print(end="\n")

print("Searching for 77 : ")
if search(77):
    print("77 is in the list!")
else:
    print("77 is not in the list!")

Muhammad AL Najmi (linked list)

2022-11-03 00:31:06 UTC

linkedList=[27,19,36,42,16,None,None,None,None,None,None,None,]
linkedListPointer=[-1,0,1,2,3,6,7,8,9,10,11,-1]
startPointer=4
nullPointer=-1
heapStartPointer=5
def find(itemSearch):
    found=False
    itemPointer=startPointer
    while itemPointer !=nullPointer and not found:
        if linkedList[itemPointer]== itemSearch:
            found=True
        else:
            itemPointer=linkedListPointer[itemPointer]#the next item pointed by previous one
    return itemPointer

def insert(itemAdd):
    global startPointer,heapStartPointer
    if heapStartPointer==nullPointer:
        print("linked listt full laaaa")
    else:
        tempPointer=startPointer
        startPointer=heapStartPointer
        heapStartPointer=linkedListPointer[heapStartPointer]
        linkedList[startPointer]=itemAdd
        linkedListPointer[startPointer]=tempPointer

def delete(itemDelete):
    global startPointer,heapStartPointer
    if startPointer==nullPointer:
        print('dah kosong dah')
    else:
        index=startPointer
        while linkedList[index]!= itemDelete and index != nullPointer:
            oldIndex=index
            index=linkedListPointer[index]#keep pointing until found
        if index ==nullPointer:
            print("item",itemDelete,"not found do")
        else:
            linkedList[index]=None
            temPointer=linkedListPointer[index]
            linkedListPointer[index]=heapStartPointer
            heapStartPointer=index
            linkedListPointer[oldIndex]=temPointer

insert(3)
print(linkedList)
delete(19)
print(linkedList)
delete(13)

EXERCISE 3 NOV 2022

susilawati — 2022-11-03 01:09:17 UTC

Nur Diyana Amani

2022-11-03 01:09:38 UTC

linkedList = [27,19,36,42,16,None,None,None,None,None]
linkedListPointer = [-1,0,1,2,3,6,7,8,9,10,11,-1]
nullPointer = -1
startPointer = 4
heapStartPointer = 5

#SEARCHING
def findItem() :
    global linkedList,linkedListPointer,nullPointer,startPointer,heapStartPointer,itemPointer
    itemSearch = int(input("Enter a number : "))
    itemPointer = startPointer
    found = False
    while itemPointer!= nullPointer and not found:
        if linkedList[itemPointer] == itemSearch :
            found = True
        else :
            itemPointer = linkedListPointer[itemPointer]
    return itemPointerdef insertC() :
    global linkedList,linkedListPointer,nullPointer,startPointer,heapStartPointer,itemPointer,tempPointer,itemAdd
    itemAdd = int(input("Add a number : "))

    if heapStartPointer == nullPointer :
        print("Linked list is full")
    else :
        tempPointer = startPointer
        startPointer = heapStartPointer
        heapStartPointer = linkedListPointer[heapStartPointer]
        linkedList[startPointer] = itemAdd
        linkedListPointer[startPointer] = tempPointerdef deleteItem() :
    global linkedList,linkedListPointer,nullPointer,startPointer,heapStartPointer,itemPointer,tempPointer, itemDelete, index, oldIndex
    itemDelete = int(input("Enter a number to delete : "))

    if startPointer==nullPointer :
        print("Linked list is empty.")
    else :
        index = startPointer
        while linkedList[index]!=itemDelete and index!=nullPointer :
            oldIndex = index
            index = linkedListPointer[index]
        if index == nullPointer :
            print("Item is not found.")
        else :
            tempPointer = linkedListPointer[index]
            linkedListPointer[index] = heapStartPointer
            heapStartPointer = index
            linkedListPointer[oldIndex] = tempPointer

EXERCISE 3 NOV 2022

susilawati — 2022-11-03 01:15:31 UTC

Muhammad Nur Hamzah Bin Norazam ALE21086

2022-11-03 01:20:03 UTC

Rania punyaaa

2022-11-03 01:21:46 UTC

MLL=[27,19,36,42,16,None,None,None,None,None,None,None]
MLLP=[-1,0,1,2,3,6,7,8,9,10,11,-1]

startPointer = 4
itemPointer = startPointer
nullPointer = -1
heapPointer = 5

item=int(input("Searching for?"))
def find(itemSearch):
    global nullPointer
    global itemPointer
    global startPointer
    found = False

    while itemPointer != nullPointer and not found:
        if MLL[itemPointer] == item:
            found = True
        else:
            itemPointer = MLLP[itemPointer]
    return itemPointer

#Inserting item
def add(itemAdd):
    global heapPointer
    global tempPointer
    global startPointer

    #itemAdd = int(input("What to add?"))
    if heapPointer == nullPointer:
        print("Linked list is full")
    else:
        tempPointer = startPointer
        startPointer = heapPointer
        heapPointer = MLLP[heapPointer]
        MLL[startPointer] = itemAdd
        MLLP[startPointer] = tempPointer
    print(MLL)
    print(MLLP)
    return heapPointer

result=find(item)
if result!=-1:
    print(item," found")
else:print(item," not found")
add(itemAdd=7)

def Delete(itemDelete):
    global heapPointer
    if startPointer==nullPointer:
        print("List is empty")
    else:
        index=startPointer
        while MLL[index]!=itemDelete and index!=nullPointer:
            oldIndex=index
            index=MLLP[index]
        if index==nullPointer:
            print("Item to delete is not found")
        else:
            tempPointer=MLLP[index]
            MLLP[index]=heapPointer
            heapPointer=index
            MLLP[oldIndex]=tempPointer
    print("Deleting item, new list;")
    print(MLL)
    print(MLLP)

Delete(itemDelete=16)

Julia

2022-11-03 01:29:40 UTC

myLinkedList=[27,19,36,42,16,None,None,None,None,None,None,None]
myLinkedListPointer=[-1,0,1,2,3,6,7,8,9,10,11,-1]
nullPointer=-1
startPointer=4
heapStartPointer=5 #first empty cell

def find(itemSearch):
    itemPointer=startPointer
    found=False
    while (itemPointer!=nullPointer) and not found:
        if myLinkedList[itemPointer]==itemSearch:
            found=True
        else:
            itemPointer=myLinkedListPointer[itemPointer]
    return itemPointer
itemSearch=int(input("Enter search value"))
result=find(itemSearch)
if result != -1:
    print("item found")
    print(result)
else:
    print("not found")

def insert(addItem):
    global startPointer,heapStartPointer
    nullPointer=-1
    if heapStartPointer==-1:
        print("Linked list is full")
    else:
        tempPointer=startPointer
        startPointer=heapStartPointer
        heapStartPointer=myLinkedListPointer[heapStartPointer]
        myLinkedList[startPointer]=addItem
        myLinkedListPointer[startPointer]=tempPointer

def delete(deleteItem):
    global startPointer,heapStartPointer,nullPointer
    if startPointer==nullPointer:
        print("Linked list is empty")
    else:
        index=startPointer
        while (myLinkedList[index]!=deleteItem) and (index!=nullPointer):
            oldindex=index
            index=myLinkedListPointer[index]
        if index==nullPointer:
            print("Item not found")
        else:
            tempPointer=myLinkedListPointer[index]
            myLinkedListPointer[index]=heapStartPointer
            heapStartPointer=index
            myLinkedListPointer[oldindex]=tempPointer

print("delete 36")
delete(36)
print(myLinkedListPointer)

Rania punyaaa

2022-11-03 01:31:14 UTC

queueLength=0
queueful=5
rearPointer=-1
frontPointer=0

q=[None for i in range(5)]
def enqueue(num):
    global queueLength,queueful,rearPointer
    if queueLength==queueful:
        print("Queue is full")
    else:
        #item=input("Enter item: ")
        #q.append(item)
        if rearPointer

Muhamad Adlee Hakimi - Exercise 3 Nov

AdleeHakimi — 2022-11-03 01:56:31 UTC

Muhammad Nur Hamzah Bin Norazam ALE21086

2022-11-07 05:26:38 UTC

ACTIVITY 11 NOV 2022

susilawati — 2022-11-11 00:42:13 UTC

susilawati — 2022-11-15 03:43:08 UTC

2022-11-15 05:07:23 UTC

susilawati — 2023-01-02 15:37:34 UTC

susilawati — 2023-01-06 02:41:43 UTC

susilawati — 2023-01-06 02:47:36 UTC

HARUN AZHAR Fibonacci & Factorial

2023-01-06 02:48:58 UTC

def fib(n):
    if n == 1:
        return 0
    if n == 2:
        return 1
    return fib(n-1)+fib(n-2)

print(fib(4))

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

print(factorial(5))

Muhamad Adlee Hakimi

2023-01-06 03:44:06 UTC

Def Fibonacci(position) :

If position <= 1:

result = 0

return result

elif position == 2:

result = 1

return result

else:

result = Fibonacci(position-1) + Fibonacci(position-2)

return result

Def Factorial(n):
if n == 0:
result = 1
return result
else:
result = n * Factorial(n-1)
return result

Muhammad Nur Hamzah Bin Norazam Al21.6

mnhamzah — 2023-01-07 05:21:39 UTC

def fact(number):
    if number==0:
        answer=1
    else:
        answer = number * fact(number-1)
    return answer
print(fact(3))
def fib(noterms):
    if noterms== 1:
        answer=0
    elif noterms==2:
        answer = 1
    else:
        answer=fib(noterms-1)+ fib(noterms-2)
    return answer
print(fib(6))

LINK EXERCISES

susilawati — 2023-01-09 02:06:19 UTC

https://drive.google.com/drive/folders/1LtkMsoHdY4Ro0xCSWdfXBcYrBKMCQONx?usp=share_link - Exercise Unit 19

susilawati — 2023-01-09 02:17:12 UTC

susilawati — 2023-01-09 02:18:06 UTC

susilawati — 2023-01-10 01:35:25 UTC

susilawati — 2023-01-10 01:36:27 UTC

susilawati — 2023-01-10 01:39:27 UTC

susilawati — 2023-01-10 01:42:11 UTC

susilawati — 2023-01-10 01:43:02 UTC

susilawati — 2023-01-11 16:46:29 UTC

susilawati — 2023-01-11 16:46:53 UTC

susilawati — 2023-01-12 01:22:11 UTC

susilawati — 2023-01-12 01:23:28 UTC

susilawati — 2023-01-12 01:25:07 UTC

susilawati — 2023-01-12 01:30:58 UTC

susilawati — 2023-01-12 01:33:27 UTC

.

2023-01-13 03:29:47 UTC

shape = input("Enter shape : ")
if shape == "square" or shape == "rectangle" or shape == "paralellogram":
    base = int(input("Enter base : "))
    height = int(input("Enter height : "))
    area = base * height
elif shape == "triangle":
    base = int(input("Enter base : "))
    height = int(input("Enter height : "))
    area = base * height * 0.5
elif shape == "circle":
    radius = int(input("Enter radius : "))
    area = 3.142 * radius ** 2
else:
    print("Error")
print(f"Area of {shape} is {area}")

.

2023-01-13 03:30:04 UTC

def area_four():
    base = int(input("Enter base"))
    height = int(input("Enter height"))
    area = base * height
    return area

def area_three():
    base = int(input("Enter base"))
    height = int(input("Enter height"))
    area = 0.5 * base * height
    return area

def area_circle():
    radius = int(input("Enter radius :"))
    area = 3.142 * radius ** 2
    return area

shape = input("Enter shape : ")
if shape == "square" or shape == "rectangle" or shape == "paralellogram":
    area = area_four()
elif shape == "triangle":
    area = area_three()
elif shape == "circle":
    area = area_circle()
else:
    print("Error")
print(f"Area of {shape} is {area}")

Adlee - Exercise 3 OOP

AdleeHakimi — 2023-01-19 01:22:27 UTC

import datetime

class Student():

    def __init__(self, name, dateOfBirth, examMark):
        self.name = name
        self.dateOfBirth = dateOfBirth
        self.examMark = examMark

    def display_exam_mark(self):
        print(f"Exam Mark : {self.examMark}")

class FullTimeStudent(Student):

    def __init__(self, name, dateOfBirth, examMark):
        Student.__init__(self, name, dateOfBirth, examMark)

class PartTimeStudent(Student):

    def __init__(self, name, dateOfBirth, examMark):
        Student.__init__(self, name, dateOfBirth, examMark)

myFullTimeStudent = FullTimeStudent("Harun", datetime.datetime(2003,10,4), 100)
myPartTimeStudent = PartTimeStudent("Musa", datetime.datetime(2003,4,1), 10)

myFullTimeStudent.display_exam_mark()
myPartTimeStudent.display_exam_mark()

NUR DIYANA AMANI KHAIRUDDIN - EXERCISE 3 OOP

2023-01-19 01:27:03 UTC

#19/01/2023

#EXERCISE 3

from datetime import date
date1 = date(2005,6,19)
date2 = date(2003,11,23)

class Student :

    def __init__(self,name,date,mark):
        self.__name = name
        self.__dateOfBirth = date
        self.__examMark = mark
        self.__fullTS = True

    def displayExamMark(self):
        print("Student Mark :",self.__examMark)

class fullTimeStudent(Student):

    def __init__(self,name,date,mark):
        Student.__init__(self,name,date,mark)
        self.__fullTS = True

class partTimeStudent(Student):

    def __init__(self,name,date,mark):
        Student.__init__(self,name,date,mark)
        self.__fullTS = False

Student1 = Student("Name1",date1,90)
Student1.displayExamMark()

print("\nNext :")
Student2 = Student("Name2",date2,98)
Student2.displayExamMark()

Julia exercise 3

2023-01-19 01:59:46 UTC

#Exercise3
from datetime import date
dateOfBirth=date(2003,11,6)
class Student:
    def __init__(self,name,dateOfBirth,examMark):
        self.__name=name
        self.__dateOfBirth=dateOfBirth
        self.__examMark=examMark
        self.__FullTime=True
    def DisplayMarks(self):
        print("Marks:",self.__examMark)
class FullTime(Student):
    def __init__(self,name,dateOfBirth,examMark):
        Student.__init__(self,name,dateOfBirth,examMark)
        self.__FullTime=True

class PartTime(Student):
    def __init__(self,name,dateOfBirth,examMark):
        Student.__init__(self,name,dateOfBirth,examMark)
        self.__FullTime=False

stud=Student("julia",dateOfBirth,80)
stud.DisplayMarks()

Rania's Exercise 3

2023-01-19 02:00:51 UTC

import datetime
class student:
    def __init__(self,name,dateOfBirth,examMark):
        self.__name=name
        self.__dateOfBirth=dateOfBirth
        self.__examMark=examMark
        self.__fullTime = True
    def displayExamMark(self):
        print("Student name: "+self.__name)
        print("Exam mark: ",self.__examMark)

class fullTime(student):
    def __init__(self, name, dateOfBirth, examMark):
        student.__init__(self,name,dateOfBirth,examMark)
        self.__fullTime=True

class partTime(student):
    def __init__(self, name, dateOfBirth, examMark):
        student.__init__(self,name ,dateOfBirth,examMark)
        self.__fullTime=False

fullTimer=fullTime("Julia",datetime.date(1998,2,17),98)
partTimer=partTime("Julius",datetime.date(1999,8,21),78)
fullTimer.displayExamMark()
partTimer.displayExamMark()

Hamzah OOP

mnhamzah — 2023-01-19 02:02:01 UTC

class student:
    def __init__(self,name, DateofBirth, examMark):
        self.__name = name
        self.__DateofBirth = DateofBirth
        self.__examMark = examMark
        self.fullTimeStudent = True
    def displayExamMark(self):
        print("Exam Marks:" , self.__examMark)
class fullTimeStudent(student):
    def __init__(self,name,DateofBirth):
        student.__init__(self, name, DateofBirth)
        self.fullTimeStudent = True
class partTimeStudent(student):
    def __init__(self,name,DateofBirth):
        student.__init__(self, name, DateofBirth)
        self.fullTimeStudent = False

Aiman - OOP

2023-01-19 02:02:22 UTC

import datetime
class student:
    def __init__(self,name,dateOfBirth,examMark):
        self.__name = name
        self.__dateOfBirth = dateOfBirth
        self.__examMark = examMark
    def showDetails(self):
        print('Student name is ' + self.__name)
        print('Students birthdate is ' + str(self.__dateOfBirth))
        print('Student exam mark is ' + str(self.__examMark))
    def displayExamMark(self):
        print('The student with name,' + self.__name + ' got a '+ str(self.__examMark) + ' mark in exam')

class partTimeStudent:
    def __init__(self,n,d,m):
        student.__init__(self,n,d,m)
        self.__fulltime = False
class fullTimeStudent:
    def __init__(self,n,d,m):
        student.__init__(self,n,d, m)
        self.__fulltime = True
myStudent = student('Aiman',datetime.date(2003,7,17),69)
myStudent.displayExamMark()

Alnajmi OOP

mnhamzah — 2023-01-19 02:02:50 UTC

import datetime

class student:
def __init__(self,name,dateOfBirth,examMark):
self.__name=name
dateOfBirth=dateOfBirth
self.__dateOfBirth=dateOfBirth
self.__examMark=examMark

def displayExamMark(self):
print('Exam Mark',self.__examMark)
print(self.__dateOfBirth)

class PartTime(student):
def __init__(self,name,dateOfBirth,examMark):
student.__init__(self,name, dateOfBirth, examMark)
fullTime=Falseclass FullTime(student):
def __init__(self,name,dateOfBirth,examMark):
student.__init__(name,dateOfBirth,examMark)
fullTime=True

HARUN BIN AZHAR - Exercise 3 OOP

2023-01-19 02:02:56 UTC

#Exercise 3
class student:
    def __init__(self, name, dob, mark):
        self.__name = name
        self.__dateOfBirth = dob
        self.__examMark = mark

    def displayExamMark(self):
        print(self.__examMark)

class fullTimeStudent(student):
    def __init__(self, name, dob, mark):
        student.__init__(self, name, dob, mark)

class partTimeStudent(student):
    def __init__(self, name, dob, mark):
        student.__init__(self, name, dob, mark)

hamzah = fullTimeStudent("hamzah", "21/2/2003", 100)
hamzah.displayExamMark()

mandud = partTimeStudent("aiman", "1/1/2003", 99)
mandud.displayExamMark()

susilawati — 2023-01-30 02:17:10 UTC

susilawati — 2023-01-30 02:19:48 UTC

susilawati — 2023-01-30 02:23:29 UTC

susilawati — 2023-01-31 00:29:46 UTC

susilawati — 2023-01-31 00:30:03 UTC

susilawati — 2023-02-02 01:17:36 UTC

susilawati — 2023-02-03 02:28:14 UTC

Post-Order Traversal

2023-02-07 01:55:39 UTC

https://docs.google.com/presentation/d/1xKXM124G8EyXvtAt13TbDeMfHHChVsIoBLYefPItmNg/edit?usp=sharing

susilawati — 2023-02-09 00:13:47 UTC

Pre-Order Traversal

AdleeHakimi — 2023-02-10 02:38:28 UTC

In Order Traversal

mnhamzah — 2023-02-10 02:40:06 UTC

susilawati — 2023-02-13 02:37:06 UTC

susilawati — 2023-02-13 21:58:15 UTC

susilawati — 2023-02-13 21:58:29 UTC

susilawati — 2023-02-13 21:58:46 UTC

susilawati — 2023-02-13 21:58:59 UTC

susilawati — 2023-02-13 21:59:33 UTC

susilawati — 2023-02-18 15:01:48 UTC

susilawati — 2023-02-18 15:06:40 UTC

Nur Diyana Amani Khairuddin

2023-02-20 03:58:39 UTC

#20/2/2023

class TStudentRecord:
    def __init__(self):
        self.name = ""
        self.address = ""
        self.className = ""

Student = TStudentRecord()
Student.name = "Orkid Osman"
Student.address = "My House"
Student.className = "2 Seroja"
newStudent = Student.name+"\n"+Student.address+"\n"+Student.className

studentFile = open("Student.txt","w")
studentFile.write(newStudent)
studentFile.close()

def readFile():
    studentFile=open("Student.txt","r")
    studentFile.read()
    studentFile.close()

def appendFile():
    addStudent = TStudentRecord()
    addStudent.name = "Diyana"
    addStudent.address = "CS Lab"
    addStudent.className = "21.4"

    newerStudent = "\n"+addStudent.name+"\n"+addStudent.address+"\n"+addStudent.className

    studentFile = open("Student.txt","a")
    studentFile.write(newerStudent)
    studentFile.close()

nStudent = TStudentRecord
nStudent.name = input("Name : ")
nStudent.address = input("Address : ")
nStudent.className = input("Class name : ")
sDetails = nStudent.name+"\n"+nStudent.address+"\n"+nStudent.className

newFile = open("NewStudent.txt","w")
newFile.write(sDetails)
newFile.close()

newFile = open("NewStudent.txt","r")
newFile.read()
newFile.close()

Muhamad Adlee Hakimi Bin Mohd Nazlee

AdleeHakimi — 2023-02-20 03:59:46 UTC

class TstudentRecord:
    def __init__(self, name, address, className):
        self.name = name
        self.address = address
        self.className = className
        with open("StudentRecord", "w") as myFile:
            myFile.write(str(name))
            myFile.write("\n" + str(address))
            myFile.write("\n" + str(className))

    def appendRecord(self, name, address, className):
        with open("StudentRecord", "a") as myFile:
            myFile.write("\n" + str(name))
            myFile.write("\n" + str(address))
            myFile.write("\n" + str(className))

    def readFile(self):
        with open("StudentRecord", "r") as recordFile:
            for line in recordFile:
                print(line.rstrip())

myRecord = TstudentRecord("Adlee", "sbh", "AL21.4")
myRecord.appendRecord("Hamzah", "phg", "AL21.6")
myRecord.appendRecord("Harun", "pj", "Al21.6")
myRecord.readFile()

Rania's

2023-02-20 04:17:18 UTC

class TstudentRecord:
    def __init__(self,n,a,c):
        self.name=n
        self.address=a
        self.classname=c


n=input("Enter name: ")
a=input("Enter address: ")
c=input("Enter class name: ")
student=TstudentRecord(n,a,c)
newStudent=student.name+"\n"+student.address+"\n"+student.classname+"\n"

def append():
    StudentFile = open("Student.txt", "a")
    StudentFile.write(newStudent)
    StudentFile.close()

def read():
    StudentFile = open("Student.txt", "r")
    print(StudentFile.read(100))
    StudentFile.close()

append()
read()

MUHAMMAD NUR HAMZAH BIN NORAZAM A21.6

mnhamzah — 2023-02-20 04:18:52 UTC

class studentrecord:
    def __init__(self,name,add,cname):
        self.name=name
        self.add = add
        self.classname = cname
    def str(self):
        return self.name+"_"+ self.add+"_"+self.classname
def apennd(name, add, cname):
    Fail=open('jah','a')
    jet=studentrecord(name,add,cname)
    Fail.write('\n'+jet.str())
    Fail.close()
def read():
    filehandle = open('jah','r')
    jet = filehandle.read()
    print(jet)
    filehandle.close()
name = input("student name")
add = input("student address")
cname = input("student class")
apennd(name,add,cname)
read()

Aiman Daud

2023-02-20 04:21:11 UTC

class TstudentRecord:
    def __init__(self,name,add,classname):
        self.name = name
        self.address = add
        self.classname = classname

    def text(self):
        return (self.name +" "+ self.address +" " + self.classname)


def append(n,a,cn):
    FileHandle = open('StudentRecord','a')
    obj = TstudentRecord(n,a,cn)
    FileHandle.write('\n' + obj.text())
    FileHandle.close()

def read():
    FileHandle = open('StudentRecord','r')
    RecordToRead = FileHandle.readline()
    print(RecordToRead)
    FileHandle.close()

append('Orkid Osman','My House','2 Seroja')

print('Enter your record details')
n = input('Name : ')
a = input('Address : ')
cn = input('Class Name : ')
append(n,a,cn)
read()

Harun bin Azhar

2023-02-20 04:21:31 UTC

class TstudentRecord:
    def __init__(self, n, a, cn):
        self.__name = n
        self.__address = a
        self.__className = cn
    def getValues(self):
        return (self.__name + "\n"+ self.__address+ "\n"+ self.__className + "\n")

def appendRecord(n, a, cn):
    try:
        file = open("TstudentRecord.txt", "a")
        record = TstudentRecord(n, a, cn)
        file.write(record.getValues())
        file.close()

    except IOError:
        print("File not found")

def readRecords():
    try:
        file = open("TstudentRecord.txt", "r")
        line = file.readline().strip()
        while line != "":
            name = line
            address = file.readline().strip()
            className = file.readline().strip()
            print(name, "", address, "", className)
            line = file.readline().strip()
        file.close()
    except:
        print("File not found")

#existing records
appendRecord("Aiman","Rumah","6 Bestari")
appendRecord("Jah", "Afrika", "5 Bernas")
appendRecord("Lee", "Marikh", "1 Bijak")

#input from user new record
name = input("Enter name: ")
address = input("Enter address: ")
className = input("Enter class name: ")
appendRecord(name, address, className)

readRecords()

Najmi

2023-02-20 04:25:34 UTC

class Tstudentrecord:
    def __init__(self,name,address,className):
        self.name=name
        self.address=address
        self.className=className
    def text(self):
        return (self.name +self.address+self.className)

def append(name,address,className):
    fileHandle=open("studentFile",'a')
    data = Tstudentrecord(name,address,className)
    fileHandle.write("\n" + data.text())
    fileHandle.close()
def read():
    fileHandle=open("studentFile",'r')
    for line in fileHandle:
        print(line.strip())
    LineOfText=fileHandle.readlines()
    print(LineOfText)
    fileHandle.close()


print('enter student details')
name=input('name:')
adress=input('adress:')
className=input('class name:')

append(name,adress,className)
read()

Julia

2023-02-20 04:28:43 UTC

class TstudentRecord:
    def __init__(self):
        self.name=""
        self.dob=""
        self.age=""

student=TstudentRecord()
student.name="Julia"
student.dob="7/6"
student.age="20"

newRecord= student.name+"\n"+student.dob+"\n"+student.age
studentFile=open("student.txt","w")
studentFile.write(newRecord)
studentFile.close()


def readFile():
    studentFile=open("student.txt","r")
    studentFile.read()
    studentFile.close()

addstudent=TstudentRecord()
addstudent.name="diyana"
addstudent.dob="6/6"
addstudent.age="20"

addedRecord= addstudent.name+"\n"+addstudent.dob+"\n"+addstudent.age

def appendFile():
    addstudent = TstudentRecord()
    addstudent.name = "diyana"
    addstudent.dob = "6/6"
    addstudent.age = "20"

    addedRecord = addstudent.name + "\n" + addstudent.dob + "\n" + addstudent.age

    studentFile=open("student.txt","r")
    studentFile.write(addedRecord)
    studentFile.close()

newStudent=TstudentRecord
newStudent.name=input("Name:")
newStudent.dob=input("DOB:")
newStudent.age=input("age:")
nRecord = newstudent.name + "\n" + newStudent.dob + "\n" + newStudent.age

newFile=open("NewStudent.txt","w")
newFile.write(nRecord)
newFile.close()

newFile=open("NewStudent.txt","r")
newFile.read()
newFile.close()

susilawati — 2023-02-21 00:40:41 UTC

Rania's

2023-02-21 01:40:16 UTC

import pickle

class TstudentRecord:
    def __init__(self):
        self.name = ""
        self.addie = ""
        self.id=""
        self.course = ""

def write():
    myFile = open("student.dat", "w+b")
    myStudent = TstudentRecord()
    myStudent.name = str(input("name? "))
    myStudent.addie = str(input("address? "))
    myStudent.course = str(input("course? "))
    myStudent.id = int(input("id? "))    newRecord=myStudent.name+"\n"+myStudent.addie+"\n"+myStudent.course
    pickle.dump(myStudent, myFile)
    myFile.close()

def read():
        myFile=open("student.dat","rb")
        array=[]
        while True:
            try:
                newData=pickle.load(myFile)
            except EOFError:
                break
            array.append(newData)
        for i in array:
            print(i)
        myFile.close()

def append():
    myFile=open("student.dat","ab")
    myStudent=TstudentRecord()
    myStudent.name = str(input("name? "))
    myStudent.addie = str(input("address? "))
    myStudent.course = str(input("course? "))    newRecord=myStudent.name+"\n"+myStudent.addie+"\n"+myStudent.course
    pickle.dump(newRecord,myFile)
    myFile.close()

write()
read()
append()
read()

Nur Diyana Amani Khairuddin - BINARY

2023-02-21 01:42:40 UTC

#21/2/2023

import pickle

class StudentRecord :

    def __init__(self):
        self.name = ""
        self.className = ""

newStudent = StudentRecord()

def writeBFile():

    newStudent.name = input("Name : ")
    newStudent.className = input("Class : ")
    SDetails = newStudent.name+"\n"+newStudent.className

    newBFile = open("Student.dat","wb")
    pickle.dump(SDetails,newBFile)
    newBFile.close()

def appendBFile():

    newStudent.name = input("Name : ")
    newStudent.className = input("Class : ")
    SDetails = newStudent.name+"\n"+newStudent.className

    newBFile = open("Student.dat","ab")
    pickle.dump(SDetails,newBFile)
    newBFile.close()

def readBFile():

    newBFile = open("Student.dat","rb")
    array = [] #new array to add data in

    while True :
        try :
            newData = pickle.load(newBFile) #assigns data line-by-line
        except EOFError :
            break
        array.append(newData) #add data into array
    for i in array:
        print(i) #print data in array

    newBFile.close()


readBFile()

Nur Diyana Amani binti Khairuddin - RANDOM/SEQUENTIAL

2023-02-21 01:51:31 UTC

#21/2/2023

class carRecord :
    def __init__(self):
        self.brand = ""
        self.plateNum = ""

newCar = carRecord()

def newFile() :

    newCar.brand = input("Brand : ")
    newCar.plateNum = int(input("Plate number : "))
    carDetails = newCar.brand+" "+str(newCar.plateNum)

    carFile = open("car.txt","w")
    address = hash(newCar.plateNum)
    carFile.seek(address)
    carFile.write(carDetails)
    carFile.close()

def findCar():

    carFile = open("car.txt","r")
    newCar.plateNum = int(input("Enter plate number of car to find : "))

    try:
        address = hash(newCar.plateNum)
        carFile.seek(address)
        carDetails = carFile.readline()
        print(carDetails)

    except:
        print("ERROR : CAR NOT REGISTERED")

    carFile.close()

newFile()
findCar()

HARUN BIN AZHAR - BinaryWrite

2023-02-21 01:53:05 UTC

import pickle
class student:
    def __init__(self, name, classes, grades):
        self.__name = name
        self.__classes = classes
        self.__grades = grades

    def getInfo(self):
        print(self.__name)
        for i in range(len(self.__classes)):
            print(self.__classes[i], self.__grades[i])

#Adding data to file
ali = student("ALI", ["CS","ENG"], [99,41])
abu = student("ABU", ["MATH", "PHY"], [101, 53])
filename = "grades.txt"
try:
    file = open(filename, "wb")
    pickle.dump(ali, file)
    pickle.dump(abu, file)
    file.close()

except IOError:
    print("File not found")

#Read all data from file
try:
    file = open(filename, "rb")
    #while not EOF
    while True:
        try:
            person = pickle.load(file)
            person.getInfo()
        except EOFError:
            break
    file.close()

except IOError:
    print("File not found")

Najmi

2023-02-21 01:59:24 UTC

import datetime
import pickle
class student:
    def __init__(self):
        self.name=''
        self.registerNumber=0
        self.dateOfBirth=datetime.datetime.now()
        self.fullTime=True

studentRecord=student()
def newRecord():
    studentRecord=student()
    studentFile=open('file.txt','a+b')
    print("enter student details")
    studentRecord.name=input('enter name')
    studentRecord.registerNumber=int(input('enter register number'))
    year=int(input('enter year of birth'))
    month=int(input('month of birth'))
    day=int(input('enter day of birth'))
    studentRecord.dateOfBirth=datetime.datetime(year,month,day)
    studentRecord.fullTime=bool(input('enter True for full time or False'))

    pickle.dump(studentRecord,studentFile)
    studentFile.close()
def read():
    studentFile=open('file.txt','rb')
    array=[]
    while True:
        try:
            data=pickle.load(studentFile)
        except EOFError:
            break
        array.append(data.dateOfBirth)
    for i in array:
        print(i)
    studentFile.close()

jULIA

2023-02-21 02:00:39 UTC

class TstudentRecord:
    def __init__(self):
        self.name=""
        self.ID=0

def addData():
    stud=TstudentRecord()
    stud.name=input("Name:")
    stud.ID=int(input("ID:"))
    mystud=(stud.name+" "+str(stud.ID))

    myFile=open("stud.txt","w")
    adress=hash(stud.ID)
    myFile.seek(adress)
    myFile.write(mystud)
    myFile.close()

def findData():
    stud=TstudentRecord()
    myFile=open("stud.txt","r")
    stud.ID=(int(input("Enter student id:"))
    try:
        address = hash(stud.ID)
        myFile.seek(address)
        studDetails=myFile.readline()
        print(studDetails)

    except:
        print("Student ID entered not found")

    myFile.close()

findData()

susilawati — 2023-02-22 22:52:50 UTC

susilawati — 2023-02-22 22:53:20 UTC

MUHAMMAD NUR HAMZAH BIN NORAZAM AL21.6

mnhamzah — 2023-02-23 00:05:19 UTC

import datetime
import pickle
class student:
    def __init__(self):
        self.name = ""
        self.registernumber = 0
        self.dateofbirth = datetime.date
        self.fulltime = True
studentrecord = student()
def writeserial():
    studentfile = open('jah','w+b')
    print("stud details")
    studentrecord.name = input()
    studentrecord.registernumber = input()
    year = int(input())
    month = int(input())
    day = int(input())
    studentrecord.dateofbirth = datetime.date(year,month,day)
    studentrecord.fulltime = bool(input())
    pickle.dump(studentrecord,studentfile)
    studentfile.close()
def readserial():
    studentfile = open('jah','rb')
    try:
        studentrecord = pickle.load(studentfile)
        print(studentrecord.name, studentrecord.registernumber,studentrecord.dateofbirth,studentrecord.fulltime)
    except:
        print("error")
        studentfile.close()
def writerandom():
    studentfile = open("jah","wb+")
    studentrecord.name = input("Full name")
    studentrecord.registernumber = int(input("Registration Number"))
    year = int(input("Year born"))
    month = int(input("Month born"))
    day = int(input("Day born"))
    studentrecord.dateofbirth = datetime.date(year,month,day)
    address = hash(studentrecord.registernumber)
    studentfile.seek(address)
    pickle.dump(studentrecord,studentfile)
    studentfile.close()
def readrandom():
    global studentrecord
    studentfile = open("jah","rb")
    studentrecord.registernumber = int(input("Insert Registration Number"))
    try:
        address = hash(studentrecord.registernumber)
        studentfile.seek(address)
        studentrecord = pickle.load(studentfile)
        print(studentrecord.name,studentrecord.dateofbirth)
    except:
        print("error")
        studentfile.close()

susilawati — 2023-02-23 00:06:55 UTC

Aiman

2023-02-23 00:14:19 UTC

import pickle

class TcarRecord:
    def __init__(self,n,id,ori):
        self.name = n
        self.registrationNumber = id
        self.origin = ori
    def convertToString(self):
        return str(self.name+' '+self.registrationNumber+' '+self.origin)

#serialization

def write():
    thisFile = open('CarRecord','wb')
    print ('Please enter your car detail')
    n = str(input('Car name : '))
    id = str(input('Car registration number : '))
    ori = str(input('Car origin : '))
    thisCar = TcarRecord(n,id,ori)
    pickle.dump(thisCar.convertToString(),thisFile)
    thisFile.close()

def read():
    thisFile = open('CarRecord','rb')
    array = []
    while True:
        try:
            newData = pickle.load(thisFile)
        except EOFError:
            break
        array.append(newData)
    for i in array:
        print(i)
    thisFile.close()

def append():
    thisFile = open('CarRecord','ab')
    print('Please enter your car detail')
    n = str(input('Car name : '))
    id = str(input('Car registration number : '))
    ori = str(input('Car origin : '))
    thisCar = TcarRecord(n, id, ori)
    pickle.dump(thisCar.convertToString(),thisFile)
    thisFile.close()

Aiman Random/Sequential

aimandaud — 2023-02-23 00:22:47 UTC

import pickle

class TcarRecord:
    def __init__(self,n,id,ori):
        self.name = n     
        self.registrationNumber = id  #DECLARE id : INT
        self.origin = ori
    def convertToString(self):
        return str(self.name+' '+self.registrationNumber+' '+self.origin)

def addData():
    thisFile = open('CarRecord', 'wb+')
    print('Please enter your car detail')
    n = str(input('Car name : '))
    id = int(input('Car registration number : '))
    ori = str(input('Car origin : '))
    thisCar = TcarRecord(n, id, ori)
    address = hash(thisCar.registrationNumber)
    thisFile.seek(address)
    pickle.dump(thisCar,thisFile)
    thisFile.close()

def retrieve():
    thisFile = open('CarRecord','rb')
    thisCar = TcarRecord('',int(input('Enter registration number to search : ')),'')
    try:
        address = hash (thisCar.registrationNumber)
        thisFile.seek(address)
        thisCar = pickle.load(thisFile)
        print('\n',thisCar.name ,'\n',thisCar.origin )
    except:
        print('ERROR')
    thisFile.close()

retrieve()

HARUN BIN AZHAR - Random

2023-02-23 00:48:48 UTC

class car:
    def __init__(self, ID, manuDate, owner):
        self.__ID = ID
        self.__manuDate = manuDate
        self.__owner = owner

    def printInfo(self):
        print(self.__ID)
        print(self.__manuDate)
        print(self.__owner)

    def getID(self):
        return self.__ID

    def getDetails(self):
        return str(self.__ID) + " " + self.__manuDate + " " + self.__owner

bugatti = car(12345, "1/1/1111", "Muhammad Nur Hamzah bin Norazam")
lambo = car(65748, "2/2/2222", "Aiman Mandud bin Daud")
fileName = "cars.txt"

#writing data to file

file = open(fileName, 'w')

address = hash(bugatti.getID())
file.seek(address)
file.write(bugatti.getDetails())

address = hash(lambo.getID())
file.seek(address)
file.write(lambo.getDetails())
file.close()

#Reading data to file
try:
    file = open(fileName, 'r')
    searchID = int(input("Enter ID of car: "))
    try:
        address = hash(searchID)
        file.seek(address)
        details = file.read()
        print(details)
    except:
        print("ERROR: ID does not exist")
    file.close()
except IOError:
    print("File not found")

Rania's Random/Sequential File

2023-02-23 00:56:38 UTC

class TBookRecord:
    def __init__(self):
        self.title=""
        self.author=""
        self.ISBN=""

newBook=TBookRecord

def newFile():
    newBook.title= input("Book title:")
    newBook.author= input("Book author:")
    newBook.ISBN= int(input("ISBN: "))
    BookDeets=newBook.title+" "+newBook.author+" "+str(newBook.ISBN)

    bookFile= open("book.txt","w")
    address=hash(newBook.ISBN)
    bookFile.seek(address)
    #pickle.dump(BookDeets,bookFile) <-- for binary
    bookFile.write(BookDeets)
    bookFile.close()

def retrieveBook():
    bookFile=open("book.txt","r")
    newBook.ISBN=int(input("Books ISBN? "))
    try:
        address=hash(newBook.ISBN)
        bookFile.seek(address)
        BookDeets=bookFile.readline(40)
        print(BookDeets)
    except:
        print("Book not found")
    bookFile.close()

newFile()
retrieveBook()

MOHAMAD NURUL AIMAN BIN DAUD AL21.4

aimandaud — 2023-02-23 01:09:14 UTC

MUHAMMAD NUR HAMZAH BIN NORAZAM AL21.6

mnhamzah — 2023-02-23 01:14:06 UTC

HARUN BIN AZHAR

2023-02-23 01:21:27 UTC

Nur Diyana Amani Khairuddin

2023-02-23 01:28:42 UTC

Muhamad Adlee Hakimi (aka Lee)

2023-02-23 01:40:19 UTC

Julia

2023-02-23 01:49:41 UTC

Rania's

2023-02-23 01:57:09 UTC

MUHAMMAD AL NAJMI

2023-02-23 02:04:54 UTC

susilawati — 2023-02-24 02:19:46 UTC

susilawati — 2023-02-24 02:20:30 UTC

Hamzah - Marked

2023-02-24 02:51:28 UTC

(Marked) Nur Diyana Amani

AdleeHakimi — 2023-02-24 03:01:55 UTC

Julia - Marked (23/23)

aimandaud — 2023-02-24 03:04:22 UTC

Harun bin AZHAR

2023-02-24 03:07:13 UTC

Najmi (marked)

2023-02-24 03:08:05 UTC

Rania(marked)

2023-02-24 03:10:54 UTC

Aiman (22/23)

juliajunaidi — 2023-02-24 03:14:21 UTC

Adlee - Marked (by Diyana)

2023-02-24 03:18:19 UTC

Hash Table - Aiman Daud

aimandaud — 2023-02-24 03:25:58 UTC

Rania’s

2023-02-24 03:28:50 UTC

Harun

2023-02-26 23:42:01 UTC

Nur Diyana Amani Khairuddin

2023-02-27 02:18:25 UTC

Julia Hannah

juliajunaidi — 2023-02-27 02:24:23 UTC

MUHAMMAD NUR HAMZAH BIN NORAZAM

juliajunaidi — 2023-02-27 02:25:46 UTC

Najmi

2023-02-27 02:35:32 UTC

Muhamad Adlee Hakimi Bin Mohd Nazlee (Lee)

AdleeHakimi — 2023-02-27 02:42:27 UTC

susilawati — 2023-03-10 02:10:23 UTC

susilawati — 2023-03-10 02:10:37 UTC

susilawati — 2023-03-15 03:09:08 UTC

susilawati — 2023-03-15 03:09:25 UTC

susilawati — 2023-03-20 03:12:53 UTC

susilawati — 2023-03-20 03:13:06 UTC

susilawati — 2023-03-23 02:55:25 UTC

susilawati — 2023-03-23 03:50:56 UTC