Tenho algumas sugestões para você.

Extraia um pouco da lógica dos métodos.

Em seu código, quando a consulta é insert e get, você tem dois grandes blocos de código que são semelhantes; você pode extrair para um método e reutilizar o método em ambas as seções.

Eu sugiro um método que retorne um booleano baseado na condição if, então você será capaz de definir as variáveis currValue e currKey como zero.

  long hashMap(String[] queryType, int[][] query) { //[...] switch (currQuery) { //[...] case "insert": if (didWeCopiedValuesToMap(currKey, currValue, values)) { currValue = 0; currKey = 0; } values.put(query[i][0], query[i][1]); break; //[...] } //[...] } private boolean didWeCopiedValuesToMap(Integer currKey, Integer currValue, Map<Integer, Integer> values, HashMap<Integer, Integer> copiedValues) { if (currKey != 0 || currValue != 0) { Set<Integer> keys = values.keySet(); for (Integer key : keys) { copiedValues.put(key + currKey, values.get(key) + currValue); } values.clear(); values.putAll(copiedValues); return true; } return false; }  

Além disso, para verificar a consulta atual currQuery, você pode extrair cada um deles em um método.

 private boolean isGet(String currQuery) { return "get".equals(currQuery); } private boolean isAddToKey(String currQuery) { return "addToKey".equals(currQuery); } private boolean isAddToValue(String currQuery) { return "addToValue".equals(currQuery); } private boolean isInsert(String currQuery) { return "insert".equals(currQuery); }  

Sempre use os primitivos quando possível

Quando você saiba que é impossível obter um valor nulo com o número, tente usar os primitivos; eles ocupam menos memória e são mais rápidos do que a classe wrapper.

Antes

 Integer currKey = 0; Integer currValue = 0;  

Depois

 int currKey = 0; int currValue = 0;  

Tente colocar menos código em switch blocos

Em minha opinião, o código se torna menos legível quando há mais de 3 linhas de códigos em um bloco de switch; Eu sugiro que você o converta em um is-else-if. Essa conversão tornará o código mais curto e legível.

Antes

 if ("insert".equals(currQuery)) { if (didWeCopiedValuesToMap(currKey, currValue, values)) { currValue = 0; currKey = 0; } values.put(query[i][0], query[i][1]); } else if ("addToValue".equals(currQuery)) { currValue += values.isEmpty() ? 0 : query[i][0]; } else if ("addToKey".equals(currQuery)) { currKey += values.isEmpty() ? 0 : query[i][0]; } else if ("get".equals(currQuery)) { if (didWeCopiedValuesToMap(currKey, currValue, values)) { currValue = 0; currKey = 0; } sum += values.get(query[i][0]); }  

  long hashMap(String[] queryType, int[][] query) { long sum = 0; int currKey = 0; int currValue = 0; Map<Integer, Integer> values = new HashMap<>(); for (int i = 0; i < queryType.length; i++) { String currQuery = queryType[i]; if (isInsert(currQuery)) { if (didWeCopiedValuesToMap(currKey, currValue, values)) { currValue = 0; currKey = 0; } values.put(query[i][0], query[i][1]); } else if (isAddToValue(currQuery)) { currValue += values.isEmpty() ? 0 : query[i][0]; } else if (isAddToKey(currQuery)) { currKey += values.isEmpty() ? 0 : query[i][0]; } else if (isGet(currQuery)) { if (didWeCopiedValuesToMap(currKey, currValue, values)) { currValue = 0; currKey = 0; } sum += values.get(query[i][0]); } } return sum; } private boolean isGet(String currQuery) { return "get".equals(currQuery); } private boolean isAddToKey(String currQuery) { return "addToKey".equals(currQuery); } private boolean isAddToValue(String currQuery) { return "addToValue".equals(currQuery); } private boolean isInsert(String currQuery) { return "insert".equals(currQuery); } private boolean didWeCopiedValuesToMap(int currKey, int currValue, Map<Integer, Integer> values) { HashMap<Integer, Integer> copiedValues = new HashMap<>(); if (currKey != 0 || currValue != 0) { Set<Integer> keys = values.keySet(); for (Integer key : keys) { copiedValues.put(key + currKey, values.get(key) + currValue); } values.clear(); values.putAll(copiedValues); return true; } return false; }  

O máximo operação cara é a addToKey x que adiciona x a todas as chaves no mapa, porque substancialmente você tem que criar uma nova chave de entrada, valor + x em seu hashmap e exclua a chave de entrada antiga, valor. Para evitar a necessidade de armazenar em cache a entrada antiga durante a iteração no mapa, você pode distinguir dois casos:

x > 0, então se você tiver iterado sobre um keyset decrescente ordenado não há necessidade de armazenar em cache as entradas antigas

x < 0, mesma abordagem, mas o keyset está em ordem crescente

Como você está usando hashmap, não há ordem de chave garantida, então você precisa de dados estrutura para armazenar as chaves a serem ordenadas, antes de iterar sobre as chaves como a seguir:

private static void addtoKey(Map<Integer, Integer> map, int i) { if (i != 0) { List<Integer> list = new ArrayList<>(map.keySet()); if (i > 0) { Collections.sort(list, Collections.reverseOrder()); } else { Collections.sort(list); } for(int key : list) { map.put(key + i, map.get(key)); map.remove(key); } } } 

Excluí o caso 0 porque map permanece intocado. Outras operações não precisam da ordem das chaves e, conforme já sugerido, seria melhor tentar isolar todas as operações em um método privado.

Comentários

• Obrigado @dariosicily pela resposta. Isn ‘ t classificar todas as vezes ao fazer addToKey operação também é caro ?. Ou posso usar a SortedMap para manter a ordem de inserção decrescente. Por exemplo, SortedMap<Integer, Integer>values = new TreeMap<Integer, Integer>(Collections.reverseOrder());
• @Praveen Você é bem-vindo. Sim, é classificando sempre, mas com ArrayList após a classificação, você procederá de forma linear.Fui condenado por você só poderia usar HashMap; se você pode usar TreeMap em vez de HashMap, você pode usar um iterador e um iterador reverso e iterar sobre seu TreeMap de maneira direta.

Versão modificada de Resposta de Johnbot” sem uma classe extra. Eu acho que a classe extra é um exagero e me distrai do algoritmo, já que tenho que pesquisar muitos códigos (muito boilerplate) para ver o que está acontecendo. Não é essa classe extra que torna o loop de processamento muito mais simples. É o algoritmo.

Outras mudanças:

• keyOffset não está claro para mim em qual direção ele está deslocado, então renomei isso para addedToKey (o mesmo para o valor).
• Ordenou a operação nomes como na especificação do problema, tanto para ficar perto da especificação quanto porque essa ordem faz mais sentido para mim.
• Introduzido args para economizar algumas repetições de código.
• Usado long / Long para tudo, não apenas para a soma. Afinal, adicionar às chaves / valores pode sobrecarregá-los se apenas usarmos int / Integer.

static long hashMap(String[] queryType, int[][] query) { Map<Long, Long> map = new HashMap<>(); long sum = 0, addedToKey = 0, addedToValue = 0; for (int i = 0; i < query.length; i++) { int[] args = query[i]; switch (queryType[i]) { case "insert": map.put(args[0] - addedToKey, args[1] - addedToValue); break; case "get": sum += map.get(args[0] - addedToKey) + addedToValue; break; case "addToKey": addedToKey += args[0]; break; case "addToValue": addedToValue += args[0]; } } return sum; } 

Comentários

• Por que adicionar uniformemente addedToKey ao a chave do valor ‘ s não funciona, mas subtraí-la para as ações insert e get sim funciona?

Que tal apenas armazenar um valor de deslocamento para chaves e valores e construir métodos de wrapper em torno do métodos get / put hashmaps para compensar esse deslocamento.