CareerCup

Strt with two pointers. One slow and anothoer Fast. Below is the code in Python.

class Node:

    """
    Basic Node Object
    """    
    __slots__ = 'elements', 'Next'
    
    def __init__(self, element, Next):
        self.element = element
        self.Next=Next
        
        
class LinkedList(object):

    """
    Create a linkedlist object using the Node Object
    """
    size = 0 # Let size be the attribute of the LinkedList Class Object
    
    def __init__(self):
        
        """
        Initialize a Head reference of the LinkedList object
        """
        self.Head=None
        
    def addElement(self, e):
        
        # Create a newNode Object
        newNode = Node(e, None)
        if LinkedList.size==0:
            self.Head=newNode
        else:
            newNode.Next=self.Head
            self.Head=newNode
        LinkedList.size += 1
        
    def displayList(self):
        #Create a tempNode and iterate
        tempNode = self.Head
        while(tempNode):
            print "Current element is [%d]"% tempNode.element
            tempNode = tempNode.Next
        
    
    def addElementinOrder(self, e):
        # Create a slow pointer and a Fast pointer
        # Travel through the list and place the element 
        # immediately after the element smaller than the given 
        # element.
        # We will also address the edge cases here
        
        slowNode=self.Head
        fastNode=self.Head.Next
        newNode = Node(e,None)
        # Check if the element that is added is less than the head
        # Add the element in head
        if self.Head.element > e:
            self.addElement(e)
        # Travel until you reach dead end
        else:
            while(fastNode):
                #stop traversing as soon as you find element larger than target
                if fastNode.element > e:
                    break
                else:
                # Continue traversing otherwise
                    slowNode=slowNode.Next
                    fastNode=fastNode.Next  
            #Make changes to the node 
            newNode.Next=fastNode
            slowNode.Next=newNode
                
        
    
    
    
if __name__== "__main__":
    
    MyLinkedList = LinkedList()
    nums = [70, 60, 50, 30, 20, 10]
    for n in nums:
        print "Inserting num = %d" % n
        MyLinkedList.addElement(n)
    
    print "=================================\n"
    print "Displaying elements in LinkedList"
    MyLinkedList.displayList()
    
    print "=================================\n"
    print "The Length of LinkedList is %d" % MyLinkedList.size
    
    print "=================================\n"
    print "Inserting 40 in LInkedList"
    
    MyLinkedList.addElementinOrder(40)
    
    print "Displaying elements in LinkedList"
    MyLinkedList.displayList()

Output:

Inserting num = 70
Inserting num = 60
Inserting num = 50
Inserting num = 30
Inserting num = 20
Inserting num = 10
=================================

Displaying elements in LinkedList
Current element is [10]
Current element is [20]
Current element is [30]
Current element is [50]
Current element is [60]
Current element is [70]
=================================

The Length of LinkedList is 6
=================================

Inserting 40 in LInkedList
Displaying elements in LinkedList
Current element is [10]
Current element is [20]
Current element is [30]
Current element is [40]
Current element is [50]
Current element is [60]
Current element is [70]

Please clear my doubt. Are all arrangements unique? What I mean it consider a 2x3 board, there can be 2 unique ways of arranging 2x1 tiles. However, you can also do another ways if you consider all arrangements unique.

_____
| |___|
I_ |___| is same as

_____
|___| |
|___| _|

Here's a short Implementation in Python

count = 0

def MaximumRepeatingInteger(arrayofnumber):
    global count
    dict_of_counts = {}
    for integer in arrayofnumber:
        if dict_of_counts.has_key(str(integer)):
            count +=1
            dict_of_counts[str(integer)]=count
        else:
            count = 1
            dict_of_counts[str(integer)]=count
        
    return max(dict_of_counts.values())

number = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5]
print MaximumRepeatingInteger(number)  : 14

number=[1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5]
print MaximumRepeatingInteger(number)  : 21

Moreover there should be a global way of storing them, you may want to remember the earlier state of the system before actually executing the newer values. Perform sufficient checks to ensure that pressure and speed are always positive at any given time (real time scenario). If the state of the system changes to negative values after performing the operation we may simple raise error.

Changed the algorithm to Python Dictionary as per your suggestion

def FindString(String, subString):
    pLen = len(subString)
    pString = ''
    found = False
    pHashTable={}
    pHashTable[subString]=subString
    if pLen > 0:
        for i in range(len(String)):
            pString = String[i:i+pLen]
            if pHashTable.has_key(pString):
                return True
    return found


def PrintMatch(String, subString):
    if FindString(String, subString): 
        print "Found %s inside %s" %(subString, String)
    else:
        print "No match Found. "
        

PrintMatch('bottle', 'tl')
PrintMatch("dceababac", "abac")

Found tl inside bottle
Found abac inside dceababac

def FindString(String, subString):
    pLen = len(subString)
    pString = ''
    found = False
    if pLen > 0:
        for i in range(len(String)):
            pString = String[i:i+pLen]
            if pString == subString:
                return True
    return found


def PrintMatch(String, subString):
    if FindString(String, subString): 
        print "Found %s inside %s" %(subString, String)
    else:
        print "No match Found. "
        

PrintMatch('bottle', 'tl')
PrintMatch("dceababac", "abac")

Found tl inside bottle
Found abac inside dceababac