Jeg har nogle forslag til dig.

Uddrag noget af logikken til metoder.

I din kode, når forespørgslen er insert og get, har du to store blokke af kode, der er ens; du kan udtrække til en metode og genbruge metoden i begge sektioner.

Jeg foreslår en metode, der returnerer en boolsk baseret på if -tilstanden, så du bliver i stand til at sætte currValue og currKey variablerne til nul.

  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; }  

For at kontrollere den aktuelle forespørgsel currQuery kan du også udpakke hver af dem i en metode.

 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); }  

Brug altid primitiverne, når det er muligt

Når du ved, at det er umuligt at få en nulværdi med tallet, prøv at bruge primitiverne; de tager mindre hukommelse og er hurtigere end indpakningsklassen.

Før

 Integer currKey = 0; Integer currValue = 0;  

Efter

 int currKey = 0; int currValue = 0;  

Prøv at placere mindre kode i switch blokke

Efter min mening bliver koden mindre læselig, når der er mere end 3 linjer med koder i en switchblok; Jeg foreslår, at du konverterer det til en is-else-if. Denne konvertering gør koden kortere og mere læselig.

Før

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

Efter

 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]); }  

Refactored code

  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; }  

Det mest dyr operation er addToKey x, der tilføjer x til alle nøgler på kortet, fordi du i det væsentlige skal oprette en ny indtastningsnøgle, værdi + x i din hashmap og slet den gamle indtastningsnøgle, værdi. For at undgå behovet for at cache den gamle post, mens det gentages over kortet, kan du skelne mellem to tilfælde:

x > 0, så hvis du har iterering over en keyset bestilt faldende, der er ikke behov for at cache de gamle poster

x < 0, samme tilgang men keyset bestilles stigende

Fordi du bruger hashmap, er der ingen garanteret nøgleordre, så du har brug for data struktur for at gemme nøgler, der skal bestilles, før det gentages over nøgler som nedenfor:

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); } } } 

Jeg udelukkede sagen 0 fordi map forbliver uberørt. Andre operationer behøver ikke rækkefølgen af nøglerne, og som allerede antydet kan det være bedre at prøve at isolere hver operation i en privat metode.

Kommentarer

• Tak @dariosicily for svaret. Er ‘ ikke sortering hver gang, mens du foretager addToKey, er det også dyrt. Eller kan jeg bruge a SortedMap for at holde indsættelsesrækkefølgen faldende. Ligesom SortedMap<Integer, Integer>values = new TreeMap<Integer, Integer>(Collections.reverseOrder());
• @Praveen Du er velkommen. Ja det er sortering hver gang, men med ArrayList efter sortering fortsætter du lineært.Jeg blev dømt for, at du kun kunne bruge HashMap; hvis du kan bruge TreeMap i stedet for HashMap kan du bruge en iterator og en omvendt iterator og iterere over din TreeMap på en lige måde.

Ændret version af Johnbots svar uden en ekstra klasse. Jeg synes, at den ekstra klasse er overkill og snarere distraherer fra algoritmen, da jeg er nødt til at søge gennem en masse kode (meget af det kedelplade) for at se, hvad der foregår. Det er ikke den ekstra klasse, der gør behandlingssløjfen meget enklere. Det er algoritmen.

Yderligere ændringer:

• keyOffset er ikke klart for mig i hvilken retning det er forskudt, så jeg omdøbte det til addedToKey (ligeledes for værdi).
• Bestilte operationen navne som i problemspecifikationen, både for at holde mig tæt på specifikationen, og fordi den rækkefølge giver mig mere mening.
• Introduceret args for at gemme nogle gentagelser af kode.
• Brugt long / Long til alt, ikke kun for summen. Når alt kommer til alt kan tilføjelse til nøglerne / værdierne få dem til at løbe over, hvis vi bare bruger 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; } 

Kommentarer

• Hvorfor tilføjer addedToKey ensartet til værdi ‘ s nøgle fungerer ikke, men alligevel trækkes den fra insert og get handlinger arbejde?

Hvad med bare at gemme en forskydningsværdi for nøgler og værdier og opbygge indpakningsmetoder rundt om hashmaps få / sæt metoder til at tage højde for denne forskydning.