如何找到可整除的数？

问题描述

我正在解决 Infytq 学习计划的一个小任务，在那里我遇到了这个障碍。我似乎无法弄清楚我遇到的问题。

给定一个队列。

我必须从给定的队列中形成一个新的整数队列，队列中的数字是均匀的 可以被 1 到 10 的所有数整除。

这是我到目前为止所做的。我目前正在排空队列。

class Queue {
      
    private int front;
    private int rear;
    private int maxSize;
    private int arr[];
      
    Queue(int maxSize) {
        this.front = 0;
        this.rear = -1;
        this.maxSize = maxSize;
        this.arr = new int[this.maxSize];
    }
      
    public boolean isFull() {
        if (rear == maxSize - 1) {
            return true;
        }
        return false;
    }
            
    public boolean enqueue(int data) {
        if (isFull()) {
            return false;
        } else {
            arr[++rear] = data;
            return true;
        }
    }

    public void display() {
        if(isEmpty())
            System.out.println("Queue is empty!");
        else {
            for (int index = front; index <= rear; index++) {
                System.out.println(arr[index]);
            }
        }
    }
            
    public boolean isEmpty() {
        if (front > rear)
            return true;
        return false;
    }
            
    public int dequeue() {
        if (isEmpty()) {
            return Integer.MIN_VALUE;
        } else {
            int data = arr[this.front];
            arr[front++] = Integer.MIN_VALUE;
            return data;
        }
    }

    public int getMaxSize() {
        return maxSize;
    }
}


class Tester {

    public static void main(String[] args) {
            
        Queue queue = new Queue(7);
        queue.enqueue(13983);
        queue.enqueue(10080);
        queue.enqueue(7113);
        queue.enqueue(2520);
        queue.enqueue(2500);

        Queue outputQueue = findEvenlyDivisibleNumbers(queue);
            
        System.out.println("Evenly divisible numbers");
        outputQueue.display();

    }
      
    public static Queue findEvenlyDivisibleNumbers(Queue queue) {
        //Implement your code here and change the return value accordingly
        Queue nqueue = new Queue(queue.getMaxSize());
        boolean flag = true;
        while(!(queue.isEmpty())){
            int val = queue.dequeue();
            for(int i=2;i<=10;i++){
                if(val%i!=0){
                    flag=false;
                    break;
                }
            }
            if(flag){
                nqueue.enqueue(val);
            }
        }
        return nqueue;
    }
}

解决方法

您应该在每次 flag 循环迭代之前将 true 重置为 while（正如您已经建议的那样）。

---

为了避免此类问题，请考虑将内部循环提取到单独的方法中。这将有助于避免嵌套循环破坏混乱：

public static boolean isDivisible(int value) {
    for (int i = 2; i < 10; i++) {
        if (value % i > 0) {
            return false;
        }
    }
    return true;
}

然后在迭代队列时简单地使用它：

public static Queue findEvenlyDivisibleNumbers(Queue queue) {
    Queue nqueue = new Queue(queue.getMaxSize());
    while (!(queue.isEmpty())) {
        int value = queue.dequeue();
        if (isDivisible(value)) {
            nqueue.enqueue(value);
        }
    }
    return nqueue;
}