2017-09-05 3 views
0

Interview Frage bei großen Unternehmen: Wie würdest du lösen?Aus beliebigen ganzen Zahlen, finde Paare, die zur erwarteten Summe summieren, geben Array-Ergebnisse als Sammlung zurück

Gegeben eine Liste von beliebigen ganzen Zahlen, finde die Paare von ganzen Zahlen, die zu einer unbekannten erwarteten Summe summieren. Gibt die Array-Ergebnisse in einer Auflistung zurück.

Das ist, was ich hatte aus zu starten:

class NumericalEntityProcessor { 

    List<Integer[]> pairsThatSumToX(List<Integer> input, Integer expectedSum) { 

    } 
} 

Dies sind zwei der möglichen Lösungen - aber ich etwas verpasst ...

class NumericalEntityProcessor { 

    List<Integer[]> pairsThatSumToX(List<Integer> input, Integer expectedSum) { 

    int n = list.size() + 2; 
    int expectedSum = n * (n + 1)/2; 
    int expectedSquaredSum = n * (n + 1) * (2 * n + 1)/6; 
    int sum = 0; 
    int squaredSum = 0; 

    System.out.println("SIZE :::" + list.size()); 

    for (Object num : list) { 
     sum = sum + (int)num; 
     squaredSum = squaredSum + ((int)num * (int)num); 
    } 

    int xplusy = expectedSum - sum; 
    int xsquareplusysquare = expectedSquaredSum - squaredSum; 
    int twoxy = xplusy * xplusy - xsquareplusysquare; 
    int xminusy = (int) Math.sqrt(xsquareplusysquare - twoxy); 
    int x = (xplusy + xminusy)/2; 
    int y = (xplusy - xminusy)/2; 

    return new Integer[] { x, y }; 

    int sum = list.stream().map(Line::getLength).collect(Collectors.summingInt(i->i)); 
    } 
} 

Oder zweite attempt-

public class ArrayExample1 { 

    public static void main(String[] args) { 

     int[] number = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 

     List<Integer> list = convertIntArrayToList(number); 
     System.out.println("list : " + list); 

    } 

    private static List<Integer> convertIntArrayToList(int[] input) { 

     List<Integer> list = new ArrayList<>(); 
     for (int i : input) { 
      list.add(i); 
     } 
     return list; 
     IntSummaryStatistics stats = list.stream() 
        .collect(Collectors.summarizingInt(Line::getLength)); 
     IntSummaryStatistics stats = list.stream().flatMap(a->Arrays.stream(a)) 
        .collect(Collectors.summarizingInt(i->i)); 
     System.out.println(stats.getSum());  
     } 
    } 
} 

Antwort

0
  1. Sortieren Sie die Liste
  2. definieren zwei Zeiger, eine am Kopf beginnend und Erhöhen, die andere am Schwanz beginnen und Erniedrigen
  3. Verschiebens einen Zeiger, während die Summe der referenzierten Zahlen kleiner ist als das Ziel
  4. Nach Iteration beachten, wenn die aktuellen Zahlen insgesamt das Ziel
  5. Wiederholen Sie Schritt 3 mit dem anderen Zeiger
  6. Beenden Iteration, wenn die Gesamt

Durch das Sortieren des Ziel überschreitet, dieser Algorithmus hat Zeitkomplexität O (n log n). Der Iterationsteil ist O (n), der für die Zwecke der Bestimmung der gesamten Zeitkomplexität ignoriert wird, da er eine niedrigere Ordnung hat.

Verwandte Themen