В то время как вложенные петли

Question

Я действительно пытаюсь решить этот алгоритм. Я знаю, что мне нужно делать вложенную петлю, но я не знаю, как ее решить.

В основном вы имеете J^A, K^B, L^C, M^D, где каждый из а, б, в и г является одним из 17

чисел {-5, -4 , -3, -2, -1, -1/2, -1/3, -1/4, 0 или одинаковые числа, но положительные}.

Теперь я собираюсь спросить у пользователя приближенного значения (скажем, и), а затем попросить его

на 4 номера. Мне нужно найти комбинацию этих чисел, которая удовлетворяет уравнению: j^a * k^b * l^c * m^d, где оно находится в пределах 0,01 от u. Например кто-то выбрал

238900 для приближения затем выбрал 14,102329,1936,13 как его 4 значений, то программа

будет проверять каждую комбинацию (ie14^-5 * 102329 * -5 * .. и т.д.) найти ближайший

стоимость до 238900 в пределах 1%. Ответ 14^-5 * 102329^1 * 1936^1/2 * 13^4, который дает

Вы о 239103 (Иногда вы не можете приблизиться к 1% от значения u).

Я просто изо всех сил, чтобы поставить вложенный цикл поэтому он проверяет все возможные комбинации в

то же самое время вместо проверки его по одному. Предположим, что переменные

заявил (а, Ь, с, d, J, K, L, M) аса двойной и Q как INT:

double [] numbers = {-5.0, -4.0, -3.0, -2.0, -1.0, -1.0/2.0, -1.0/3.0, -1.0/4.0, 0.0, 1.0/4.0, 1.0/3.0, 1.0/2.0, 1.0, 2.0, 3.0, 4.0, 5.0} 

while(j - u < k){ 
    while(k - u < l){ 
     while(l - u < m){ 
      while(m < u * 0.01){ 
       Math.pow(m,numbers[q]; 
       q++; 
      } 
      int i = 0; 
      if(i == 0){ 
       q = 0; 
       i++; 
      } 
      Math.pow(l,numbers[q]); 
      q++; 
     } 
     int y = 0; 
     if(y == 0){ 
      q = 0; 
      y++; 
     } 
     Math.pow(k,numbers[q]); 
     q++; 
    } 
    int r = 0; 
    if (r == 0){ 
     q = 0; 
     r++ 
    } 
    Math.pow(j,numbers[q]); 
    q++; 
} 

Answer 1

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

вещи, чтобы смотреть на в вашем коде:

1. u Цель появляется в каждой из ваших петель, например while (j - u < k). Это не имеет смысла, потому что вы пытаетесь вычислить что-то других, чем цель, и сравнить их.

2. Ограничения не упоминают, что индексы должны быть связаны каким-либо образом. Таким образом, упоминание j и k в том же состоянии кажется странным.

3. Звонки в Math.pow вычисляют результат, который впоследствии отбрасывается.

Ниже приведена короткая программа, которая делает то, что вы описали.Он производит следующие выходные данные для тестирования:

14.000000^-5.000000 * 102329.000000^1.000000 * 1936.000000^0.500000 * 13.000000^4.000000 = 239102.786480 (approx 238900.000000) 

Программа приведена ниже. Не стесняйтесь внимательно изучить его и приспособите, если ваша проблема изменится.

public class Indices 
{ 
    public static void main(String[] args) 
    { 
     double j = 14.0; 
     double k = 102329.0; 
     double l = 1936.0; 
     double m = 13.0; 

     double u = 238900.0; 

     double[] r = new Indices().findIndices(j, k, l, m, u); 

     if (r == null) 
      System.out.println("No solution"); 
     else 
      System.out.format("%f^%f * %f^%f * %f^%f * %f^%f = %f (approx %f)%n", j, r[0], k, r[1], l, r[2], m, r[3], r[4], u); 
    } 

    double[] findIndices(double j, double k, double l, double m, double u) 
    { 
     // constants 
     double[] indices = new double[] { -5.0, -4.0, -3.0, -2.0, -1.0, -1.0/2.0, -1.0/3.0, -1.0/4.0, 0.0, 1.0/4.0, 1.0/3.0, 1.0/2.0, 1.0, 2.0, 3.0, 4.0, 5.0 }; 

     double threshold = u * 0.01; // initially 1% of objective value 

     double[] bestIndices = null; // initially unknown 
     double bestDelta = threshold + 1; 

     for (int ai = 0; ai < indices.length; ai++) 
     { 
      double p1 = Math.pow(j, indices[ai]); 

      for (int bi = 0; bi < indices.length; bi++) 
      { 
       double p2 = p1 * Math.pow(k, indices[bi]); 

       for (int ci = 0; ci < indices.length; ci++) 
       { 
        double p3 = p2 * Math.pow(l, indices[ci]); 

        for (int di = 0; di < indices.length; di++) 
        { 
         double p4 = p3 * Math.pow(m, indices[di]); 

         double delta = Math.abs(p4 - u); 
         if (delta < bestDelta) 
         { 
          // record new best 
          bestDelta = delta; 
          bestIndices = new double[] 
           { 
            indices[ai], 
            indices[bi], 
            indices[ci], 
            indices[di], 
            p4 
           }; 
         } 
        } 
       } 
      } 
     } 
     return bestIndices; 
    } 
}