CareerCup

This is how you nail it:
go to : [ cdecl.org ]
====
declare p as array 5 of pointer to function returning int
=====

Rudimentary. Just do DFS in any form with depth count ( max_depth ) and create visited set.
Do this for both user_1 and user_2.
Then simply do an intersection.
You are done.

def print_triangular(depth){
  panic( depth > 7 , "We do not have those many...")
  alphabet = ['A':'Z'].asList 
  upto = 0 
  for ( row_num : [1: depth] ){
    row = str( [upto:upto+row_num] , "" ) as { alphabet[$.o] }
    upto += row_num
    println(row)
  }
}

/* 
In the current form, the problem is un-intelligible.
Formal problem should be as follows.
Let a list of persons be given in a format such that:
person -> parent_1, parent_2
item = [child, parent_1, parent_2]

where person, parent_1, parent_2 are (string/int) ids, 
and it means 'person' is a children of parent_1 & parent_2

Now, given two random parson p1, and p2 can we tell if they are related?
That also is not a formal statement.
Related, quite literally means if there is a path from p1 to p2.
Below is the code that sovles it:
*/

def are_related( person_1, person_2 , data ){
  def build_graph( parental_list ){}
    graph = dict()
    for ( item : parental_list ){
      #(child, p1, p2) = item
      if ( child !@ graph ){ graph[child] = set() }
      if ( p1 !@ graph ){ graph[p1] = set() }
      if ( p2 !@ graph ){ graph[p2] = set() }
      graph[child] += [ p1, p2 ]
      graph[p1] +=  child
      graph[p2] +=  child
    }
  }
  def path_exists( relation_graph, p1, p2 ){
   visited = set()
   queue = list()
   queue.enqueue(p1)
   while ( !empty(queue)){
     p = queue.poll()
     relations_of_p_order_1 = relation_graph[p]
     if ( p2 @  relations_of_p_order_1 ) return true
     unvisited = select( relations_of_p_order_1) where { $.o !@ visited }
     visited += p
     queue += unvisited
   }
   false // no path 
  }
  path_exists( build_graph(data), person_1, person_2 ) )
}

Pretty rudimentary. And too much code, this is not worthy for a Sr Software Eng.

def one_or_no_parents( data ){
  graph_data = dict()
  for ( pair : data ){
    if ( pair[0] !@ graph_data ){ graph_data[pair[0]] = set() }
    if ( pair[1] !@ graph_data ){ graph_data[pair[1]] = set() }
    graph_data[pair[1]] += pair[0]
  }
  // now parition the whole graph_data 
  parental_buckets = [ set(), set(), set() ]
  for ( child : graph_data.keys ){
    num_parents = size(graph_data[child])
    parental_buckets[num_parents] += child
  }
  [ parental_buckets[0], parental_buckets[1] ] // return 
}

It has enough hint - and you can easily convert it to Python.

def avg_mark_lowest_id_student( data_file ){
  students = dict() //  dict 
  lowest_student_id = num("inf")
  for ( line : file(data_file) ){
    #(id, sub, marks) = line.split("\\W+")
    id = int(id) // cast to int
    if ( id !@ students ){
      if ( id < lowest_student_id ){
        lowest_student_id = id // update the lowest id
      }
      students[id] = list()
    }
    students[id] += marks
  }
  data_list = students[lowest_student_id]
  tot = sum( data_list )
  avg = float(tot)/size(data_list)
}

It is more simpler than people made it to be.

/* 
Level order traversal 
*/
def Node : { v : null, child : [] }

def traverse( root ){
  cur_level = list( root )
  while ( !empty( cur_level ) ){
    next_level = list()
    for ( node : cur_level ){
      printf( "%s ", node.v )
      next_level += node.child 
    }
    println()
    cur_level = next_level
  }
}

/* 
Given a binary tree, 
Find the path having maximal product.
It can be shown that for :
1. a generic binary tree, 
2. any sort of numerical values  ( +,- )
This is impossible w/o going via all possible paths,
from the root.
Thus, the problem is chalked out for us:
*/
def node : {  v: 0 , c : [] } 

def solve( root ){
  def traversal( node, cur_path, all_paths ){
    my_path = cur_path + node.v 
    if ( empty(node.c) ){
      all_paths.add ( my_path )
      return 
    }
    for( node.c ){ traversal($, cur_path, all_paths) }
  }
  all_paths = list()
  traversal( root, [] , all_paths )
  all_products = list ( all_paths ) as { 
    product = fold ( $.o , 1 ) as { $.p *= $.o }
    [ $.o, product ]
  }
  #(,max) = minmax( all_products ) where { sign($.l.1 - $.r.1) }
  max // rerturn 
}

It is incredibly simple.
1. If the first char and last char are not "(" and ")" - then return the same string.
2. If they are, then,
2.1 get the substring "sub" from position 1 to len-2 (0 based index ).
2.2. Verify if this string has matched parenthesis
2.3 If it has then return the "sub".
2.4 Else return the original string.

Here.

def bin_add( n1, n2 ){
  /* 
  n1 digit, n2 digit, carry digit from previous ->
  carry, resulting digit 
  */
  RULES = { '000' : '00', 
            '001' : '01', 
            '010' : '01',
            '011' : '10',
            '100' : '01', 
            '101' : '10',
            '110' : '10',
            '111' : '11' }
  min_size = size(n2)
  max_size = size(n1)
  if ( max_size < min_size ){
    #(n2,n1) = [n1, n2] // swap 
  }
  carry = '0'
  result = ""
  // when both are same size 
  i = min_size -1
  j = max_size -1
  while ( i >=0 ){
    input = str("%s%s%s", n1[j],n2[i], carry)
    i -= 1 
    j -= 1
    output = RULES[input]
    carry = output[0]
    result = str( "%s%s", output[1],  result )
  }
  while ( j >= 0) {
    input = str("%s0%s", n1[j],carry) 
    j -= 1
    output = RULES[input]
    carry = output[0]
    result = str( "%s%s", output[1],  result )
  }
  if ( carry == '1' ){
    result = str("1%s", result)
  }
  result // return 
}

println( bin_add('1101','1') )

Too much convolution, really. Not needed.

def depth_sum( some_item , cur_depth = 0){
   if ( !(some_item isa 'list') ) return ( some_item * cur_depth ) 
   sum ( some_item ) as {
       depth_sum( $.o, cur_depth + 1 )
   }
}
A = [[1,1],2,[1,1]]
x = depth_sum( A )
println(x)

Repeat of [ careercup.com/question?id=5139875124740096 ]

I am wondering, as an ex-SDEIII in amazon - where in Amazon people would build parser/interpreter - this is a case of that.
One good thing is - it is about pretty simple case of line by line parsing. So it is a line by line interpreter - that is good.
The bad is one line can be arbitrary complex expression.

Forget SDEIIs there are not many PE's who are capable of handling this problem.

/* 
 this function defines the weight between two vertices
 we are looking at a directed graph, 
  where a->b and b->a will have different weights
*/
def min_click_path( ch_src, ch_dst  ){
   abs_delta = #|ch_src - ch_dst | // this is done by using +/- channel button 
   dst_digits = size( ch_dst , 10 ) // this is the abs number press 
   #(m,M) = minmax( abs_delta, dst_digits )
   m // minimal path from src to dst 
}
/* 
now just assume en.wikipedia.org/wiki/Dijkstra%27s_algorithm
from src to ch_dst 
respond with the weight for ch_dst 
*/

I just wrote this .. and I believe it is beautiful. From elegance perspective. Hence, sharing.

def tail_function( file_name , n ) {
  last_n_lines = list( [0:n] ) as { null }
  cur_inx = 0 
  lc = 0 
  for ( line : file(file_name) ){
    lc += 1 
    cur_inx %= n
    last_n_lines[cur_inx] = line 
    cur_inx += 1  
  }
  // print back the last_n_lines, imagining a circular buffer
  start_inx =  lc % n  
  
  for ( [start_inx:n] ){ (x = last_n_lines[$]) || x == null || println(x) }
  for ( [0:start_inx] ){ (x = last_n_lines[$]) || x == null || println(x) } 
}

tail_function( @ARGS[0] , @ARGS[1])

/* 
Of course there is a way to do it, with remembering 
the last char and current char and proceed, 
but that is not cool. That is too mundane.
So, I propose this insanely interesting strategy
*/
def reduce_string( some_string ) {
  res = some_string
  for ( c : some_string ){
    regex_pattern = str("[%s]{2,}", c)
    res = res.replaceAll(regex_pattern,"")
  } 
}
println( reduce_string( "aaaaacbbbbxxxdddddefghhg") )

Well, well. I am not entirely sure... but this seems to fit the bill. It was fun.
Can anyone break it?

I will hire you. I just wrote an answer that is just that w/o seeing yours. Darn right you are.

We do not require sorting at all. No need. Using sorting, things are incredibly easy. There is a neat and fun way of solving this.

/* 
If the precision of the meetings are in integers
that is 2:30 to 3:30, then we can simply quantize
the minimal value which is 30 mins meeting time min.
Then the problem becomes finding the time quantum of 30 mins 
which contains the maximum overlap of meetings.
We encode the time 11:30 as 11.5 -> 115 and take a 5 as 30 mins.
This can easily be done.
This can be solved in Theta(N). Observe:
*/
def find_min_rooms( list_of_meetings ) {
  // simply carry on a counter ...
  counter = dict()
  for ( meeting : list_of_meetings ){
     for ( s = meeting.start * 10 ; s <= meeting.end * 10 ; s+= 5 ){
       counter[s] += 1 ?? counter[s] = 1 
     }
  } 
  #(m,M) = minmax( counter.values )
  return M 
}

Also, we can find out what point groups can not mutually create a circle. How? Simple, any 3 points on a plane can be made into a circle, unless all 3 of them form a line.

It is O(n^2) to check all points to find out all lines, at most.
So, we would have point groups which can not be used as circle.
That automatically should reduce a lot of points comparison.

They, might be possibly more optimisations, but am thinking still. Hence a comment, not an answer.

Ah I see. Then your solution works, and the question is not even a question, sadly. :(

@Ankit Tomar's idea will not generally work - because arrays are not guaranteed to be unique. Of Course with unique array - where all elements are different it will work, but that is now as trivial as intersection and union of sets.

Solution to this problem is to imagine the generalised set operations.
Suppose an element valued "e" has count "count_a" in the "a" array or list, and "count_b" in the "b" array or list.

count of element "e" in the intersection of a,b will be defined as:

min( count_a, count_b)

count of element "e" in the union of a,b will be defined as:

max( count_a, count_b)

This generalised algorithm now can be used to Union/Intersection.You can generalised this to even find out set minus.

Actual problem can be solved, for all inputs this way , worthy of SDE 3 tag. Kudos Amazon.

/* 
select domain of inversions,
and imagine starting with (0,0) which is sorted ascending.
*/
def find_if_whatever( array ){
  N = size(array)
  if ( N < 2 ) return true // boundary condition
  // now, anything else.
  domains = list()
  domain = { 's' : 0, 'e'  : 0 , 'st' : true }
  for ( i : [ 1 : N ] ){
    sorted = ( array[domain.e] <= array[i] ) 
    if ( sorted == domain.st ){
      // add to domain 
      domain.e = i 
    } else {
       // end domain, create domain 
       domains += domain
       domain = { 's' : i, 'e'  : i , 'st' : sorted }
    }
  } 
  // now am done ...
  domains += domain
  println( jstr( domains ) ) // debug???
  // now, well, well... 
  D = size( domains) 
  if ( D > 3 ) return false // no go... right?
  // this is a clear go 
  if ( D == 1 ) return true 
  // now, when D=2, we have.. problems.. so 
  if ( D == 2 ){
    if ( domains[0].st && !domains[1].st ) return array[domains[0].e] <= array[domains[1].s] 
    if ( !domains[0].st && domains[1].st ) return array[domains[0].s] <= array[domains[1].s] 
    return false 
  }
  // now when D==3, so... larger problems...
   if ( domains[0].st && domains[2].st ) { 
     return array[domains[0].e] <= array[domains[1].e] && 
            array[domains[1].s] <= array[domains[2].s] 
   } 
   return false // done 
}

 
println( find_if_whatever([ 1, 10,-1 ]) )
println( find_if_whatever([ 1, 2,3,4,8,7,6,9  ]) )
println( find_if_whatever([ 1,2,3,50,40,90,10,23,99  ]) )

Upvoted, only works if there is some amount of sorting.
It breaks for inputs like : [ 6,1,2,5,4,3,2,1 ], essentially unsorted inputs.

Use heap and you are done.
[ en.wikipedia.org/wiki/Min-max_heap ]

/* 
It can be done, in multiple linear traversals.
[1] Traverse to find out the min and max of the session ranges.
[2] Create a list of session count per time point, and keep on increasing
[3] Last traversal, find out the range which has max count.

We do not know (a,b) means both inclusive, or first inclusive 2nd exclusive.
It is assumed that (a,b) means user was live from a to b, that is, both inclusive 
That does not match the sample output, obviously
*/

def get_max_session( session_list ){
  seed = { 'm' : num('inf'), 'M' : num('-inf') } 
  range = fold( session_list , seed ) as {
    $.p.m = ( $.p.m > $.o[0] ) ? $.o[0] : $.p.m 
    $.p.M = ( $.p.m < $.o[1] ) ? $.o[1] : $.p.M 
    $.p // return 
   }
   // now create a list, counters:
   counters = list( [range.m : range.M + 1] ) as { 0 } // done
   // next, increment counters...
   for ( session : session_list ){
      for ( offset : [ session[0] : session[1] + 1] ){
          counters[ range.m - offset ] += 1 // incrementing sessions
      }
   }
   // now, find out the range where max count exists
   max_range = { 's' : range.m , 'e' : range.m , 'c' : counters[0] }
   cur_range = { 's' : range.m , 'e' : range.m , 'c' : counters[0] }
   for ( i : [ 0 : size(counters) ] ){
      if ( cur_range.c != counters[i] ){
         cur_range = { 's' : i + range.m , 'e' : i + range.m , 'c' : counters[i] }
         if ( cur_range.c > max_range.c ){
             // update max 
             max_range = { 's' : cur_range.s, 'e' : cur_range.e, 'c' : cur_range.c }
         }
      } else {
         cur_range.e = i + range.m
      }
   }
   // print max 
   println( max_range )
}

session_list = [ [2,5], [3,6], [8,10],[10,12], [9,20] ]  
get_max_session( session_list )

result:

{s=13, c=3, e=13}

L = [['abc', 10], ['def', 15], ['ghi', 10], ['abc', 12], ['xyz', 100]] 
g = group( L ) as { $.o[0] } as { sum( $.value ) as { $.o[1] } } 
l = list(g) as { [ $.key, $.value ] }
sortd( l ) where { sign( $.l[1] - $.r[1] ) }
println( str(l , "\n") as { str($.o, "->") } )

Produces:

xyz->100
abc->22
def->15
ghi->10

Here you go.

/* 
In here, we are abusing Java IO 
*/
def abusing_java_print_count( path_string ){
   if ( path_string #$ "/" ){
      // remove trailing "/" 
      path_string = path_string[0:-2] 
   }
   words = path_string.split("/",-1)
   count = dict()
   p = words[0]
   f = file( p ).file.getCanonicalPath()
   count[f] = 1 
   for ( i : [ 1 : size(words) ] ){
      p += ("/" + words[i])
      f = file( p ).file.getCanonicalPath()
      if ( f !@ count ){
         count[f] = 0 
      }
      count[f] += 1 
   }
   count // return 
}

c = abusing_java_print_count( "a/../../../a")
println( jstr(c,true) )

The crucial thing is the abstract call to getCanonicalPath(), which one can now replace with
a custom impl. Here is how you get the response:

{
        "\/Codes\/zoomba\/a":1,
        "\/Codes":1,
        "\/a":1,
        "\/Codes\/zoomba":1,
        "\/":1
}

All answers are .. staggeringly wrong. Guys & Gals - it is a directory structure. I can destroy all these algorithms happiness by repeating same directory names in entirely different paths.

For example:

a/../../../a

Did you notice something interesting there? NO? Let me show you.
Suppose I am currently in the directory :

/home/dofus/

Now, the first bit will move me to

/home/dofus/a

Next 3 "../" will take me to :

/ # this is root!

And then next "a" will take me to:

/a # a directory under the root.

So, it is not as easy as it sounds. In fact, that is why the guys who write JDK has a special function for it called

[ docs.oracle.com/javase/10/docs/api/java/io/File.html#getCanonicalPath() ]

You have to normalise paths with respect to the starting or base directory.
And that is why it is an SDE3 question, not an SDE1/2 question.

Specifically:

visitCount("a/../../../a"); // null pointer exception

I will answer this in next post.

Here .
[ geeksforgeeks.org/search-an-element-in-a-sorted-and-pivoted-array/ ]

/* Find all perm.
Notice that the permutations are nothing but a mapping between 
index sets - bitmaps into the list of items.
Observe, for a 3 member list {c : 3, b : 2 , a : 1 , '' :  0 } 
... 
Thus the problem is can be solved in 2 ways.
[1] Next higher permutation , when next is not there, increase number of digits
[2] Using the mthod of base 'k' numbers, when list is of size k - 1
where digits do not repeat. We implement  [2] here.
*/

def Permutations{
    def $$( list_of_items ){ // constructor 
      $.items = list_of_items 
      $.base = size( $.items ) + 1 
      assert( $.base - 1 == size( set( $.items) ), "Repeated items, I do not do those!" )
      $.cur_number = -1 // nothing 
    }
    def $next(){
       next_num = $.cur_number  
       while ( true ){
          next_num = next_num + 1
          base_change_string = str( next_num , $.base )
          //println( base_change_string )
          // can not use any integer that is having '0' as digit 
          continue ( '0' @ base_change_string )
          break ( size(base_change_string) > $.base )
          // if no digits repeated, then ok ?
          digits = set ( base_change_string.toCharArray )
          break ( size( digits) == size(base_change_string) )
       }
       break ( size(base_change_string) > $.base )
       $.cur_number = next_num
       // now map it back with the items 
       list ( base_change_string.toCharArray ) as { idx = int( $.o ) - 1 ; $.$.items[ idx ]  }
    }
}
p = new ( Permutations, [ 'a' ,'b' , 'c' ] )
for ( x : p ){
   println( x )
}

def find_cut_point(some_string){
  counter = 0 
  a_counter_list = list( some_string.toCharArray ) as {
    // cumulative count of 'a' at index
    ( $.o == _'a' ) ? ( counter += 1 ) : counter  
  }
  N = size(some_string)
  A_count = a_counter_list[-1] 
  B_count = N - A_count 
  exists( a_counter_list ) where {
    // $.o is the current item
    // $.i is the index of the item 
    current_b_count = $.i + 1 - $.o 
    count_a_which_will_be_left = A_count - $.o 
    count_b_which_will_be_left = B_count - current_b_count 
    count_a_which_will_be_left == count_b_which_will_be_left
  }
}

find_cut_point( "aaabbb" )

def back_track( tmp, n ){
  //println( str(tmp) )
  if ( n == 0 ) {
    println( str( tmp ) )
    return 
  }
  N = size( tmp )
  for ( i = 0; i < N - n -1 ; i+= 1 ){
    j = i + n + 1 
    continue( tmp[i] != 0 || tmp[j] != 0 )
    tmp_next = list(tmp) // deep copy 
    tmp_next[i] = tmp_next[j] = n 
    back_track( tmp_next, n-1 )
  }
}

def do_fb(n){
  buf = list( [0:n * 2 ] ) as { 0 } // get the buf
  back_track( buf , n  )
}
N = 4 
println( "== back tracking == ")
do_fb(N)

I think the keep it simple, stupid works better here.
1. Construct a graph from the list ( it is a type of adj list anyways )
2. Check if the graph is a tree first.
2.1 In that case, there must be no cycle
2.2 and one clear node with null parent.
3. Do a pre-order traversal on that "tree" and check at any point if there is any discrepancy
from the already given traversal.

@acoding, suppose the input is : ( parent_id, node_id) format :

( null, 0 ), ( null, 2 ) , ( null, 4 ) ,   (0,1) , ( 2,3), ( 4,5)

what would happen? Of course we are giving wrong input -- but..

No. Perhaps only you understood how to do it anyways.

/*
Problem is that:
 swap_even() can permutate only even indices.
 swap_odd() can permutate only odd indices.
That means that if someone breaks down the word into 
two bag of characters with 
Even [0] Bag for even indices ( 0 based indexing )
Odd [1] Bag of odd indices 
Then, two words are equivalent if 
for word w1 and w2
the bags ( Even and Odd ) are comprise of exact same 
characters with exact same frequencies
that is the tuple ( char , count ) must be same 
But on introspection, we can not compare this dictionary tuples.
So, what we do is create a sorted charset and then put a delimiter
to ensure that sorted_even_chars # sep # sorted_odd_chars
acts as key 

Thus, we can create a hash function that is entirely reliant on that.
 */

 def special_equivalent_hash_function( string ){
   #(even, odd) = partition( string.toCharArray ) where { 2 /? $.i }
   sorted_evens = str( sorta(even), '') 
   sorted_odds = str( sorta(odd), '') 
   sorted_evens + "#" +  sorted_odds // return  
 }

def find_all_special_equivalents( list_of_strings ){
  mset( list_of_strings ) as {
    special_equivalent_hash_function( $.o )
  }
}

res = find_all_special_equivalents( ["abcd", "cbad", "bacd" ] )
println( jstr(res,true) )

Produces :

{
        "ac#bd":[
                "abcd",
                "cbad"
        ],
        "bc#ad":[
                "bacd"
        ]
}

def Node : { val : null, left : null, right : null  }
def Entry : { node : null, x : null, y : null }

def make_entries( entry_list, root , x_pos, y_pos  ){
  entry_list += new ( Entry, root, x_pos, y_pos )
  if ( !empty( root.left ) ) { make_entries( entry_list, root.left, x_pos - 1, y_pos + 1 ) }
  if ( !empty( root.right ) ) { make_entries( entry_list, root.right, x_pos + 1, y_pos + 1 ) }
}

def visit_tree_column_and_row_wise( root ){
   entries = make_entries( list(), root, 0, 0 )
   // sort all entries by x_pos and then y_pos 
   sorta( entry_list ) where {
     left_entry = $.l 
     right_entry = $.r 
     prec = sign( left_entry.x - right_entry.x )
     if ( prec !=0 ) return prec 
     sign( left_entry.y - right_entry.y )
   }
   println( str( entry_list , "," ) as { $.node.val }  )
}

def cheat( some_arr ){
  some_num = 1 + fold( some_arr, 0 ) as {  $.p*10 + $.o }
  ret_arr = list()
  while ( some_num != 0 ){
    ret_arr.add( 0 , some_num % 10 )
    some_num /= 10 
  }
  ret_arr 
}
def non_cheat( some_arr ){
  resp = rfold ( some_arr, { 'carry' : 1, 'result' : list() } ) as {
    r = ( $.o +  $.p.carry )
    $.p.carry = r / 10 
    $.p.result.add ( 0,  r % 10 )
    $.p // return 
  }
  resp.result // return 
}

println( non_cheat( [1,4,3 ] ) )

Imagine you are in the Point Origin with (0,0). Clearly, movement can be only X,Y. Thus, the way to handle it is simply keeping track of the co-ordinates in a set, and check if I have visited the point before or not.
If I did, I am inside a loop.

One more thing. The question is incomplete. It also should give the direction the robot is facing right now, is it N,E,W, S ?

/* quicksort */
def _partition_( arr, l, r ){
  v = arr[r]
  i = l
  j = r - 1 
  while ( true ){
    while ( arr[i] < v ){ i += 1 }
    while ( arr[j] > v ){ j -= 1 }
    break( i >= j )
    t = arr[i] ; arr[i] = arr[j]; arr[j] = t 
  } 
  t = arr[i] ; arr[i] = arr[r]; arr[r] = t
  i // return  
}

def _qs_(arr, l, r ){
  if ( l >= r ) return  
  // now here
  i = _partition_(arr,l,r)
  _qs_(arr,l,i-1)
  _qs_(arr,i+1,r)
}

def quicksort( arr ){
   _qs_(arr, 0, size(arr) - 1)
}

l = list( [0:13] ) as  { random(100) }
println( l )
quicksort(l)
println(l)

/* 
look and say sequence 
en.wikipedia.org/wiki/Look-and-say_sequence
*/

def look_and_say_next( cur_no ){
  digits = str( cur_no ).toCharArray 
  count = 1 
  buf = ""
  past_digit = digits[0]
  for ( inx : [1:size(digits)] ){
    cur_digit = digits[ inx ]
    if ( cur_digit != past_digit ){
       buf += ( str( count ) + str( past_digit) )
       past_digit = cur_digit 
       count = 1  
    } else {
      count += 1 
    }
  }
  buf += ( str( count ) + str( past_digit) )
  int( buf )
}
las = list( 1 )
for ( inx : [0:10 ] ){
  next = look_and_say_next( las[-1] )
  las += next
  println( next )
}

/* LIS */
def lis( input ){
  if ( empty(input) ) return []
  stacks = list(  )
  stacks.add( list( input[0] ) )
  for ( inx : [1:size( input) ]){
    added = false 
    for ( s : stacks ){
      continue ( input[inx] <= s[0] ){ 
        added = true
        s += input[inx] 
        }
    }
    if ( !added ){ stacks.add( list( input[inx] ) ) }
  }
  println( size( stacks) )
  // top elements of the stacks from left to right
  // is the increasing sequence 
  println( str( stacks , ",")  as { $.o[0] } )  
}

a = [10, 22, 9, 33, 21, 50, 41, 60, 80]
lis( a )

/* LIS */
def lis( input ){
  if ( empty(input) ) return []
  stacks = list(  )
  stacks.add( list( input[0] ) )
  for ( inx : [1:size( input) ]){
    added = false 
    for ( s : stacks ){
      continue ( input[inx] <= s[0] ){ 
        added = true
        s += input[inx] 
        }
    }
    if ( !added ){ stacks.add( list( input[inx] ) ) }
  }
  println( size( stacks) )
  // top elements of the stacks from left to right
  // is the increasing sequence 
  println( str( stacks , ",")  as { $.o[0] } )  
}

a = [10, 22, 9, 33, 21, 50, 41, 60, 80]
lis( a )

/* 
Too much convolution in all the answers
Actual, things can be done much faster
*/
def UserActivity : {
   user_id : "user-id" ,
   actions_at : [/* list of timestamps */ ] 
}

def PageActivityForDay : { 
  page_id : "page-id" , 
  day : "YYY-MM-dd" , 
  user_activity : { /* map of User Activities  keyed by user-id */ }
}
// which pages has exactly 100 users in a day?
yo = select(  list_of_page_activities_per_day ) where { size( $.user_activity ) == 100  }
// Which page was visited by only one user exactly 15 times in a day? 
meh = select(  list_of_page_activities_per_day ) where {  
    exists ( $.user_activity ) where { size( $.actions_at ) == 15  }
} 
// Which page was visited by u3 more than 20 times in a day? 
foo = select(  list_of_page_activities_per_day ) where {  
    "u3" @ $.user_activity && size( $.user_activity["u3"].actions_at ) > 20  
}

Nearly optimal:

def merge_list_of_list( list_of_lists ){
    iterators = list( list_of_lists ) as { $.o.iterator }
    final_merge_list = list( )
    added = true 
    while ( added ){
        added = false 
        for ( it : iterators ){
            added = it.hasNext 
            if ( added ){
                final_merge_list += it.next // done 
            }
        }
    }
    final_merge_list // return 
}

If you are using it already, why don't we use arraylist and simply solve the problem there by storing pointers and then reorder the list? :-)

/* 
In the current form, the question is ill posed.
It is as good as asking, given an array, find which indices 
the maximal elements are - and return one at random.
More realistic and proper question would be:

Given a stream of integers, at any given time, if we were to ask 
Give me a random index where the maximal element has appeared.

That would be worth interesting effort.
So we start.
*/
def bucket : { val : num('-inf'), indices : list(-1), cur_index : -1  }

def find_random_index( integer_iterator , bucket ){
   if ( integer_iterator.hasNext ){
      bucket.cur_index += 1 
      next_int = integer_iterator.next()
      if ( next_int > bucket.val ){
          bucket.val = next_int
          bucket.indices = list( bucket.cur_index )
      } else if ( next_int == bucket.val ){
          bucket.indices +=  bucket.cur_index 
      }
   } 
   random( bucket.indices ) // return a random value from collection 
}

We can massively reduce the code by following this :
[ en.wikipedia.org/wiki/Happy_number ] and following that :

All unhappy numbers follow sequences that eventually reach the eight-number cycle

4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 → ...

In C, integers are 2 to 4 bytes long. ASCII characters are 1 byte long. We can pack 4 bytes into one 4bytes integer.

@whoknows, thanks a lot for downvoting my comment.
Now I know every downvote is loosing points by 5! It is a nice game!

I am thinking which sort of english language actually allows :
"three ones **three** fours" translated into "3142" .
Thus...