Domino Java zadanie

0

Cześć, robiłem zadanie i zaciąłem sie w pewnym momencie czy mółby ktoś z was pomóc rozwiązać problem, zadanie polega przestawieniu kostek domina w zaleznosci od ilosci iteracji
| - kostka stoi
\ - kostka upada w lewo
/ - kostka upada w prawo
Przykładowo przy ciągu wejściowym: ||//||||/|
Zastosowanie jednej iteracji powinno dać wynik: ||///\||/|
POniżej załączam moj kod, proszę o pomoc :

String input = "||//||\\||/\\|";
        StringBuilder output = new StringBuilder(input);
        StringBuilder cos = new StringBuilder();

        Scanner scanner = new Scanner(System.in);
        int iterations = 1; //=scanner.nextInt();
        for (int i = 0; i < iterations; i++) {
            for (int j = 2; j < output.length(); j++) {
                char prevprev = output.charAt(j - 2);
                char prev = output.charAt(j - 1);
                char act = output.charAt(j);
                if (prevprev == '|') {
                    if (prev == '|' || prev == '/') {
                        output.replace(j - 2, j - 1, "|");
                        cos.append("|");
                    } else {
                        output.replace(j - 2, j - 1, "\\");
                        cos.append("\\");
                    }
                } else if (prevprev == '/') {
                    if (act == '|') {
                        if (prev == '|' || prev == '/') {
                            output.replace(j - 2, j - 1, "/");
                            cos.append("/");
                        }
                    } else if (act == '\\') {
                        if (prev == '|') {
                            output.replace(j - 2, j - 1, "/");
                            cos.append("/");
                        }
                    }
                } else {
                    output.replace(j - 2, j-1, "\\");
                    cos.append("\\");
                }
            }

        }
        System.out.println(output.toString());
    }
0

Problem polega na ... ?
Niestety, jeśli chciałeś powiedzieć "no to uruchomcie kod", to nie nadaje się do uruchomienia, jest niekompletny

Zmień te wielokrotnie powtarzane stałe znakowe na takie coś w klasie (poza metodami)

final static char LEFT='\\'; 

itd

mam wątpliwości, czy pod output jest optymalna struktura danych, być mzoe lepiej by się klepało

char[] output = new char[ xxxx.length() ];

a zmiennej cos to nie rozumiem.

0

Problem polega na tym że po uruchomieniu programu dostaje wynik niezgodny z oczekiwanym, mój wynik: ||//|\||/| Zastosowanie jednej iteracji powinno dać wynik: ||///||/|

0

@777roman:

Pora nauczyć się używania debugera, ustawić breakpointy, przekrokować fragmenty itd.... nikt inny tego nie zrobi.
jakiego IDE używasz?

0
777roman napisał(a):

zadanie polega przestawieniu kostek domina w zaleznosci od ilosci iteracji

Na czym polega zależność?

Przykładowo przy ciągu wejściowym: ||//||||/|
Zastosowanie jednej iteracji powinno dać wynik: ||///\||/|

Dlaczego?

Poza tym, jak zauważył już @AnyKtokolwiek - nie opisałeś też nawet, na czym polega problem.

0

IDEA co do debugera potrafie wstawić breakpointy przejść przez pętle krok po kroku tlyko nie jestem w stanie poprawnie ustawić algorymiki aby przesunęło mi pionowy klocek

1

Napisz oryginalny tekst zadania. W jaki sposób ciąg kostek ma być przekształcany?

Jako przykład podajesz:

In:  ||//||||/|
Out: ||///\||/|

Potem piszesz Kostka pochylona w lewą stronę możę przechylić kostkę znajdującą się po jej lewej stronie w lewo gdy ta jest w pozycji stojącej i analogicznie co do storny prawej, z tego można zrozumieć, że przy jednej iteracji powinno być takie przekształcenie:

In:  ||//||||/|
Out: ||///|||//

Na podstawie czego piszesz, że w podanym przez Ciebie ciągu wejściowym, kostka 6 od lewej ma się pochylić w lewo, skoro obie sąsiednie stoją?

0

| - kostka domina stoi nienaruszona
/ - kostka domina przewraca się w prawą stronę
\ - kostka domina przewraca się w lewą stronę Twoim zadaniem jest napisanie algorytmu wyznaczającego nowy literał zawierający powyższe znaki po X iteracjach, podczas których zachodzą zmiany w sąsiednich kostkach, X jest parametrem wejściowym. Przykładowo dla ciągu wejściowego:

||//||\||/\|

Zastosowanie 1 iteracji algorytmu powinno dać wynik:

||///\\||/\|
0

W ogóle, żeby dobrze działało, to musisz mieć dwie zmienne tekstowe i traktować to jako liniowy automat komórkowy. Zastosowałeś jedną zmienną, przez co przy analizie następnego znaku informacje są fałszowane.

Jak słusznie zauważyłeś, aby ustalić, jaki ma być znak, to analizujesz trzy kolejne znaki, nazwane jako prevprev, prev i act. Ustalając, jaki jest znak w danym miejscu, należy sprawdzać znak bieżący i po jednym sąsiedzie po lewej i po prawej stronie. W Twoim przypadku dostrzegam, że sprawdzasz znak bieżący i dwa sąsiednie po prawej stronie, wtedy to da się na jednej zmiennej tekstowej, ale implementacja prawidłowego przekształcenia nie będzie prawidłowa. Sąsiad przed pierwszym i za ostatnim znakiem powinien być traktowany jako znak |.

O ile dobrze rozumiem treść, to powinny być takie przekształcenia:

In      Out
\|/     |
/|\     |
|||     |
\||     |
||/     |
_\_     \
_/_     /
/||     /
/|/     /
||\     \
\|\     \

Znak _ oznacza dowolny znak na wejściu.

0

Dzięki tabelka bardzo pomocna ,po dodaniu do kodu jako pierwszego i ostatniego sąsiada wartości przez Ciebie zasugerowanych czyli 'I' program rzeczywiście działa poprawnie w przypadku usunięcia skrajnych sąsiadów jednak się rozkłada, jest jakaś opcja zaradzenia temu, aby bez dodawania skrajnych pozycji prorgam ten działał prawidłowo?
Aktualny kod:

    private static final char LEFT = '\\';
    private static final char RIGHT = '/';
    private static final char STAND = '|';

    public static void main(String[] args) {
        String input = "|||//||\\||/\\||";
        StringBuilder output = new StringBuilder();


        Scanner scanner = new Scanner(System.in);
        int iterations = 1; //=scanner.nextInt();
        for (int i = 0; i < iterations; i++) {
            for (int j = 1; j < input.length() - 1; j++) {
                char prev = input.charAt(j - 1);
                char act = input.charAt(j);
                char next = input.charAt(j + 1);
                if (act == STAND) {
                    if ((prev == LEFT && next == RIGHT)
                            || (prev == RIGHT && next == LEFT)
                            || (prev == STAND && next == STAND)
                            || (prev == LEFT && next == STAND)
                            || (prev == STAND && next == RIGHT)) {
                        output.append("|");
                    } else if (prev == RIGHT && next == STAND) {
                        output.append("/");
                    } else if (prev == RIGHT && next == RIGHT) {
                        output.append("/");
                    } else if (prev == STAND && next == LEFT) {
                        output.append("\\");
                    } else if (prev == LEFT && next == LEFT) {
                        output.append("\\");
                    }
                } else if (act == RIGHT) {
                    output.append("/");
                } else {
                    output.append("\\");
                }
            }

        }
        System.out.println(output.toString());
    }
1

Są dwa wyjścia:

  1. Domyślam się, że stały ciąg źródłowy wpisałeś do testów, a docelowo będzie pobierać od użytkownika. Po prostu po pobraniu ciągu dopisujesz po jednym znaku | z obu stron i przetwarzasz znaki od drugiego do przedostatniego. Zanim wypiszesz ciąg docelowy, obcinasz pierwszy i ostatni znak.
  2. Fragment pobierający 3 znaki do analizy wystarczy przerobić na takie coś:
                char prev = (j > 0) ? input.charAt(j - 1) : '|';
                char act = input.charAt(j);
                char next = (j < (input.length() - 1)) ? input.charAt(j + 1) : '|';

1 użytkowników online, w tym zalogowanych: 0, gości: 1