Test results - Codility

Code: 14:50:26 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int N) {
        // write your code in Java SE 8
    }
}

Code: 14:50:37 UTC, php, autosave

1 2 3 4 5 6

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    // write your code in PHP7.0
}

Code: 14:50:57 UTC, php, autosave

1 2 3 4 5 6

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   
}

Code: 14:51:08 UTC, php, autosave

1 2 3 4 5 6 7 8

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   
}

Code: 14:51:18 UTC, php, autosave

1 2 3 4 5 6 7 8

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   if ()
}

Code: 14:51:33 UTC, php, autosave

1 2 3 4 5 6 7 8

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   if ($N % 2 == )
}

Code: 14:51:48 UTC, php, autosave

1 2 3 4 5 6 7 8

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   if ($N % 2 == 1)
}

Code: 14:52:03 UTC, php, autosave

1 2 3 4 5 6 7 8

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   if ($N % 2 == 1) 
}

Code: 14:52:33 UTC, php, autosave

1 2 3 4 5 6 7 8 9

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   $a = $N % 2;
   if ($a ==)
}

Code: 14:53:04 UTC, php, autosave

1 2 3 4 5 6 7 8 9

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   $a = $N % 2;
   $b = $
}

Code: 14:53:16 UTC, php, autosave

1 2 3 4 5 6 7 8 9

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   $a = $N % 2;
   $b = $N / 2;
}

Code: 14:53:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   while ()
   $a = $N % 2;
   $b = $N / 2;
}

Code: 14:54:38 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   
   $a = $N % 2;
   $b = $N / 2;
}

Code: 14:54:48 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   
   
   $a = $N % 2;
   $b = $N / 2;
   
}

Code: 14:55:19 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   $a = $N % 2;
   $b = $N / 2;
   
}

Code: 14:55:35 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   $bin_num[] = $N % 2;
   $b = $N / 2;
   
}

Code: 14:56:05 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   $bin_num[] = $N % 2;
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   
}

Code: 14:56:25 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   $bin_num[] = $N % 2;
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   
   
}

Code: 14:56:39 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   $bin_num[] = $N % 2;
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
   
   }
   
}

Code: 14:57:10 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
   }
   
}

Code: 14:57:23 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       
   }
   
}

Code: 14:57:33 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $
   }
   
}

Code: 14:57:44 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $
   }
   
}

Code: 14:58:01 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($bin_num)
   }
   
}

Code: 14:58:12 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   
}

Code: 14:58:55 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   
   
}

Code: 14:59:10 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   
   print_R($bin_num);
   
}

The submission is being evaluated.

Code: 14:59:26 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   
   print_R($bin_num);
   
}

Code: 14:59:40 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = '';
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   
   print_R($bin_num);
   return $result;
}

Code: 15:00:06 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = '';
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   print_R($bin_num);
   return $result;
}

The submission is being evaluated.

Code: 15:00:30 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = '';
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   print_R($bin_num);
   return $result;
}

The submission is being evaluated.

Code: 15:00:52 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = ';
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   print_R($bin_num);
   return $result;
}

Code: 15:00:54 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   print_R($bin_num);
   return $result;
}

The submission is being evaluated.

Code: 15:01:25 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   
   return $result;
}

Code: 15:01:33 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   $b = $N / 2;
   $bin_num[] = $b % 2;
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:02:00 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:02:15 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:03:03 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:03:09 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print $bin_num;
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:03:52 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print implod$bin_num;
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:03:56 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0 ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:04:47 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0  ) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
       if ($N == 1) break;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:04:57 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0  && $N != 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:05:42 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 0  && $N  1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:05:48 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N >  1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

The submission is being evaluated.

Code: 15:06:22 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:06:41 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
   print implode($bin_num);
   print "this is a debug message\n";
   
   return $result;
}

Code: 15:06:51 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
   print implode($bin_num);
   
   return $result;
}

Code: 15:07:21 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = 0 ; $i)
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:07:51 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0)
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:08:22 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $
        }
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:08:35 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:08:52 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:09:11 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:09:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
   print implode($bin_num);
   
   return $result;
}

Code: 15:09:43 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:10:14 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_nu))
   //print implode($bin_num);
   
   return $result;
}

Code: 15:10:43 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:11:03 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:11:14 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:11:25 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:11:35 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:11:45 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
                $idx++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:12:07 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:12:17 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:14:11 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:14:22 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:14:41 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx)
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:14:55 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx == 0)
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:15:05 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx == 0 && )
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:15:25 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1])
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:15:37 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] != 0)
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:16:00 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) $max = $cnt[$idx];
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:16:12 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:16:24 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max )
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:16:34 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max >)
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:16:44 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max > 0)
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $result;
}

Code: 15:17:08 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $result = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        $max = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max > 0)
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:17:19 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max > 0)
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:18:41 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max = 0)
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:18:54 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx];
                    else
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:19:14 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx];
                    else {
                        $max = $max > 
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:19:27 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > 
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:19:46 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:20:18 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:20:36 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:20:40 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:21:26 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:21:37 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:21:56 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num)."\n";
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:22:12 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num)."\n"\\;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:22:22 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:22:23 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
     //   $int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:22:38 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:22:59 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
p
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:23:07 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print implode($bin_num);
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:23:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeo($bin_num);
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:23:33 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num);
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:24:04 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num);
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:24:26 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num).'\n';
    if (sizeof($bin_num) >0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            print $bin_num[$i].'\n';
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:24:42 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num).'\n';
    if (sizeof($bin_num) > 0) {
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            print $bin_num[$i].'\n';
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:24:54 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num).'\n';
    if (sizeof($bin_num) > 0) { print "debug";
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            print $bin_num[$i].'\n';
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:25:13 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."n";
    if (sizeof($bin_num) > 0) { print "debug";
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            print $bin_num[$i].'\n';
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:25:16 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug";
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            print $bin_num[$i].'\n';
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:25:43 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug";
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:25:44 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug";
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:26:14 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug". ;
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:26:23 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num)-1;
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:27:07 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:27:09 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:28:16 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    
        for ($i = sizeof($bin_num)-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:28:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = sizeof($bin_num)
        for ($i = -1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:28:40 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = sizeof($bin_num);
        for ($i = -1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:28:44 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = sizeof($bin_num);
        for ($i = $size-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:30:01 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = c($bin_num);
        for ($i = $size-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:30:05 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = count($bin_num);
        for ($i = $size-1 ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:31:37 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = count($bin_num);
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:31:40 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) { print "debug".sizeof($bin_num);
    $size = count($bin_num)-1;
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:31:51 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}
print sizeof($bin_num)."\n";
    if (sizeof($bin_num) > 0) {
    $size = count($bin_num)-1; print $size;
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:32:18 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = count($bin_num)-1; print $size;
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:32:23 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $size;
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:32:44 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            $re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:32:56 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:32:58 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print $bin_num[$i]."\n";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:33:22 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print "ssss";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        $int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:33:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print "ssss";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    print $int_bin_num;
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:33:36 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i <= 0 ; $i--) {
            print "ssss";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:34:15 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1; print $bin_num[3];
        for ($i = $size ; $i >= 0 ; $i--) {
            print "ssss";
            //$re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:34:31 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:34:35 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:35:30 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++; 
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:35:40 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++; print $idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:35:54 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $idx++; print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:36:15 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                $ print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:36:24 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($idx > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:39:49 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ( > 0 && $cnt[$idx-1] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:40:00 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] > 0) {
                    if ($max == 0) $max = $cnt[$idx-1];
                    else {
                        $max = $max > $cnt[$idx-1] ? $max : $cnt[$idx-1];
                    }
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:40:15 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:40:21 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:40:51 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($$cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:40:59 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] != null && $cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:42:05 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] != null &&$cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:42:15 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if ($cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:42:26 UTC, php, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:43:39 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $ma$cnt[$idx];
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:43:57 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:44:12 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        /print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
                print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

Code: 15:44:17 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        //print implode($re_bin_num);
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
               // print "idx: ".$idx."\n";
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   //print implode($bin_num);
   
   return $max;
}

The submission is being evaluated.

Code: 15:44:36 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
        //$int_bin_num = implode($re_bin_num);
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

Code: 15:44:46 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   $int_bin_num = 0;
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

Code: 15:44:56 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

Code: 15:45:23 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

The submission is being evaluated.

Code: 15:45:38 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
    
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

The submission is being evaluated.

Code: 15:46:38 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
   
   return $max;
}

Code: 15:46:47 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
            $re_bin_num[] = $bin_num[$i];
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:47:00 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_)
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:47:10 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i])
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:47:20 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if
           }
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:47:34 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > )
           }
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:47:53 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else
           }
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:48:05 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           }
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:48:19 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:48:27 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

The submission is being evaluated.

Code: 15:48:53 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           // $re_bin_num[] = $bin_num[$i];
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

The submission is being evaluated.

Code: 15:49:10 UTC, php, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
 /*   
    if (sizeof($re_bin_num) > 0) {
        $idx = 0;
        for ($i = 0 ; $i < sizeof($re_bin_num) ; $i++) {
            if ($re_bin_num[$i]) {
                if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else {
                $cnt[$idx]++;
            }
        }
    }
    */
   
   return $max;
}

Code: 15:49:25 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
   
   return $max;
}

The submission is being evaluated.

Code: 15:49:35 UTC, php, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
   
   return $max;
}

The submission is being evaluated.

Code: 15:49:38 UTC, php, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

// you can write to stdout for debugging purposes, e.g.
// print "this is a debug message\n";

function solution($N) {
    $max = 0;
   $cnt = array();
   $bin_num = array();
   $re_bin_num = array();
   
if ($N > 0) {   
   while ( $N > 1) {
       $bin_num[] = $N % 2;
       $N = $N / 2;
   }
}

    if (sizeof($bin_num) > 0) {
    $size = sizeof($bin_num)-1;
    $idx = 0;
        for ($i = $size ; $i >= 0 ; $i--) {
           if ($bin_num[$i]) {
               if (sizeof($cnt) > 0 && $cnt[$idx] > 0) {
                    $max = $max < $cnt[$idx] ? $cnt[$idx] : $max;
                    $idx++;
                }
                $cnt[$idx] = 0;
            }
            else $cnt[$idx]++;
           
            
        }
    }
   
   return $max;
}

The submission is being evaluated.