Сдвигайте элементы в массиве строк, пока выбранная буква не будет иметь индекс 0

Question

У меня есть массив строк типа first_page = {{"U","M","Y","Q","I","A","L","D","P","F","E","G","T","Z","V","W","H","O","X","J","C","R","B","S","N","K"}

Теперь, если я наберу A, он ищет A (в строке будет только один A) и сохраняетсмещая A и каждый элемент на один индекс вверх, элемент под последним индексом смещается к индексу 0, тогда как A не имеет индекса 0.

Что является самым простым способомдобиться этого?У меня проблемы, и мой текущий не очень рабочий код выглядит следующим образом:

   for(int i = 0; i<25;i++) {
        help[i] = first_page[keys_int[0]][i];
                  } 
    for(int i = 0; i<25;i++) {

       if(first_page[keys_int[0]][i].equals(plain_chars[0].toUpperCase())) {
           rememberedi = i;
          int k = i;

            do {

                first_page_copy[keys_int[0]][k+1] = help[k];
                first_page_copy[keys_int[0]][k] = help[k-1];

                k++;
                if(k==24) {
                    first_page_copy[keys_int[0]][k+1] = help[k];
                          first_page_copy[keys_int[0]][0] = help[24];
                          k = 1;
                }

              }while(!first_page[keys_int[0]][0].equals(plain_chars[0]));
            i = 26;
       }
    }    

Массив многомерный, но я работаю только со строкой из выбранного столбца.

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

Answer 1

После перечитывания вашего вопроса и вашего комментария я могу предположить, что вы хотите сместить весь 2D массив строк последовательно.Конечно, я также предположил, что каждая строка в этом случае имеет одинаковый размер.

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

import java.util.Arrays;

public class Answer {

    //testCase - 2D matrix of Strings:
    private static final String[][] testCase =
            {
                    {"A", "B", "C", "D", "E", "F", "G"},
                    {"0", "1", "2", "3", "4", "5", "6"},
                    {"a", "b", "c", "d", "e", "f", "g"}
            };
    private static final String testSearch = "C";


    //find the index of searchString in the array of strings
    private static int findIndexOf(String[] strings, String searchString) {

        for (int index = 0; index < strings.length; index++)
            if (strings[index].equals(searchString))
                return index;  //searchString found at index
        return -1;             //searchString not found
    }

    //shifting one row by one step
    private static String[] shiftToRightByOneStep(String[] strings) {

        String[] result = strings;
        String last = strings[strings.length - 1];
        System.arraycopy(strings, 0, result, 1, strings.length - 1);
        result[0] = last;
        return result;
    }

    //shifting matrix by one step
    private static String[][] shiftMatrixToRightByOneStep(String[][] matrix) {

        String[][] result = matrix;
        for (String[] row : matrix) {
            shiftToRightByOneStep(row);
        }
        return result;
    }

    public static void main(String[] args) {

        String[][] myMatrix = testCase;
        String find = testSearch;
        int howManySteps = myMatrix[0].length - findIndexOf(myMatrix[0], find);
        System.out.println("Shifting matrix by " + howManySteps + " steps");
        System.out.println("Original matrix:\n" + Arrays.deepToString(testCase) + "\n_____________________________________");
        System.out.println("STEPS:");
        for (int step = 0; step < howManySteps; step++)
            System.out.println(Arrays.deepToString(shiftMatrixToRightByOneStep(myMatrix)) + "\n_____________________________________");

        //testing is it original matrix changed
        // (of course it is, b/c I used references instead of copies)
        System.out.println("Original matrix:\n" + Arrays.deepToString(testCase));
    }
}

Вывод:

Смещение матрицы за 5 шагов

Исходная матрица:

[[A, B, C, D, E, F, G], [0, 1, 2, 3, 4, 5, 6], [a, b, c, d, e, f, g]]

---

ШАГИ:

[[G, A, B, C, D, E, F], [6, 0, 1, 2, 3, 4, 5], [г, a, b, c, d, e, f]]

---

[[F, G, A, B, C, D, E], [5, 6, 0, 1, 2, 3, 4], [f, g, a, b, c, d, e]]

---

[[E, F, G, A, B, C, D], [4, 5, 6, 0, 1, 2, 3], [e, f, g, a, b, c, d]]

---

[[D, E, F, G, A, B, C], [3, 4, 5, 6, 0, 1, 2], [d, e, f, g, a, b, c]]

---

[[C, D, E, F, G, A, B], [2, 3, 4, 5, 6, 0, 1], [c, d, e, f, g, a, b]]

---

Исходная матрица:

[[C, D, E, F, G, A, B], [2, 3, 4, 5, 6, 0, 1], [c,д, е, ж, а, б]]

Answer 2

На только сдвиг массива до тех пор, пока первое значение не станет равным заданной строке, вы можете сделать

private static boolean shiftToString(String[] strings, String search) {
    assert strings != null : "null strings";
    assert strings.length > 0 : "empty strings";
    assert search != null : "null search";

    int count = 0;

    while (count++ < strings.length) {
        if (strings[0].equals(search))
            return true;  // or count - 1
        String last = strings[strings.length-1];
        for (int i = strings.length-1; i > 0; i--) {
            strings[i] = strings[i-1];
        }
        strings[0] = last;
    }
    return false;
}

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

^{на самом деле это можно решить, просто скопировав 2 части массива, я знаю, но просто чтобы проверить что-то}

Answer 3

Ну, в вашем коде нет необходимости в циклах.Некоторые дорогостоящие вещи, такие как копирование массивов, реализованы в Java так быстро, как могли.

Одним из них является System.arraycopy(.Зная это, ваша цель - найти индекс нужного String во входном массиве и скопировать массив так, как вам нужно.

Документ API для arraycopy можно найти здесь .

Это был бы самый быстрый способ, которым я могу это сделать:

public class Answer {

    private static int findIndexOf(String[] array, String string) {
        for (int index = 0; index < array.length; index++)
            if (array[index].equals(string))
                return index;
        return -1;
    }

    private static String[] shift(String[] input, String string) {
        String[] result = new String[input.length];
        int offset = findIndexOf(input, string);
        if (offset != -1) {
            System.arraycopy(input, offset, result, 0, input.length - offset);
            System.arraycopy(input, 0, result, input.length - offset, offset);
            return result;
        } else {
            return null;
        }

    }


    public static void main(String[] args) {

        //test
        String[] input =
                {"U", "M", "Y", "Q", "I", "A", "L", "D", "P", "F", "E", "G", "T", "Z", "V", "W", "H", "O", "X", "J", "C", "R", "B", "S", "N", "K"};

        String[] desiredOutput =
                {"A", "L", "D", "P", "F", "E", "G", "T", "Z", "V", "W", "H", "O", "X", "J", "C", "R", "B", "S", "N", "K", "U", "M", "Y", "Q", "I"};

        System.out.println(Arrays.toString(desiredOutput));
        System.out.println(Arrays.toString(shift(input, "A")));

    }
}

Вывод этого кода:

[A, L, D, P, F, E, G, T, Z, V, W, H, O, X, J, C, R, B, S, N, K, U, M, Y, Q, I]
[A, L, D, P, F, E, G, T, Z, V, W, H, O, X, J, C, R, B, S, N, K, U, M, Y, Q, I]

Примечание: Если вам нужен результат в том же массиве, вы можете сделать это так:

input = shift(input, "A");

Answer 4

Как уже говорилось в других ответах, первым шагом является поиск индекса символа, который должен быть смещен в положение 0.

private static int indexOf(char character, char[] characters) {
    for (int i = 0; i < characters.length; i++) {
        if (characters[i] == character) {
            return i;
        }
    }

    return -1;
}

Тогда мы можем использовать классы Arrays и System для быстрого переключения.

protected static void shiftRight(char character, char[] characters) {
    int indexOf = indexOf(character, characters);
    if (indexOf > 0) {
        char[] temp = Arrays.copyOfRange(characters, 0, indexOf);
        System.arraycopy(characters, indexOf, characters, 0, characters.length - indexOf);
        System.arraycopy(temp, 0, characters, characters.length - temp.length, temp.length);
    }
}

Если indexOf меньше 0, character не был найден.Если indexOf равно 0, то characters не требует сдвига, поскольку массив уже имеет желаемое состояние.В обоих случаях сдвиг не происходит.

Применяя это к символам из вопроса:

public static void main(String[] args) throws Exception {
    char character = 'A';
    char[] characters = { 'U', 'M', 'Y', 'Q', 'I', 'A', 'L', 'D', 'P', 'F', 'E', 'G', 'T', 'Z', 'V', 'W', 'H', 'O', 'X', 'J', 'C', 'R', 'B', 'S', 'N', 'K' };

    System.out.println(Arrays.toString(characters));      
    shiftRight(character, characters);
    System.out.println(Arrays.toString(characters));
}

Это печатает:

[U, M, Y, Q, I, A, L, D, P, F, E, G, T, Z, V, W, H, O, X, J, C, R, B, S, N, K] 
[A, L, D, P, F, E, G, T, Z, V, W, H, O, X, J, C, R, B, S, N, K, U, M, Y, Q, I]

---

Обратите внимание:
Вместо массива String, который используется в вопросе, я использую массив char, поскольку каждый String содержит только букву.

Answer 5

Алгоритм сдвига массива довольно прост.Лучше показать это на примере:

1. Исходный массив {'a', 'b', 'c', 'd', 'e'}
2. Вы хотите, чтобы 'c' был первым элементом, поэтому сдвиньте массив влево для offs = 2 позиции
3. шаг 1 : перевернуть все элементы в массиве: {'e', 'd', 'c', 'b', 'a'}
4. шаг 2 : сначала перевернуть 3 элементы arr.length - offs = 5 - 2 = 3: {'c', 'd', 'e', 'b', 'a'}
5. Шаг 3 : отменить последний 2 элементы offs = 2: {'c', 'd', 'e', 'a', 'b'}
6. Здесь вы сдвинули данный массив на 2позиции слева.

Вы можете сделать все это на месте , не создавая временный массив.Это хороший подход, особенно для огромных массивов.

public static void shiftArray(char[] arr, char ch) {
    int pos = indexOf(arr, ch);

    if (pos > 0) {
        for (int i = 0, j = arr.length - 1; i < j; i++, j--)
            swap(arr, i, j);
        for (int i = 0, j = arr.length - pos - 1; i < j; i++, j--)
            swap(arr, i, j);
        for (int i = arr.length - pos, j = arr.length - 1; i < j; i++, j--)
            swap(arr, i, j);
    }
}

Вспомогательные методы:

private static int indexOf(char[] arr, char ch) {
    for (int i = 0; i < arr.length; i++)
        if (arr[i] == ch)
            return i;
    return -1;
}

private static void swap(char[] arr, int i, int j) {
    char ch = arr[i];
    arr[i] = arr[j];
    arr[j] = ch;
}

Answer 6

Звучит как много ненужных смещений.Просто дайте мне знать, если я правильно понял: например: {A, B, C, D, E, F, G} - типы 'E' - результат: {E, F, G, A, B, C, D}

В этом случае: просто сначала найдите индекс 'E', затем вы можете выполнить цикл for (без необходимости делать - while)

for(int i=0; i<source.length; i++){
    target[i] = source[(i+index)%source.length];
}