Как найти наибольшую дельта в массиве?

Question

Допустим, что я пытаюсь подражать группе цен на акции. Каждая из этих цен на акции находится в массиве. Дельта - разница между каждой из этих цен. Я ищу найти максимальную дельту и вернуть ее в массив. Когда я попытался осуществить это в Eclipse, я получил следующие ошибки для этих двух строк кода:

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

Что я делаю неправильно, возможно?

Answer 1

изменение

int[] largestDelta = {0}; 

в

int largestDelta = stocks[0]; 

или

int largestDelta = 0; 

Также помните об изменении типа возвращаемого значения.

Answer 2

Проблема в том, что вы пытаетесь сравнить int и массив. Это, конечно, ошибка: delta > largestDelta.

Другая ошибка заключается в том, что вы назначаете int массиву. Эта линия также ошибка: largestDelta = stocks[i];

Вы должны изменить самую большую дельту с междунар, например, так:

int largestDelta = 0; 

После этого, вы сможете сравнить delta и largestDelta, а также назначить stocks[i] до largestDelta

Надеюсь, это поможет!

Answer 3

Вы сравниваете int, delta, с int [], largestDelta. Возможно, вы должны просто сказать 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 уже предлагает в период заказа и упаковки.

Например:

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

даст вам результат:

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 в другой класс, который будет держать оригинал значение индекса и добавьте свойство 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