배열에서 가장 큰 델타를 찾는 방법은 무엇입니까?

Question

나는 주가의 그룹을 에뮬레이트하려고 애 쓰고있다. 이 주가는 각각 배열로되어 있습니다. 델타는 각 가격의 차이입니다. 최대 델타 찾기를 찾고 배열로 리턴합니다. 이클립스에서이를 구현하려고 할 때, 나는 코드의 두 라인에 대한 다음과 같은 오류가있어 :

if (delta > largestDelta) { 
    largestDelta = stocks[i]; 
} 

""운영자를> 인수 유형 (들) INT, INT []에 정의되어 있지 않습니다 " 유형 불일치 :

public class Stocks { 
    static int[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 }; 

    // delta = sell point - buy point 
    // find largest delta 

    public static int[] findMaximumProfit(int[] stocks) { 

     int delta = 0; 
     int[] largestDelta = {0}; 
     for (int i=0; i < stocks.length; i++) { 
      delta = stocks[i+1] - stocks[i]; 
      if (delta > largestDelta) { 
       largestDelta = stocks[i]; 
      } 
     } 
     return largestDelta; 
    } 
} 

나는 아마도 잘못하고 있어요 무엇 : INT로 변환 할 수없는 것은 [] "

가 여기 내 전체 코드의 int로?

Answer 1

변화

int[] largestDelta = {0}; 

int largestDelta = stocks[0]; 

또는

int largestDelta = 0; 

에 또한 반환 형식 변경에 대한 기억.

Answer 2

문제는 int와 배열을 비교하려고하는 것입니다. 이것은 물론 오류입니다 : delta > largestDelta.

다른 오류는 int에 배열을 지정한다는 것입니다. 지정도

int largestDelta = 0; 

이 일을 한 후에는 delta 및 largestDelta을 비교할 수 있습니다, 그리고 : 당신은 int로 가장 큰 델타 변경과 같이해야 largestDelta = stocks[i];

:이 줄은 오류가 stocks[i] to largestDelta

희망이 있습니다.

Answer 3

int [], largestDelta 인 int와 delta을 비교합니다. 아마도 int largestDelta = 0;이라고 말하고 public static int findMaximumProfit(int[] stocks)을 정의해야할까요? 가능한 모든 주식 사이의 모든 델타의 최대를 찾고 있다면, 당신은 이중 루프를 수행해야합니다

for (int i=0; i < stocks.length; i++) { 
    for (int j=i+1; j < stocks.length; j++) { 
     delta = stocks[j] - stocks[i]; 
     if (delta > largestDelta) { 
      largestDelta[0] = i; 
      largestDelta[1] = j;  
     } 
    } 
} 

Answer 4

이 델타 추적하는 데 고려를, 그래서 당신은 그들이 있었다 선택적으로 일부 작업을 수행 할 수 있습니다 얼마나 알고 나중에 추가 조작. 또한 주문 및 포장 기간에 이미 Java가 제공하는 것을 사용하십시오.

예를 들어

: 주문은 원래 배열에 중요한 경우

Best amount of profit is 
Profit : 5, delta=4 
Profit : 10, delta=3 
Profit : 1, delta=1 
Profit : 6, delta=1 
Profit : 7, delta=1 
Profit : 6, delta=0 
Profit : 7, delta=0 
Profit : 10, delta=0 

, 원본 유지됩니다 다른 클래스에 sortedStocks을 포장 할 수 있습니다 :

import java.util.*; 

class ProfitDelta implements Comparable<ProfitDelta> { 
    private int delta; 
    private int profit; 
    public ProfitDelta(int delta, int profit) { this.delta = delta; this.profit = profit; } 
    public int getDelta() { return delta; } 
    public int getProfit() { return profit; } 
    public int compareTo(ProfitDelta o) { 
     return o.delta - this.delta;  
    } 
} 

class Main { 
    static Integer[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 }; 

    public static void main(String[] args) { 
     System.out.println("Best amount of profit is "); 
     for (ProfitDelta profit : getBestProfitAmount(stocks)) { 
      System.out.println("Profit : " + profit.getProfit() + ", delta=" + profit.getDelta()); 
     } 
    } 

    public static ProfitDelta[] getBestProfitAmount(Integer[] stocks) { 
     ProfitDelta[] profits = new ProfitDelta[stocks.length]; 

     List<Integer> sortedStocks = Arrays.asList(stocks); 
     List<ProfitDelta> sortedProfits = Arrays.asList(profits); 
     Collections.sort(sortedStocks); 

     int delta = 0; 
     int stockValue; 
     for (int i = 0; i < stocks.length; i++) { 
      stockValue = sortedStocks.get(i); 
      delta = stockValue - delta; 
      sortedProfits.set(i, new ProfitDelta(delta, stockValue)); 

      delta = stockValue; 
     } 
     Collections.sort(sortedProfits); 
     return profits; 
    } 
} 

는 당신에게 출력을 줄 것이다 인덱스 값을 입력하고 originalIndex을 ProfitDelta에 추가하십시오.또는이 같은 이벤트 단순한는 :

import java.util.*; 

class ProfitDelta implements Comparable<ProfitDelta> { 
    private int originalIndex = 0; 
    private int delta = 0; 
    private int profit; 
    public ProfitDelta(int index, int profit) { this.originalIndex = index; this.profit = profit; } 
    public int getOriginalIndex() { return originalIndex; } 
    public int getDelta() { return delta; } 
    public void setDelta(int delta) { this.delta = delta; } 
    public int getProfit() { return profit; } 
    public int compareTo(ProfitDelta o) { return o.delta - this.delta; } 
} 

class ProfitComparator implements Comparator<ProfitDelta> { 
    @Override public int compare(ProfitDelta o1, ProfitDelta o2) { 
     return o1.getProfit() - o2.getProfit(); 
    } 
} 

class Main { 
    static int[] stocks = { 1, 7, 6, 7, 10, 5, 6, 10 }; 

    public static void main(String[] args) { 
     System.out.println("Best amount of profit is "); 
     for (ProfitDelta profit : getBestProfitAmount(stocks)) { 
      System.out.println("Profit : " + profit.getProfit() + 
       ", delta=" + profit.getDelta() + 
       ", originalIndex=" + profit.getOriginalIndex()); 
     } 
    } 

    public static ProfitDelta[] getBestProfitAmount(int[] stocks) { 
     ProfitDelta[] profits = new ProfitDelta[stocks.length]; 
     int delta = 0; 

     List<ProfitDelta> sortedProfits = Arrays.asList(profits); 
     for (int i = 0; i < stocks.length; i++) { 
      sortedProfits.set(i, new ProfitDelta(i, stocks[i])); 
     } 
     Collections.sort(sortedProfits, new ProfitComparator()); 

     for (ProfitDelta profit : profits) { 
      profit.setDelta(profit.getProfit() - delta); 
      delta = profit.getProfit(); 
     } 
     Collections.sort(sortedProfits); 

     return profits; 
    } 
} 

출력한다 :

Best amount of profit is 
Profit : 5, delta=4, originalIndex=5 
Profit : 10, delta=3, originalIndex=4 
Profit : 1, delta=1, originalIndex=0 
Profit : 6, delta=1, originalIndex=2 
Profit : 7, delta=1, originalIndex=1 
Profit : 6, delta=0, originalIndex=6 
Profit : 7, delta=0, originalIndex=3 
Profit : 10, delta=0, originalIndex=7