Благодаря много за изчерпателния и най-вече бърз отговор, въпреки абсурдния час, в който пуснах темата. Честно казано веднага го видях и започнах да дебъгвам, но много от синтаксиса в горното решение го виждам за първи път. Не знам дали е заради слабата ми подготовка или е нещо, което съм изпуснал, но е факт че горното по-скоро ме демотивира в началото, отколкото да ме обнадежди :/

Само ми показа колко нищо не знам :D 

Реших да го зарежа, но днес се ядосах как така толкова хора са я решили, а аз не и реших да пробвам по "селският" метод със стрингове без битови операции и написах едно "бързо" решение с "Матрица", което е всичко, но красиво, но дава 100/100 за 0.071 секунди. 

https://pastebin.com/Tz0kAy9w

Идеята е проста.

1. Създава се матрица с размери: Редове - броят на елементите, Колони - 16 на брой (16 битови числа). 

2.  Взимат се елементите от входа и се превръщат в масив от нули и единици, като в началото на всеки масив се добавят нулички, за да се превърне в 16 битов. 

3. Обхожда се матрицата по колони и се броят колко единички има във всяка колона. 

Същият този ред се обхожда отдолу нагоре (или кой както иска) и се запълват толкова реда с единички, колкото е броят, който сме преброили отгоре. Допълва се със нули до най-горният ред на матрицата.

(Поради слабите ми дебъгърски умения си създадох нова матрица, в която си запълвам изхода, това не е нужно може и в оригиналната матрица да се пълнят). 

4. Обновената матрица се обхожда по редове, като всеки ред масива от 0-ли и 1-ци се превръща в нормално число, което се запазва в изходен масив.

5. Със String.join(", ", изходниятМасив) се създава желаният от judge изход и се принтира на конзолата. 

Успех и късмет! 

Колеги ето едно решение и от мен което мисля че е разбираемо и доста кратко.За съжаление не можах да го направя на изпита:)

Ако някой ми каже как да използвам String.join за масиви които не са String щесъм му благодарен

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BitSnow {
    public static void main(String[] args) throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String[] input = reader.readLine().split(", ");

        int[] numbers = new int[input.length];

        for (int i = 0; i < input.length; i++) {
            numbers[i] = Integer.parseInt(input[i]);
        }

        for (int i = numbers.length - 1; i > 0; i--) {
            int firstValue = numbers[i];

            numbers[i] = numbers[i] | numbers[i - 1];
            numbers[i - 1] &= firstValue;

            for (int j = i - 2; j >= 0 ; j--) {
                firstValue = numbers[i];
                numbers[i] = numbers[i] | numbers[j];
                numbers[j] &= firstValue;
            }
        }

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < numbers.length; i++) {
            sb.append(numbers[i]);
            if (i != numbers.length - 1){
                sb.append(", ");
            }
        }
        System.out.println(sb.toString());
    }
}

Интересно решение, наистина, добра работа с побитовите операции! 

Но алгоритъмът отново е неоптимален - вложен цикъл, в който отново обхождаме (част от) елементите.

Не, че има значение за тази задача или при по-малко на брой входни данни, но подобни задачи са добра основа за търсене и намиране на по-ефективни решения и придобиването на умения, за случаите в практиката, когато бързодействието е важно. 

EDIT:

Относно въпросът за String.join, може да погледнеш отговорите ми в тази тема

А това е пример с обикновен int[]:

        int[] numbers = new int[10];
        System.out.println(Arrays.toString(numbers).replaceAll("[\\[\\]]", ""));

Output:

0, 0, 0, 0, 0, 0, 0, 0, 0, 0