Engineer sollicitatievragen

Glassdoor somehow merges my comment. Correct solution: public static int findMax(int start, int[] digits){ int max = Integer.MIN_VALUE; int id = 0; for (int i=start;i

public static void print(Integer number) { int num = number; int count =Integer.toString(num).length(); int[] digits = new int[count]; int k = count-1; while (num > 0){ digits[k] = num % 10; num = num /10; k--; } for (int i=0;i

private static int swap(int num) { String str = Integer.toString(num); int msd = str.charAt(0) - 48; int swapPos = -1; int maxDiff = -1; for(int counter = 1 ; counter = maxDiff) { maxDiff = diff; swapPos = counter; } } if(swapPos!=-1) { StringBuffer sb = new StringBuffer(str); sb.replace(0, 1, "" + str.charAt(swapPos)); sb.replace(swapPos, swapPos+1, ""+ msd); return Integer.parseInt(sb.toString()); } System.out.println(msd); return num; }

code <=

fun maximize(input: Int): Int { fun Int.pow(exponent: Int): Int = toDouble().pow(exponent).toInt() fun Int.digit(position: Int): Int = (this / 10.pow(position)).rem(10) var working = input var digits = 0 while (working > 0) { working /= 10 digits++ } return generateSequence(1) {it + 1} .takeWhile { it generateSequence(top - 1) {it - 1}.takeWhile { it >= 0 }.map { top to it } } .map { pair -> val top = input.digit(pair.first) val bottom = input.digit(pair.second) input - top * 10.pow(pair.first) - bottom * 10.pow(pair.second) + top * 10.pow(pair.second) + bottom * 10.pow(pair.first) } .max() ?: 0 }

"and put it in a set." to put it in a set you need to implement a way to compare hashs What you would need is 1 - build your hash for given word(O(n)) 2 - check if the word is present in every other hash with same quantity, since you will need to compare with all previous words everytime the complexity is O(nk) where k is the number of distinct words so overal complexity O(nk)

You can either create a custom hash function which is very complex or compress the phrase like: a4b6f.... ordered alphabetically. If the 2 compressed phrases mach, they are anagrams. The complexity would be O(140) to compress each phrase * n phrases which leads to O(n) complexity.

Short python answer: def findPermutationsSort(): res = f([]) perm_dict = {} for s in res: key = ''.join(sorted(s)) if key in perm_dict: print 1 else: perm_dict[key] = 1

import java.util.LinkedList; import java.util.Queue; public class MaximumNumberOfConcurrentUsers { public static void main(String[] args) { int[][] users = {{1,3}, {3,4}, {1,2}, {111111,555555},{1,3}}; quickSort(users, 0, users.length-1); int maxUsers = Integer.MIN_VALUE; Queue usersStack = new LinkedList(); usersStack.add(users[0]); while (!usersStack.isEmpty()) { for(int i=1;i usersStack.peek()[1]) { maxUsers = Math.max(maxUsers, usersStack.size()); usersStack.poll(); } usersStack.add(users[i]); } maxUsers= Math.max(maxUsers, usersStack.size()); break; } System.out.println(maxUsers); } static void quickSort(int [][]users, int start, int end) { if(!(end>start)) return; int pIndex = partitionArr(users, start, end); quickSort(users, start, pIndex-1); quickSort(users, pIndex+1, end); } static int partitionArr(int [][]users, int start, int end) { int pivot = users[end][0]; int pLogout=users[end][1]; int partition= start; for(int i=start; i

Complexity is O(n*logn + 2n) . You can reduce it to O(nlogn +n ) by implemeting own quicksort during assigment. Overall its O(nlogn) time complexity logs = [(1,3), (3,4), (1,2), (111111,555555),(1,3)] sorted_logs = [] for elm in logs: sorted_logs.append((elm[0], 1)) sorted_logs.append((elm[1], -1)) sorted_logs.sort(key=lambda x: x[0]) ans = tmp = 0 for elm in sorted_logs: tmp += elm[1] if tmp > ans: ans = tmp print(ans)

My solution Ruby: arr.group_by { |k| k[:login] }.map{|k,v| [k, v.size]}.to_h.values.max

actualy in prev solution /END/ should be at the end

Files.lines(new File("Log.txt").toPath()).filter(f->f.contains("Error")).collect(Collectors.toList());

The first approach that will work and is time complexity wise efficient is that of hash map. Pseudo code: Sort the given input by userid; Create a hashmap hm; // for c++ you can use unordered_set string previous_userId; for userId, page in sortedinput: if previous_userId is not equal to userId // create output of previous_userId using hm for key, value in hm if value >= 2 add it to userId's output clear hm previous_userId = userId for each valid_prefix_page in page // like for page = /home/account valid_prefix_pages would be /home and /home/account if valid_prefix_page exists in hm then add it to hm with key as valid_suffix_page and value as 1 else increase value (corresponding to valid_prefix_page) by 1 This solution works fine. But we can optimize memory by using trie instead of hashmap and storing value at each "/" node of how many times a prefix has occured.

Hi. How much score do they expect in codility test. I have given the test and out of 4 I got 100 for 2 and zero for 2 although all the test cases ran successfully. My score is below 60. Can I expect a call for further rounds.

Hi. How much score do they expect in codility test. I have given the test and out of 4 I got 100 for 2 and zero for 2 although all the test cases ran successfully. My score is below 60. Can I expect a call for further rounds.

Assume that p3 = p1 + p2 / 2 is a prime number for some consecutive p1, p2. Since p3 is the mean of p1 and p2, p1 < p3 < p2. This is a contradiction to p1 and p2 being consecutive prime numbers. Therefore, the mean of p1 and p2 cannot be a prime number.

Any prime number is an odd number so if p1 is odd the consecutive number p1+1 will be even which contradicts p2 to be prime. Hence its not possible.