1,1,2,3,5,8,13....

1,2,3,4,12,13

1110110011101101011000001

1,2,3,4,12,13,5555555555, 99999999999999

java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 1
	at mayton.compression.encoders.fibonacci.FibonacciUtils.encodeF(FibonacciUtils.java:34)
	at mayton.compression.encoders.fibonacci.FibonacciUtilsTest.test(FibonacciUtilsTest.java:12)

    public static String encodeF(long n) {
        int a = 1;
        int b = 1;
        int t;
        int len = 0;
        while (b <= n) {
            t = a + b;
            a = b;
            b = t;
            len++;
        }
        int[] r = new int[len];
        len--;
        while (b != 0) {
            t = b - a;
            b = a;
            a = t;
            if (b <= n) {
                r[len] = 1;
                n -= b;
            } else {
                r[len] = 0;
            }
            len--;
        }
        return Arrays.asList(r).stream().map(x -> String.valueOf(x)).collect(Collectors.joining(""));
    }

@Test
    public void test() {
        //assertEquals("", FibonacciUtils.encodeF(0)); // TODO: Hey what about zero?
        assertEquals("11", FibonacciUtils.encodeF(1));
    }

 @IntRange(from = 0)
    public static long decodeF(@NotNull String s) {
        long a = 1;
        long b = 1;
        long t;
        long sum = 0;
        for(int i = 0; i < s.length(); i++ ) {
            if (s.charAt(i) == '1') {
                sum += b;
            }
            t = a + b;
            a = b;
            b = t;
        }
        return sum;
    }

    @Test
    public void testDecoder() {
        assertEquals(1L, FibonacciUtils.decodeF("1"));
        assertEquals(2L, FibonacciUtils.decodeF("01"));
        assertEquals(3L, FibonacciUtils.decodeF("001"));
        assertEquals(4L, FibonacciUtils.decodeF("101"));
        assertEquals(5L, FibonacciUtils.decodeF("0001"));
        assertEquals(6L, FibonacciUtils.decodeF("1001"));
        assertEquals(7L, FibonacciUtils.decodeF("0101"));
        assertEquals(8L, FibonacciUtils.decodeF("00001"));
        assertEquals(9L, FibonacciUtils.decodeF("10001"));
        assertEquals(10L, FibonacciUtils.decodeF("01001"));
        assertEquals(11L, FibonacciUtils.decodeF("00101"));
        assertEquals(12L, FibonacciUtils.decodeF("10101"));
        assertEquals(13L, FibonacciUtils.decodeF("000001"));
    }

    @IntRange(from = 0)
    public static long decodeF(@NotNull String s) {
        if (s.length() == 0) {
            throw new IllegalArgumentException("Unable to decode empty string!");
        }
        // TODO: Check for maximum possible value for s
        long a = 1;
        long b = 1;
        long t;
        long sum = 0;
        char prevChar = '*';
        for(int i = 0; i < s.length(); i++ ) {
            char c = s.charAt(i);
            if (c == '1') {
                sum += b;
            } else if (c != '0') {
                throw new IllegalArgumentException("Unexpected symbol found " + Character.toString(c));
            }
            t = a + b;
            a = b;
            b = t;
            if (prevChar == '1' && c == '1') {
                throw new IllegalArgumentException("Illegal Fibonaccy notation. Impossible to have '11' sequence in " + s);
            }
            prevChar = c;
        }
        return sum;
    }

    @NotNull
    public static String encodeF(@IntRange(from = 0) long n) {
        int a = 1;
        int b = 1;
        int t;
        int len = 0;
        while (b <= n) {
              t = a + b;
              a = b;
              b = t;
              len++;
        }
        StringBuilder s = new StringBuilder();
        while(len > 0) {
              t = b - a;
              b = a;
              a = t;
              len--;
              if (b <= n) {
                  s.append("1");
                  n -= b;
              } else {
                  s.append("0");
              }
        }
        return StringUtils.reverse(s.toString());
    }