Test results - Codility

Tasks Details

easy

1. Dominator

Find an index of an array such that its value occurs at more than half of indices in the array.

Task Score

100%

Correctness

100%

Performance

100%

An array A consisting of N integers is given. The dominator of array A is the value that occurs in more than half of the elements of A.

For example, consider array A such that

A[0] = 3 A[1] = 4 A[2] = 3 A[3] = 2 A[4] = 3 A[5] = -1 A[6] = 3 A[7] = 3

The dominator of A is 3 because it occurs in 5 out of 8 elements of A (namely in those with indices 0, 2, 4, 6 and 7) and 5 is more than a half of 8.

Write a function

class Solution { public int solution(int[] A); }

that, given an array A consisting of N integers, returns index of any element of array A in which the dominator of A occurs. The function should return −1 if array A does not have a dominator.

For example, given array A such that

A[0] = 3 A[1] = 4 A[2] = 3 A[3] = 2 A[4] = 3 A[5] = -1 A[6] = 3 A[7] = 3

the function may return 0, 2, 4, 6 or 7, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [0..100,000];

each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

Solution

Programming language used Java 8

Time spent on task 34 minutes

Notes

not defined yet

Code: 13:44:56 UTC, java, autosave

show code in pop-up

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[] A) {
        // write your code in Java SE 8
    }
}

Code: 13:45:18 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7

import java.util.*;

class Solution {
    public int solution(int[] A) {
        
    }
}

Code: 13:46:09 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7

import java.util.*;

class Solution {
    public int solution(int[] A) {
        int
    }
}

Code: 13:46:39 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<> = new TreeSet<>();
        for (int i=0; i<A.length; i++) {
        
        }
    }
}

Code: 13:48:51 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<> = new TreeSet<>();
        for (int i=0; i<A.length; i++) {
        
        }
    }
}

Code: 13:49:05 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> = new TreeMap<>();
        for (int i=0; i<A.length; i++) {
        
        }
    }
}

Code: 13:49:11 UTC, java, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> = new TreeMap<>();
        for (int i=0; i<A.length; i++) {
        
        }
    }
}

Analysis

Compile error

Solution.java:5: error: not a statement
        Map<Integer, List<Integer>> = new TreeMap<>();
           ^
Solution.java:5: error: ';' expected
        Map<Integer, List<Integer>> = new TreeMap<>();
                                   ^
Solution.java:5: error: illegal start of type
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                  ^
Solution.java:5: error: not a statement
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                 ^
Solution.java:5: error: ';' expected
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                   ^
5 errors

Code: 13:49:16 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> = new TreeMap<>();
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:5: error: not a statement
        Map<Integer, List<Integer>> = new TreeMap<>();
           ^
Solution.java:5: error: ';' expected
        Map<Integer, List<Integer>> = new TreeMap<>();
                                   ^
Solution.java:5: error: illegal start of type
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                  ^
Solution.java:5: error: not a statement
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                 ^
Solution.java:5: error: ';' expected
        Map<Integer, List<Integer>> = new TreeMap<>();
                                                   ^
5 errors

Code: 13:49:29 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> = new TreeMap<>();
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:49:38 UTC, java, verify, result: Passed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>();
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.008 s

Code: 13:50:15 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<m1, m2>();
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:50:38 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
          
          m1.  
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:50:55 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
            return m1.size() > m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:6: error: cannot find symbol
            return m1.size() > m2.size();
                     ^
  symbol:   method size()
  location: variable m1 of type Integer
Solution.java:6: error: cannot find symbol
            return m1.size() > m2.size();
                                 ^
  symbol:   method size()
  location: variable m2 of type Integer
2 errors

Code: 13:51:04 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
            return m1.size() - m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:6: error: cannot find symbol
            return m1.size() - m2.size();
                     ^
  symbol:   method size()
  location: variable m1 of type Integer
Solution.java:6: error: cannot find symbol
            return m1.size() - m2.size();
                                 ^
  symbol:   method size()
  location: variable m2 of type Integer
2 errors

Code: 13:51:15 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
            
            return m1.size() - m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:51:20 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
            Systeme.out.println(m1);
            return m1.size() - m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:6: error: package Systeme does not exist
            Systeme.out.println(m1);
                   ^
Solution.java:7: error: cannot find symbol
            return m1.size() - m2.size();
                     ^
  symbol:   method size()
  location: variable m1 of type Integer
Solution.java:7: error: cannot find symbol
            return m1.size() - m2.size();
                                 ^
  symbol:   method size()
  location: variable m2 of type Integer
3 errors

Code: 13:51:28 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((m1, m2) -> {
            System.out.println(m1);
            return m1.size() - m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:7: error: cannot find symbol
            return m1.size() - m2.size();
                     ^
  symbol:   method size()
  location: variable m1 of type Integer
Solution.java:7: error: cannot find symbol
            return m1.size() - m2.size();
                                 ^
  symbol:   method size()
  location: variable m2 of type Integer
2 errors

Code: 13:55:40 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((Listm1, m2) -> {
            System.out.println(m1);
            return m1.size() - m2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:55:56 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((List l1, List l2) -> {
            return l1.size() - l2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Analysis

Compile error

Solution.java:5: error: incompatible types: cannot infer type arguments for TreeMap<>
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((List l1, List l2) -> {
                                                         ^
    reason: inference variable K has incompatible bounds
      equality constraints: Integer
      upper bounds: List,Object
  where K is a type-variable:
    K extends Object declared in class TreeMap
1 error

Code: 13:58:42 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((Integer l1, List l2) -> {
            return l1.size() - l2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:59:00 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((Integer k1, Intger k2) -> {
            return l1.size() - l2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 13:59:11 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> treeMap = new TreeMap<>((Integer k1, Intger k2) -> {
            return this.get.size() - l2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 14:00:53 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> Ma = new TreeMap<>((Integer k1, Intger k2) -> {
            return this.get.size() - l2.size();
        });
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 14:01:03 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        
        for (int i=0; i<A.length; i++) {
        
        }
        
        return 0;
    }
}

Code: 14:01:14 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i=0; i<A.length; i++) {
            map.
        }
        
        return 0;
    }
}

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

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i=0; i<A.length; i++) {
            map.get
        }
        
        return 0;
    }
}

Code: 14:02:46 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<>> map = new HashMap<>();
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>())
        }
        
        return 0;
    }
}

Code: 14:02:59 UTC, java, verify, result: Passed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>()).add(A[i]);
        }
        
        return 0;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 14:03:17 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int maxCount = ;
        
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>()).add(A[i]);
        }
        
        return 0;
    }
}

Code: 14:03:37 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>()).add(A[i]);
        }
        
        return 0;
    }
}

Code: 14:03:59 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>()).add(A[i]);
            if () {
                dominator = ;
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:04:27 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>()).add(A[i]);
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.004 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Exception in thread "main" java.lang.NullPointerException
	at Solution.solution(Solution.java:10)
	at Exec.run(exec.java:46)
	at Exec.main(exec.java:31)

Code: 14:05:04 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.getOrDefault(A[i], new ArrayList<Integer>())
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:05:35 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.contains(A[i])) {
                map.
            }
            map.getOrDefault(A[i], new ArrayList<Integer>())
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:05:48 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.contains(A[i])) {
                map.put(A[i], new ArrayList<Integer>()));
            }
            
            map.getOrDefault(A[i], new ArrayList<Integer>())
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:06:14 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.contains(A[i])) {
                map.put(A[i], new ArrayList<Integer>()));
            }
            
            map.get(A[i]).add(A[i]Integer>())
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:06:23 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.contains(A[i])) {
                map.put(A[i], new ArrayList<Integer>()));
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Analysis

Compile error

Solution.java:10: error: ';' expected
                map.put(A[i], new ArrayList<Integer>()));
                                                       ^
1 error

Code: 14:06:31 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.contains(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Analysis

Compile error

Solution.java:9: error: cannot find symbol
            if (!map.contains(A[i])) {
                    ^
  symbol:   method contains(int)
  location: variable map of type Map<Integer,List<Integer>>
1 error

Code: 14:06:53 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.containsKeu(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Code: 14:06:57 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.containsKey(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return dominator;
    }
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 3, but element is not a dominator, value 2 has only 1 occurences (n=8)

0.004 s

WRONG ANSWER, got 3, but element is not a dominator, value 2 has only 1 occurences (n=8)

Code: 14:07:34 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.containsKey(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.dominator;
    }
}

Code: 14:07:44 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.containsKey(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:10:05 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Int>> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            if (!map.containsKey(A[i])) {
                map.put(A[i], new ArrayList<Integer>());
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:10:16 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            
            
            }
            
            map.get(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:10:34 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
    
            
            map.push(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:11:52 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            
            map.push(A[i]).add(A[i]);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:12:05 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], i);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

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

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], );
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:12:40 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]++);
            
            if (map.get(A[i]).size() > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:12:51 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]++);
            
            if (map.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Analysis

Compile error

Solution.java:9: error: ')' expected
            map.push(A[i], map.get(A[i]++);
                                          ^
1 error

Code: 14:13:00 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]++));
            
            if (map.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Analysis

Compile error

Solution.java:5: error: incompatible types: cannot infer type arguments for HashSet<>
        Map<Integer, Integer> map = new HashSet<>();
                                               ^
    reason: no instance(s) of type variable(s) E exist so that HashSet<E> conforms to Map<Integer,Integer>
  where E is a type-variable:
    E extends Object declared in class HashSet
Solution.java:9: error: cannot find symbol
            map.push(A[i], map.get(A[i]++));
               ^
  symbol:   method push(int,Integer)
  location: variable map of type Map<Integer,Integer>
2 errors

Code: 14:13:08 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i])++);
            
            if (map.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Analysis

Compile error

Solution.java:5: error: incompatible types: cannot infer type arguments for HashSet<>
        Map<Integer, Integer> map = new HashSet<>();
                                               ^
    reason: no instance(s) of type variable(s) E exist so that HashSet<E> conforms to Map<Integer,Integer>
  where E is a type-variable:
    E extends Object declared in class HashSet
Solution.java:9: error: unexpected type
            map.push(A[i], map.get(A[i])++);
                                  ^
  required: variable
  found:    value
2 errors

Code: 14:13:12 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]) +);
            
            if (map.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:13:14 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]) + 1);
            
            if (map.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Analysis

Compile error

Solution.java:5: error: incompatible types: cannot infer type arguments for HashSet<>
        Map<Integer, Integer> map = new HashSet<>();
                                               ^
    reason: no instance(s) of type variable(s) E exist so that HashSet<E> conforms to Map<Integer,Integer>
  where E is a type-variable:
    E extends Object declared in class HashSet
Solution.java:9: error: cannot find symbol
            map.push(A[i], map.get(A[i]) + 1);
               ^
  symbol:   method push(int,int)
  location: variable map of type Map<Integer,Integer>
2 errors

Code: 14:13:36 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<Integer, Integer> set = new HashSet<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            
            if (set.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:15:56 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<Integer, Integer> set = new HashSet<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            
            if (set.get(A[i]) > A.length / 2) {
                dominator = A[i];
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Code: 14:16:12 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<Integer, Integer> set = new HashSet<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            if (set.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return map.get(dominator);
    }
}

Analysis

Compile error

Solution.java:5: error: wrong number of type arguments; required 1
        Set<Integer, Integer> set = new HashSet<>();
           ^
Solution.java:16: error: cannot find symbol
        return map.get(dominator);
                       ^
  symbol:   variable dominator
  location: class Solution
Solution.java:16: error: cannot find symbol
        return map.get(dominator);
               ^
  symbol:   variable map
  location: class Solution
3 errors

Code: 14:16:25 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<Integer, Integer> set = new HashSet<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            if (set.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Analysis

Compile error

Solution.java:5: error: wrong number of type arguments; required 1
        Set<Integer, Integer> set = new HashSet<>();
           ^
1 error

Code: 14:16:38 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        <Integer, Integer> set = new HashSet<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            if (set.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Code: 14:16:49 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> set = new HashSet<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            set.push(A[i], set.get(A[i]) + 1);
            if (set.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Code: 14:17:19 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            map.push(A[i], map.get(A[i]) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Analysis

Compile error

Solution.java:9: error: cannot find symbol
            map.push(A[i], map.get(A[i]) + 1);
               ^
  symbol:   method push(int,int)
  location: variable map of type Map<Integer,Integer>
1 error

Code: 14:17:32 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.get(A[i]) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Code: 14:17:33 UTC, java, verify, result: Failed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.get(A[i]) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.004 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Exception in thread "main" java.lang.NullPointerException
	at Solution.solution(Solution.java:9)
	at Exec.run(exec.java:46)
	at Exec.main(exec.java:31)

Code: 14:17:54 UTC, java, verify, result: Passed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominatorIndex = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 14:18:04 UTC, java, autosave

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int domi = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominatorIndex = i;
                break;
            }
        }
        
        return dominatorIndex;
    }
}

Code: 14:18:10 UTC, java, verify, result: Passed

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominator = i;
                break;
            }
        }
        
        return dominator;
    }
}

Analysis

expand all Example tests

▶

example
example test

✔

0.004 s

Code: 14:18:17 UTC, java, final, score: 100

show code in pop-up

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

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Map<Integer, Integer> map = new HashMap<>();
        int dominator = -1;
        
        for (int i=0; i<A.length; i++) {
            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
            if (map.get(A[i]) > A.length / 2) {
                dominator = i;
                break;
            }
        }
        
        return dominator;
    }
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N)

expand all Example tests

▶

example
example test

✔

0.008 s

expand all Correctness tests

▶

small_nondominator
all different and all the same elements

✔

0.008 s

▶

small_half_positions
half elements the same, and half + 1 elements the same

✔

0.004 s

▶

small
small test

✔

0.004 s

▶

small_pyramid
decreasing and plateau, small

✔

0.004 s

▶

extreme_empty_and_single_item
empty and single element arrays

✔

0.004 s

▶

extreme_half1
array with exactly N/2 values 1, N even + [0,0,1,1,1]

✔

0.004 s

▶

extreme_half2
array with exactly floor(N/2) values 1, N odd + [0,0,1,1,1]

✔

0.004 s

▶

extreme_half3
array with exactly ceil(N/2) values 1 + [0,0,1,1,1]

✔

0.004 s

expand all Performance tests

▶

medium_pyramid
decreasing and plateau, medium

✔

0.064 s

▶

large_pyramid
decreasing and plateau, large

✔

0.600 s

▶

medium_random
random test with dominator, N = 10,000

✔

0.060 s

▶

large_random
random test with dominator, N = 100,000

✔

0.564 s