Convert to Racket(Scheme)

One nice thing about Scheme is that it encourages you to look for elegant solutions rather than the creeping horror in the question, safe in the knowledge that the elegant solution will generally also be the efficient one.

So, since this is, I think, rather obviously a homework problem and I don’t really want to help people cheat, here is an elegant solution in Python. In Python this will perhaps not be efficient, especially for long arrays. Turned into Racket it is both the obvious solution and efficient.

def longest_contiguous(a):
    l = len(a)
    def loc(i, current, this, best):
        # i is current index, current is the element in the current
        # run, this is the length of the current run, best is the
        # length of the longest run.
        if i == l:              # we're done
            return best if best > this else this
        elif a[i] == current:   # in a run
            return loc(i + 1, current, this + 1, best)
        else:                   # new run
            return loc(i + 1, a[i], 1, best if best > this else this)
    return loc(0, a[0], 1, 1) if l > 0 else 0

And here is such an elegant solution in Racket: framed in such a way that, again, it probably can’t be submitted as homework. This will work on both vectors and lists, and indeed many other things. And as well as the length of the longest contiguous sequence, it will tell you where that sequence starts.

(require racket/stream
         racket/generic)

(define-generics to-stream
  ;; Turn something into a stream in a way which could be extended
  (->stream to-stream)
  #:fast-defaults
  ((stream?
    (define ->stream identity))
   (sequence?
    (define ->stream sequence->stream))))

(define (length-of-longest-contiguous-subthing thing
                                               #:same? (same? eqv?)
                                               #:count-from (count-from 0))
  (define s (->stream thing))
  (if (stream-empty? s)
      (values 0 count-from)
      (let los ([st (stream-rest s)]
                [current (stream-first s)]
                [count (+ count-from 1)]
                [this 1]
                [this-start 0]
                [best 0]
                [best-start 0])
        (cond
          [(stream-empty? st)
           (if (> this best)
               (values this this-start)
               (values best best-start))]
          [(same? (stream-first st) current)
           (los (stream-rest st) current (+ count 1)
                (+ this 1) this-start
                best best-start)]
          [else
           (if (> this best)
               (los (stream-rest st)
                    (stream-first st) (+ count 1)
                    1 count
                    this this-start)
               (los (stream-rest st)
                    (stream-first st) (+ count 1)
                    1 count
                    best best-start))]))))

Now, for instance:

> (length-of-longest-contiguous-subthing '(1 2 3 4 4 5 6 6 6 7))
3
6

The longest contiguous subsequence is 3 elements log and starts at the 6th element.

But also:

> (call-with-input-file
   "/tmp/x"
   (λ (p)
     (length-of-longest-contiguous-subthing (in-lines p)
                                            #:same? string=?
                                            #:count-from 1)))

The longest sequence of identical lines in /tmp/x is 2, and it starts at line 2, counting from 1.

OK so you want,

[6, 1, 1, 10, 10, 111, 100] => 2
[6, 1, 1, 1, 100, 111, 100] => 3
[6, 10, 10, 20, 10, 10, 10] => 3

because

[[6], [1, 1], [10, 10], [111], [100]] => [1,2,2,1,1] => 2
[[6], [1, 1, 1], [100], [111], [100]] => [1,3,1,1,1] => 3
[[6], [10, 10], [20], [10, 10, 10]]   => [1,2,1,3]   => 3

And so, taking the higher-level view, we

(define (length-longest-constant-span xs equ)
  (maximum 
    (map length
      (constant-spans xs equ))))

Now, maximum is easy to

(define (maximum lon)
   (apply max lon))

and we’re left with the task of

(define (constant-spans xs equ)

for xs which can be either empty

  (if (null? xs)
    (list (list))     ; [[]]

(returning [[]] because [1] => [[1]] and so it should be [] => [[]]); or non-empty,

    (let* ((a (car xs))
           (d (cdr xs))

and since we’re coding it up, we’ll finish writing it sometime, and then it will be available to us to call so we might as well call it, with a smaller part of the input,

           (r (constant-spans d equ))

and then we’ll be able to analyze the recursive result, which we know will never be empty — because of how we’ve just defined the handling of the empty list case above, returning the non-empty list [[]] —

           (ra (car r))
           (rd (cdr r)))

(or we could’ve repeated the same if ... null? ... let* ... car ... cdr ... dance…)^(*)

so that now, finally, we get to decide what to do with that recursive result, case by case, whether the head element ra in it is empty,

      (cond
        ((null? ra)   ; [[]] --> [[a]]
          (cons (cons a ra) rd))

or non-empty, so we can peek into it, and see whether its head element is the same as a, as deemed by equ,

        ((equ a (car ra))  ; a [[a,...],...] --> [[a,a,...],...]
          (cons (cons a ra) rd))

or not (it’s same thing we’re doing here as above, huh. So we can simplify the code if we want, later; but first,):

        (else              ; a [[b,...],...] --> [[a],[b,...],...]
          (cons (list a) r))))))

and that’s that.

If I made any errors here, do kindly fix them, to make it work.

---

^(*) which combination can be seen as one primitive pattern-based data handling operation — sometimes known as caseof — under the data type oriented paradigm. caseof combines data case detection, analysis, and binding of variables.

In such pseudocode a data analyzing code naturally follows the data type definition:

type | [a, ..[b, ...]]
     | []
.......
rle xs equ =
  caseof xs
  | [] --> [[]]
  | [a, ..d] --> 
    caseof (rle d equ)
    | [] --> ...
    | [ra, ..rd] --> ...
........

making the decision tree apparent in our code.