Настройка массива сложных коэффициентов, избегая ведущих нулей

Question

Я создал класс для комплексных чисел:

public class Complex {
    private double x;   //Real part x of the complex number x+iy.
    private double y;   //Imaginary part y of the complex number x+iy.

     public Complex(double x, double y) {   //Constructor: Initializes x, y.
        this.x=x;
        this.y=y;
    }

    public Complex(double x) { //Real constructor - initialises with a real number.
        this(x, 0.0);
    }

    public Complex() {   //Default constructor; initialiase x and y to zero.
        this(0.0, 0.0);
    }
}

Я хотел бы создать функцию Polynomial, которая бы принимала массив коэффициентов и фильтровала его так, чтобы, например, [ 1,0,0,1,0,0,0,0,0 ...], он вернул бы массив длины 4. Так как нулевые числа, которые остались, бесполезны в полиноме.

Вот как будет выглядеть сложный массив

Complex [] coeff = new Complex [] {
    new Complex(-1.0 ,0.0), new Complex(),
    new Complex() , new Complex(1.0, 0.0)
};

Полином будет определяться как

Polynomial p = new Polynomial(coeff);

Вот формулировка задачи:

Вот как должен выглядеть полином, набирая коэффициенты комплексного массива

Я думал построения алгоритма, который ищет первый ноль нулевой последовательности (до конца массива), а затем удаляет нули.

Также я думал об инвертировании записей массива так, чтобы [0,1,1,0,1,0,0,0] было бы [0,0,0,1,0,1 , 1,0], а затем создание функции, которая начала бы «запись» моего нового массива с первой нетривиальной записи.

Как бы я go создал такую ​​функцию?

Моя попытка для этого:

   int j=0;
        for(int i=coeff.length-1; i>=0; i-=1)
        {    
            if(coeff[i].getReal()== 0 && coeff[i].getImag() == 0 ){
                 j=+1;     
            }
            else {
                break;
            }

        }

        int a = coeff.length-j;    
        this.coeff = new Complex[a];
        for (int i=0;i<this.coeff.length;i+=1){
            this.coeff[i]=coeff[i];     
        }
     }

И, например, я хотел бы напечатать:

Complex a1=new Complex(-3, 1);
        Complex a2=new Complex(2, 0.3);
        Complex a3=new Complex(); 
        Complex b=new Complex(); 
        Complex[] com=new Complex[] {a1,b, a2, a3,b};

и вывод:

(-3.0+1.0i)+ (0.0+0.0i)X^1+(2.0+0.3i)X^2+(0.0+0.0i)X^3

Но предполагается быть:

(-3.0+1.0i)+ (0.0+0.0i)X^1+(2.0+0.3i)X^2

И я попытался добавить «-1» к int a = coeff.length-j; :

int a = coeff.length-j-1;

но потом, если я распечатаю

Complex[] com=new Complex[] {a1,b, a2, a3,b,b,b,b,b,b};

Это даст мне те же результаты (ie сохранение тривиальных коэффициентов).

Как можно ли заставить конструктор не хранить эти тривиальные коэффициенты?

Answer 1

Я думаю, что путь к go здесь - это перебирать массив для конца до начала, как вы и пытались. Проблема с вашим кодом заключается в следующем:

if(coeff[i].getReal()== 0 && coeff[i].getImag() == 0 ){
                 j=+1;     //Here! I think you wanted to do j+=1
            }

Выполняя j = + 1, вы заставляете j всегда иметь значение 1. Таким образом, изменение j = + 1 на j + = 1 исправит это ,

Кроме того, я сделал другой код, если вы хотите проверить его. В конце он делает то же самое, но я думаю, что чище.

public class Polynomial {

    private Complex[] coeff; 

    public Polynomial(Complex[] coeff) {
        this.coeff = cleanCoeff(coeff);
    }

    private Complex[] cleanCoeff(Complex[] coeff) {
        int length = coeff.length;
        Complex complex = null;
        for (int i = coeff.length - 1; i >= 0 ; i--) {
            complex = coeff[i];
            if(complex.getX() == 0 && complex.getY() == 0) {
                length--; 
            }else {
                break;
            }
        }
        return Arrays.copyOf(coeff, length);

    }

    public Complex[] getCoeff() {
        return coeff;
    }
}

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

Answer 2

Это можно сделать относительно легко, используя что-то вроде следующего:

int effective_len(Complex coeff[]) {
  int pos = 0;
  Complex zero();

  for (int i=0; i<coeff.lengh; i++) {
    if (!zero.equals(coeff[i])) {
      pos = i;
    }
  }

  return pos + 1;
}

Для этого вам нужно будет определить метод equals, в котором вы просто проверяете действительные и мнимые компоненты, но это должно получить Вы, где вам нужно go.