Застревание с использованием массивов в java

Question

Я до сих пор новичок в написании кода. Я пытаюсь взять массив, заполненный количеством элементов «x», и вам нужно найти ряд чисел. Параметры принимают массив, минимальное число и максимальное число. Конечный результат должен включать минимум, максимум и числа между ними. Вот вроде примера того, что я говорю:

The starting array:[2, 8, 7, 3, 4] 
Min value: 1 
Max value: 5 
End result: [2, 3, 4] 

Я надеюсь, что это не сбивает с толку, и что я отчасти объяснил это достаточно хорошо, чтобы понять.

код у меня есть это:

public static int[] range(int[] a, int low, int high) 
{ 
    int[] rangeArray = new int[0]; 

    for (int i = low; i <= high; i++) 
    { 
    if (low >= a.length && high <= a.length) 
    { 
     rangeArray[i] = a[i]; 
    } 
    } 

    return rangeArray; 
} 

Answer 1

Ваша первая проблема здесь:

int[] rangeArray = new int[0]; 

Что это делает экземпляр и массив целых чисел, названных rangeArray. Затем он инициализирует его длиной 0. Поэтому все, что добавлено в этот массив, было бы вне пределов. Вы должны инициализировать его до длины результата возврата; В этом случае трудно.

Тогда мы имеем этот блок кода:

for (int i = low; i <= high; i++) //start at the lowest possible number and go to the highest 
{ 
    //check for validity 
} 

Существует немного концепции вопроса здесь; вы делаете итерацию от low до high. Что делать, если low очень низкий (-1 миллион?) И high также очень высокий? Это много думает безрезультатно.

Вместо позволяет цикл через массив вы на самом деле данный:

for (int idx = 0; idx < a.length; idx++) { 
    //Check the value of int, if it is in the desired range, save it. 
} 

Наконец, давайте рассмотрим это:

if (low >= a.length && high <= a.length) 

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

Вместо этого вы хотите «если текущее значение индекса находится между моим низким и высоким, сохраните его».

if (a[idx] >= low && a[idx] <= high) 

Подвижной его мы получаем:

public static int[] range(int[] a, int low, int high) 
{ 
    int[] rangeArray = new int[a.length];//this is the most we will need 
    int numbersFound = 0;//to keep track of result array index  

    for (int idx = 0; idx < a.length; idx++) { 
    { 
    if (a[idx] >= low && a[idx] <= high) 
    { 
     rangeArray[numbersFound++] = a[i]; 
    } 
    } 

    return rangeArray; 
} 

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

Answer 2

Ваша логика неверна.

1. Размер массива присваивается нулю. Как вы будете хранить что-то в этом контейнере, если нет места?
2. Счетчик контуров выключен.
   • Самый простой способ перебрать массив должен начать с самого начала и перейти к концу
   • Массив индексов начинается с нуля
   • массива индексов идти до (длина - 1)
3. Вы должны использовать высокий и низкий уровень теста.

код псевдо

initialize result to the same size as the input 
foreach(item in array) 
{ 
    if(item is in range) { 
     add item to result 
    } 
} 

Ближе к коду

results = new Int[a.length()]; 
int resultsPosition = 0; 
for(int i = 0; i < a.length(); i++) { 
    if(a[i] => low && a[i] <= high) { 
      results[reultsPosition] = a[i]; 
      resultsPosition++; 
    } 
} 

Answer 3

Строка кода int[] rangeArray = new int[0] является инстанцированием массива с длиной 0. Вы не можете ничего сделать с этим массивом!

Поскольку мы знаем начальный массив ([2,8,7,3,4]), мы знаем размер. Итак, давайте изменим длину массива до 5, так как мы добавляем все номеров в этот массив, все элементы будут соответствовать граничным условиям), делая теперь код строки int[] rangeArray = new int[5].

Далее, давайте посмотрим на ваши циклы. Я предполагаю, что путь, который вы хотите предпринять, - это посмотреть на каждое значение и посмотреть, равен ли он >= минимум, а также <= максимум. Итак, мы должны создать второй массив. Назовем это boundaryArray. Давайте также сделаем эту длину 5, так как все элементы могут, по сути, соответствовать условиям. Итак, у нас есть эта строка: int[] boundaryArray = new int[5]. Итак, давайте перейдем к элементам и посмотрим, соответствует ли какое-либо из значений. Давайте посмотрим на этот код:

int minimum = 1; 
int maximum = 5; 
int counter = 0; 
for (int i = 0; i < rangeArray.length; i++) 
{ 
    if (rangeArray[i] >= minimum && rangeArray[i] <= maximum 
    { 
    boundaryArray[counter] = rangeArray[i]; 
    counter++; 
    } 
} 

Сначала мы инициализируем два ints, наш минимум и максимум (1 и 5 соответственно). Затем у нас есть счетчик, чтобы отслеживать, сколько элементов было добавлено. Затем мы используем цикл for, чтобы пройти через наш исходный массив, и каждый раз, когда мы проходим через цикл, мы увеличиваем на 1. Затем, если число, на которое мы смотрим, => min и < = max, мы добавляем число в borderArray и увеличиваем счетчик.

Если вы хотите распечатать список, просто запустите другой цикл цикла от 0 до границыArray.length и распечатайте массив, используя System.out.println(boundayArray[i].toString()), где i является переменной цикла for-loop.

Answer 4

У вас есть две основные проблемы. Во-первых, вы инициализируете свой массив, чтобы иметь в нем 0 элементов, а это значит, что вы ничего не сможете с ним сделать. Линия, которая говорит int[] rangeArray = new int[0] должна быть:

int[] rangeArray = new int[a.length]; 

Это говорит о том, что вы хотите, чтобы ваш новый массив будет столь же большим, как массив, который вы используете в качестве ваших входных значений. Поскольку мы по существу фильтруем массив параметров, он не должен быть больше, поэтому мы не будем иметь ошибки вне диапазона.

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

int counter = 0; //keep track of our spot in our new array 
for(int i : a) //iterate over all the elements of a using int i as our iterator 
{ 
    if(i >= min && i<= max) //check if it is within our allowed range 
    { 
     rangeArray[counter] = i; //add it to the new array 
     counter++;    //increment counter to add to next spot in our new array 
    } 
} 

Answer 5

public static int[] range(int[] a, int low, int high) { 

    Arrays.sort(a); // sort the aray first 

    int length = 0; // number of numbers within the range 

    for (int i = 0; i < a.length; i++) { // check all ints in the array 

     // if the int is in the range, add 1 to the length 
     if (low <= a[i] && high >= a[i]) { 
      length++; 
     } 
    } 

    // determine array size with number of numbers found within the range 
    int[] rangeArray = new int[length]; 

    for (int i = 0; i < a.length; i++) // for every int in the array 
    { 
     if (low <= a[i] && high >= a[i]) // if number is between the range 
     { 
      rangeArray[i] = a[i]; // add it to the range array 
     } 
    } 
    return rangeArray; 
} 

public static void main(String args[]) { 
    int[] array = {2, 8, 7, 3, 4}; 
    int[] rangeArray = range(array, 1, 5); 

    System.out.print(Arrays.toString(rangeArray)); 
} 

---

Выход:

[2, 3, 4] 

Answer 6

Для простоты и удобства чтения я бы не спешить, чтобы генерировать массив и сократить его позже, потому что это кажется довольно расточительным (что, если у меня есть массив из многих ints, но только некоторые из них совпадают?)

Я бы пошел с чем-то вроде:

List<Integer> temp = new List<>(); 
    for(int i = 0 ; i < a.length ; i++){ 
     if (low <= a[i] && high >= a[i]){ 
      temp.add(a[i]); 
     } 
} 
return ArrayUtils.toPrimitive(temp.toArray(new Integer[temp.size()])); 

Это, в значительной степени, потому что я плохо с индексами и поэтому я стараюсь использовать STL вместо массивов при возможных