eiei

Author: anythingth2

Diff for: .lab7_1.py.swp

@@ -0,0 +1,30 @@
+class node:
+    def __init__(self,data):
+        self.data = data
+        self.next = None
+
+class linkedlist:
+    def __init__(self):
+        self.head = self.tail = None
+    
+    def __str__(self):
+        output =''
+        n = self.head
+        while n is not self.tail:
+            output += n.data
+            n = n.next
+        output+=n.data
+        return output
+    def append(self,data):
+        if self.head == None:
+            self.head = node(data)
+            self.tail = self.head
+        else:
+            tail = self.tail
+            tail.next = node(data)
+            self.tail = tail.next
+x = linkedlist()
+x.append('a')
+x.append('b')
+x.append('c')
+print(x)

Diff for: .lab7_1.py.un~

@@ -0,0 +1,148 @@
+class node:
+    def __init__(self,data,nexts = None):
+        self.data = data
+        self.nexts = nexts 
+
+    def __str__(self):
+        return self.data
+
+class List:
+
+    def __init__(self,data = None):
+        self.head = self.tail = node(data)
+        self.size = 0 if data == None else 1
+    def __str__(self):
+        p = self.head
+        while p.nexts != None:
+            print(p.data,end=' ')
+            p = p.nexts
+        print(p.data)
+        return ''
+    
+    def isEmpty(self):
+        return self.size == 0
+
+    def append(self,data):
+        p = node(data)
+        if self.head.data == None:
+            self.head = p
+            self.tail = self.head
+        self.tail.nexts = p
+        self.tail = p
+        self.size += 1
+    
+    def addHead(self,data):
+        p = node(data,self.head)
+        self.head = p
+        self.size +=1
+
+    def isIn(self,data):
+        t = self.head
+        while t.nexts != None:
+            if t.data == data:
+                return True
+            t = t.nexts
+        if t.data == data:
+            return True
+        return False
+
+    def before(self,data):
+        before = None
+        i = self.head
+        while i.nexts != None:
+            if i.data == data:
+                return before
+            before = i
+            i = i.nexts
+        if i.data == data:
+            return before
+        return None
+
+    # def remove(self,data):
+    #     if not self.isIn(data) or self.before(data) == None:
+    #         print('Failed to remove')
+    #         return
+    #     self.before(data).nexts = self.before(data).nexts.nexts
+    
+    def remove(self,index):
+        currentNode = self.get(index-1)
+        currentNode.nexts= self.get(index+1)
+    def removeTail(self):
+        t = self.before(self.tail.data)
+        t.nexts = None
+        self.tail = t
+
+    def removeHead(self):
+        self.head = self.head.nexts
+
+    def get(self,index):
+        if index > self.size:
+            raise IndexError
+        t = self.head
+        for i in range(index):
+            t = t.nexts
+        if t != None:
+            return t
+
+    def insert(self,node,index):
+        currentNode = self.get(index)
+        nextNode = currentNode.nexts
+        
+        currentNode.nexts = node
+        node.nexts = nextNode
+
+        
+class Poke(List):
+    def __init__(self,start,end):
+        List.__init__(self,)
+        for i in range(start,end+1):List.append(self,str(i))
+    def bottomUp(self,factor):
+        if factor <= 0 or factor >= 1:
+            raise IOError('factor must in range 0 - 1')
+        sizeBottomUp =int(self.size*factor)
+        newTail = self.get(sizeBottomUp)
+        newHead = newTail.nexts
+        oldHead = self.head
+        oldTail = self.tail
+        oldTail.nexts = oldHead
+        self.tail = newTail
+        self.tail.nexts = None
+        self.head = newHead
+    def deBottomUp(self,factor):
+        if factor <= 0 or factor >= 1:
+            raise IOError('factor must in range 0 - 1')
+        sizeDeBottomUp = int(self.size*factor)
+        newTail = self.get(self.size - sizeDeBottomUp)
+        newHead = self.get(self.size - sizeDeBottomUp + 1)
+        self.tail.nexts = self.head
+        self.head = newHead
+        self.tail = newTail
+        newTail.nexts = None
+
+    def riffle(self,factor):
+        if factor <= 0 or factor >= 1:
+            raise IOError('factor must in range 0 - 1')
+        cutIndex = int(self.size * factor)
+
+        self.tail = self.get(cutIndex)
+        # self.tail.nexts = None
+        for i in range(0,self.size - cutIndex):
+            insertNode = node(self.get( i + cutIndex ).data)
+            self.remove(i+cutIndex)
+            self.insert(insertNode,i*2)
+    
+    def deRiffle(self,factor):
+        if factor <= 0 or factor >= 1:
+            raise IOError('factor must in range 0 - 1')
+        
+        
+
+            
+
+    
+poke = Poke(1,10)
+poke.riffle(0.6)
+print(poke)
+#poke.bottomUp(0.3)
+# poke.riffle(0.6)
+# print(poke)

Diff for: .linkedlist.py.un~

@@ -0,0 +1,74 @@
+def printNdown(n):
+    if n==1:
+        print(n,end=' ')
+    else:
+        print(n)
+        printNdown(n-1)
+
+def printToN(n):
+    if n==1:
+        print(n ,end= ' ')
+    else:
+        printToN(n-1)
+        print(n,end=' ')
+
+def sumToN(n):
+    if n==1:
+        return 1
+    else: 
+        return n+sumToN(n-1)
+
+def printForw(lists):
+    if len(lists) != 0:
+        return str(lists.pop(0)) + str(printForw(lists))
+    else:return ''
+
+def printBack(lists):
+    if len(lists) != 0:
+        return str(lists.pop()) + str(printBack(lists))
+    else:return ''
+
+class node:
+    def __init__(self,data):
+        self.data = data
+        self.next = None
+    def __str__(self):
+        return self.data
+
+class lists:
+    def __init__(self,lists_head = None):
+        if lists_head == None:
+            self.head = self.tail = None
+        else:
+            self.head = node(lists_head.pop(0))
+            n = self.head
+            while len(lists_head) != 0:
+                n.next = node(lists_head.pop(0))
+                self.tail = n
+                n = n.next
+            
+    def __str__(self):
+        output = ''
+        n = self.head
+        while n.next != None:
+            print(n.data,end=' ')
+            n = n.next
+        print(n.data)
+        return ''
+
+def fibo(n):
+    if n==1 or n==2:
+        return 1
+    else:
+        return fibo(n-1) + fibo(n-2)
+print(fibo(20))
+x = lists([1,2,3,4,5])
+
+#print(x)
+
+
+#printNdown(5)
+#printToN(5)
+#print(sumToN(10))
+#print(printForw([1,2,3,4,5]))
+#print(printBack([1,2,3,4,5]))

Diff for: 1

@@ -0,0 +1,74 @@
+def printNdown(n):
+    if n==1:
+        print(n,end=' ')
+    else:
+        print(n)
+        printNdown(n-1)
+
+def printToN(n):
+    if n==1:
+        print(n ,end= ' ')
+    else:
+        printToN(n-1)
+        print(n,end=' ')
+
+def sumToN(n):
+    if n==1:
+        return 1
+    else: 
+        return n+sumToN(n-1)
+
+def printForw(lists):
+    if len(lists) != 0:
+        return str(lists.pop(0)) + str(printForw(lists))
+    else:return ''
+
+def printBack(lists):
+    if len(lists) != 0:
+        return str(lists.pop()) + str(printBack(lists))
+    else:return ''
+
+class node:
+    def __init__(self,data):
+        self.data = data
+        self.next = None
+    def __str__(self):
+        return self.data
+
+class lists:
+    def __init__(self,lists_head = None):
+        if lists_head == None:
+            self.head = self.tail = None
+        else:
+            self.head = node(lists_head.pop(0))
+            n = self.head
+            while len(lists_head) != 0:
+                n.next = node(lists_head.pop(0))
+                self.tail = n
+                n = n.next
+            
+    def __str__(self):
+        output = ''
+        n = self.head
+        while n.next != None:
+            print(n.data,end=' ')
+            n = n.next
+        print(n.data)
+        return ''
+
+def fibo(n):
+    if n==1 or n==2:
+        return 1
+    else:
+        return fibo(n-1) + fibo(n-2)
+print(fibo(10))
+x = lists([1,2,3,4,5])
+
+#print(x)
+
+
+#printNdown(5)
+#printToN(5)
+#print(sumToN(10))
+#print(printForw([1,2,3,4,5]))
+#print(printBack([1,2,3,4,5]))

Diff for: lab5_1.py

@@ -0,0 +1,30 @@
+class node:
+    def __init__(self,data):
+        self.data = data
+        self.next = None
+
+class linkedlist:
+    def __init__(self):
+        self.head = self.tail = None
+    
+    def __str__(self):
+        output =''
+        n = self.head
+        while n is not self.tail:
+            output += ' ' + str(n.data)
+            n = n.next
+        output+=' ' + str(n.data)
+        return output
+    def append(self,data):
+        if self.head == None:
+            self.head = node(data)
+            self.tail = self.head
+        else:
+            tail = self.tail
+            tail.next = node(data)
+            self.tail = tail.next
+x = linkedlist()
+x.append('a')
+x.append('b')
+x.append('c')
+print(x)

Diff for: lab7_1.py

@@ -0,0 +1,30 @@
+class node:
+    def __init__(self,data):
+        self.data = data
+        self.next = None
+
+class linkedlist:
+    def __init__(self):
+        self.head = self.tail = None
+    
+    def __str__(self):
+        output =''
+        n = self.head
+        while n is not self.tail:
+            output += ' ' + str(n.data)
+            n = n.next
+        output+=n.data
+        return output
+    def append(self,data):
+        if self.head == None:
+            self.head = node(data)
+            self.tail = self.head
+        else:
+            tail = self.tail
+            tail.next = node(data)
+            self.tail = tail.next
+x = linkedlist()
+x.append('a')
+x.append('b')
+x.append('c')
+print(x)