I am trying to write a function that returns true or false if a given string has exactly 6 consecutive characters with the same value. If the string has more or less than 6, it will return false:

I am not allowed to use lists, sets or import any packages. I am only restricted to while loops, for loops, and utilizing basic mathematical operations

Two example runs are shown below:

Enter a string: 367777776  
True

Enter a string: 3677777777776  
False

Note that although I entered numbers, it is actually a string within the function argument for example: consecutive('3777776')

I tried to convert the string into an ASCII table and then try and filter out the numbers there. However, I

def consecutive(x):
    storage= ' '
    acc=0
    count=0
    for s in x:
        storage = str(ord(s))   ' '
        acc =ord(s)
        if acc == acc:
            count =1
    for s in x-1:
        
    return count

My intention is to compare the previous character's ASCII code to the current character's ASCII code in the string. If the ASCII doesnt match, I will add an accumulator for it. The accumulator will list the number of duplicates. From there, I will implement an if-else statement to see if it is greater or less than 6 However, I have a hard time translating my thoughts into python code.

Can anyone assist me?

CodePudding user response：

That's a pretty good start!

A few comments:

• Variables storage and acc play the same role, and are a little more complicated than they have to be. All you want to know when you arrive at character s is whether or not s is identical to the previous character. So, you only need to store the previously seen character.
• Condition acc == acc is always going to be True. I think you meant acc == s?
• When you encounter an identical character, you correctly increase the count with count = 1. However, when we change characters, you should reset the count.

With these comments in mind, I fixed your code, then blanked out a few parts for you to fill. I've also renamed storage and acc to previous_char which I think is more explicit.

def has_6_consecutive(x):
    previous_char = None
    count = 0
    for s in x:
        if s == previous_char:
            ???
        elif count == 6:
            ???
        else:
            ???
            previous_char = ???
    ???

CodePudding user response：

You could use recursion. Loop over all the characters and for each one check to see of the next 6 are identical. If so, return true. If you get to the end of the array (or even within 6 characters of the end), return false.

For more info on recursion, check this out: https://www.programiz.com/python-programming/recursion

CodePudding user response：

would something like this be allowed?

def consecF(n):
    consec = 1
    prev = n[0]
    for i in n:
        if i==prev:
            consec =1
        else:
            consec=1
        if consec == 6:
            return True
        prev = i
        
    return False
n = "12111123333221"
print(consecF(n))

CodePudding user response：

You can try a two pointer approach, where the left pointer is fixed at the first instance of some digit and the right one is shifted as long as the digit is seen.

def consecutive(x):
    left = 0
    while left != len(x):
        right = left
        while right < len(x) and x[right] == x[left]:
            right  = 1
        length = (right - 1) - left   1 # from left to right - 1 inclusive, x[left] repeated
        if length == 6: # found desired length
            return True
            
        left = right

    return False # no segment found
     
tests = [
    '3677777777776',
    '367777776'
]

for test in tests:
    print(f"{test}: {consecutive(test)}")

Output

3677777777776: False
367777776: True

CodePudding user response：

You should store the current sequence of repeated chars.

def consecutive(x):
    sequencechar = ' '
    repetitions = 0
    for ch in x:
        if ch != sequencechar:
            if repetitions == 6:
                break
            sequencechar = ch
            repetitions = 1
        else:
            repetitions  = 1
    return repetitions == 6

If I could, I would not have given the entire solution, but this still is a simple problem. However one has to take care of some points.

As you see the current sequence is stored, and when the sequence is ended and a new starts, on having found a correct sequence it breaks out of the for loop.

Also after the for loop ends normally, the last sequence is checked (which was not done in the loop).