Смотритель: hubert

task30.task3010 не проходит тестирование, прошу помочь

Добрый день. прошу помощи в решении задания task30.task3010.

Минимальное допустимое основание системы счисления
В метод main первым аргументом приходит строка, которая содержит последовательность символов (Все символы в строке имеют коды в таблице ASCII от 32 до 127 включительно). Длина строки не превышает 255 символов. Нужно реализовать программу, которая по входящей строке определит, является ли содержимое строки записью числа в системе счисления с основанием не больше 36 включительно. Если является — нужно вывести минимальное основание системы счисления, в которой это число может существовать. Если не является — необходимо вывести «incorrect».
В системах счисления с основанием большим 10 в качестве цифр используются латинские буквы. К примеру, числу 35 в десятичной системе соответствует число «Z» в системе с основанием 36. Так как рассматриваем позиционные системы счисления — минимальное основание, которое должна выводить программа, это 2.
Если возникают любые исключения — перехватывай их и не выводи стек-трейс.

Пример1:
Вход:
00
Ожидаемый вывод:
2

Пример2:
Вход:
12AS08z
Ожидаемый вывод:
36

Пример3:
Вход:
12AS08Z/
Ожидаемый вывод:
incorrect

Требования:
1. Если возникло любое исключение — необходимо перехватить его и не выводить стек-трейс.
2. Если входящая строка содержит что-либо, кроме латинских букв и цифр — необходимо вывести «incorrect».
3. Если входящая строка корректна — необходимо вывести основание системы счисления.
4. Минимальное основание, которое выводит программа должно равняться 2.
5. Вывод программы должен соответствовать условию.

При проверке на сервере проходит всё кроме



public class Solution {
    public static void main(String[] args) {
        try {
            String num = args[0];

            if (!num.matches("\\w+")){
                System.out.println("incorrect");
                return;
            }

            for(int i = 2;i < 37;i++){
                try {
                    Long.parseLong(num, i);
                    System.out.println(i);
                    break;
                } catch (NumberFormatException e) {
                    /*NOP*/
                }
            }
        } catch (Exception e) {
            /*NOP*/
        }
    }
}

task30.task3002 не проходит тестирование РЕШЕНА

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

Осваиваем методы класса Integer
Используя метод Integer.parseInt(String, int) реализуй логику метода convertToDecimalSystem, который должен переводить переданную строку в десятичное число и возвращать его в виде строки.

Требования:
1. Метод convertToDecimalSystem (String), возвращающий String, должен существовать.
2. Метод convertToDecimalSystem (String), возвращающий String, должен иметь модификаторы доступа: public, static.
3. Метод convertToDecimalSystem (String), возвращающий String, должен переводить переданную строку в десятичное число и возвращать его в виде строки.
4. Метод convertToDecimalSystem (String) должен вызывать метод Integer.parseInt(String, int).
5. Метод main (String[]), возвращающий void, должен иметь модификаторы доступа: public, static.

Четвёртый пункт ни в какую не проходит, хотя метод вызывается.

package com.javarush.task.task30.task3002;

/* 
Осваиваем методы класса Integer
*/
public class Solution {

    public static void main(String[] args) {
        System.out.println(convertToDecimalSystem("0x16")); //22
        System.out.println(convertToDecimalSystem("012"));  //10
        System.out.println(convertToDecimalSystem("0b10")); //2
        System.out.println(convertToDecimalSystem("62"));   //62
    }

    public static String convertToDecimalSystem(String s) {
        //напишите тут ваш код
        String result ="";
        String tmp;
      if (s.startsWith("0x")){
          tmp = s.substring(2,s.length());
          result = String.valueOf(Integer.parseInt(tmp,16));
      }
      else if (s.startsWith("0b")){
          tmp = s.substring(2,s.length());
          result = String.valueOf(Integer.parseInt(tmp,2));
      }
      else if (s.startsWith("0")){
          tmp = s.substring(1,s.length());
          result = String.valueOf(Integer.parseInt(tmp,8));
      }
      else
          result = s;
        return result;
    }
}

task22.task2209

Условие:
В методе main считай с консоли имя файла, который содержит слова, разделенные пробелом.
В методе getLine используя StringBuilder расставь все слова в таком порядке, чтобы последняя буква данного слова совпадала с первой буквой следующего не учитывая регистр.
Каждое слово должно участвовать 1 раз.
Метод getLine должен возвращать любой вариант.
Слова разделять пробелом.
Вывести полученную строку на экран.

Пример тела входного файла:
Киев Нью-Йорк Амстердам Вена Мельбурн

Результат:
Амстердам Мельбурн Нью-Йорк Киев Вена

Требования:
1. Метод main должен считывать имя файла с клавиатуры.
2. В методе getLine должен быть использован StringBuilder
3. Метод getLine должен возвращать пустую строку(пустой StringBuilder) в случае если ему не были переданы параметры(слова).
4. Все слова переданные в метод getLine должны быть включены в результирующую строку, если это возможно.
5. Вывод на экран должен соответствовать условию задачи.

/////////

Я вот написал код, позволяющий найти все возможные варианты расстановки слов. Где-то получается длиннее, где-то короче и.т. д.
На картинке можно посмотреть комбинации.
Взял эти города — Пекин Гонконг Токио Москва Париж Лондон Киев Нью-Йорк Амстердам Вена Мельбурн Телявив Осака Оренбург Таганрог Гагарин.

Действительно ли нужно добавлять оставшиеся слова не попавшие никуда в конец? Просто об этом в условии ни хреналеона нету! И это бредово.

Метод getLine должен возвращать любой вариант. Это как понимать? Я должен возвращать какой-то рандомный варинат строки удовлетворяющий результату?

Сейчас валидатор не принимает:

(- тут я возвращаю самый длинный результат)
Все слова переданные в метод getLine должны быть включены в результирующую строку, если это возможно.

Вывод на экран должен соответствовать условию задачи. (казалось бы какому условию, просто через пробел да с большой буквы. Как он может не соответствовать?....)

package com.javarush.task.task22.task2209;

import java.io.*;
import java.util.ArrayList;

/*
Составить цепочку слов
*/
public class Solution {
    public static void main(String[] args) throws IOException {
        //...

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String fileName = reader.readLine();

        FileReader fileReader = new FileReader(fileName);


        StringBuilder file = new StringBuilder();
        while (fileReader.ready()){
            file.append((char) fileReader.read());
        }


        String[] strings = file.toString().split(" ");

        for (int x = 0; x< strings.length; x++){
           strings[x] = strings[x].toLowerCase();
        }

        StringBuilder result = getLine(strings);
        System.out.println(result.toString());
    }

    public static StringBuilder getLine(String... words) {

        if(words!=null && words.length!=0) {   // проверка на условие валидатора

            ArrayList<StringBuilder> megaList = new ArrayList<>(); // тут хранию все возможные комбинации

            ArrayList<String> originalList = new ArrayList<>();  // оригинальный лист стрингов

            for (String word : words) {
                originalList.add(word.toLowerCase()); // делаю всё с маленькой буквы
            }

            int k = originalList.size();   

            while (k > 0) {   //  повторяем цик столько раз, сколько у нас элементов в оригинальном массиве
                StringBuilder stringBuilder = new StringBuilder();
                ArrayList<String> copyOfList = new ArrayList<>(originalList);  // копия оригинального листа

                ArrayList<String> list = new ArrayList<>();  // лист где я храню подобранные слова

                list.add(copyOfList.get(k-1));  // начинаю с конца (не важно) сразу добавляю один (последний) в лист
                copyOfList.remove(k-1);  // и удаляю его из копии листа оригинала

                int n = copyOfList.size();
                while (n > 0) {  //  повторяем цик столько раз, сколько у нас элементов в оригинальном массиве

                    //тут стравниваем буквы, если есть совпадение, то удалячем из копии листа объект под индексом index
                    int index = -1;
                    for (int x = 0; x < copyOfList.size(); x++) {

                        String str1 = copyOfList.get(x);
                        String str2 = list.get(list.size() - 1);

                        char ch1 = str1.charAt(0);
                        char ch2 = str2.charAt(str2.length() - 1);

                        if (ch1 == ch2) {
                            list.add(str1);
                            index = x;
                            break;
                        }
                    }

                    if (index != -1) {
                        copyOfList.remove(index);
                    }

                    n--;
                }

                
                // возвращаем заглавные буквы и морфмируем stringBuilder
                for (String into : list) {
                    String str = into;
                    str = Character.toUpperCase(str.charAt(0)) + str.substring(1);

                    stringBuilder.append(str).append(" ");
                }
                // удаляем пробел 
                stringBuilder.replace(stringBuilder.length()-1,stringBuilder.length(),"");
                megaList.add(stringBuilder);

                k--;
            }

            // тут я просто нахожу самую длинную комбинацию
            int maxIndex=0;
            int lenght=megaList.get(0).length();

            for (int e = 1; e < megaList.size(); e++ ){
                if(megaList.get(e).length()>=lenght) {
                    lenght = megaList.get(e).length();
                    maxIndex = e;
                }
            }

          //  System.out.println(megaList);
            return megaList.get(maxIndex);
        }

    return new StringBuilder();
    }
}

Ошибка incompatible types в task14.task1405;

Всем привет. помогите разобраться, понимаю что решение простое… но что то не доходит какое именно!
ошибка
"
incompatible types: com.javarush.task.task14.task1405.Solution.Food cannot be converted to com.javarush.task.task14.task1405.Solution.Selectable:
Solution.java, line: 10, column: 33
"
Вывод компилятора:
com/javarush/task/task14/task1405/Solution.java:10: error: incompatible types: com.javarush.task.task14.task1405.Solution.Food cannot be converted to com.javarush.task.task14.task1405.Solution.Selectable
Selectable selectable = new Food();

/*
Food
1. Реализовать интерфейс Selectable в классе Food.
2. Метод onSelect() должен выводить на экран фразу «food was selected«.
3. Подумай, какие методы можно вызвать для переменной food и какие для selectable.
4. В методе foodMethods вызови методы onSelect, eat, если это возможно.
5. В методе selectableMethods вызови методы onSelect, eat, если это возможно.
6. Явное приведение типов не использовать.
*/

public class Solution {
    public static void main(String[] args) {
        Food food = new Food();
        Selectable selectable = new Food();
        Food newFood = (Food) selectable;

        foodMethods(food);
        selectableMethods(selectable);
    }

    public static void foodMethods(Food food) {
       food.eat();
        food.onSelect();

    }

    public static void selectableMethods(Selectable selectable) {
        selectable.onSelect();

    }

    interface Selectable {
        void onSelect();
    }

    static class Food {
        public void onSelect() {
            System.out.println("food was selected");
        }
        public void eat() {
            System.out.println("food was eaten");
        }
    }
}

Оценка попыток решения задач и конечный счет

Ребят, мне кажется что java rush ранее выдавала куда более красивую и правдоподобную статистику по тому как вы решили ту или иную задачу. Я имею ввиду среднее количество попыток на сколько успешнее вы решили задачу по сравнению с остальными. Что вы думаете на этот счет?

level19.lesson10.home09 READER-обертка, помогите!

Моя программа в двух вариантах, и ни один из вариантов не проходит проверку на сервере! подскажите, в чем может быть дело?
<em>/* Контекстная реклама
В методе main подмените объект System.out написанной вами реадер-оберткой
Ваша реадер-обертка должна выводить на консоль контекстную рекламу после каждого второго println-а
Вызовите готовый метод printSomething(), воспользуйтесь testString
Верните переменной System.out первоначальный поток

Рекламный текст: "JavaRush - курсы Java онлайн"

Пример вывода:
first
second
JavaRush - курсы Java онлайн
third
fourth
JavaRush - курсы Java онлайн
fifth
*/</em>

— Вариант 1:
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

public class Solution {

    public static void main(String[] args) {
        PrintStream originalConsolePrintStream = System.out;
        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
        PrintStream customOutputStream = new PrintStream(byteArray);
        System.setOut(customOutputStream);
        new TestString().printSomething();

        System.setOut(originalConsolePrintStream);

        String lines[] = byteArray.toString().split(System.lineSeparator());
        for (int i = 0; i < lines.length; i++) {
            System.out.println(lines[i]);
            if (i % 2 != 0) {
                System.out.println("JavaRush - курсы Java онлайн");
            }
        }

    }

    public static class TestString {
        public void printSomething() {
            System.out.println("first");
            System.out.println("second");
            System.out.println("third");
            System.out.println("fourth");
            System.out.println("fifth");
        }
    }
}

— Вариант 2
import java.io.*;

public class Solution {

    public static void main(String[] args) {
        PrintStream orig = System.out;
        System.setOut(new outputStreamDecorator(orig));
        TestString t = new TestString();
        t.printSomething();
        System.setOut(orig);

    }

    public static class TestString {
        public void printSomething() {
            System.out.println("first");
            System.out.println("second");
            System.out.println("third");
            System.out.println("fourth");
            System.out.println("fifth");
        }
    }

    static class outputStreamDecorator extends PrintStream {
        String ad = "JavaRush - курсы Java онлайн";
        static int counter = 0;
        public outputStreamDecorator(OutputStream out) {
            super(out);
        }

        public void println(String s) {
            super.println(s);
            counter++;
            if (counter % 2 == 0 ){
                super.println(ad);
            }
        }
    }
}

Как в новом плагине загружать задачи без сброса прогресса?

В старом плагине, насколько я помню, при открытии уже решённой задачи, решение не пропадало. Сейчас сразу же предупреждение при открытии, что файлы будут сброшены. Можно как-то вернуть на старый вариант? Сейчас получается, что нельзя посмотреть своё же решение. Закрыл задачу, потом открыл и решение сброшено.

  • ,

task32.task3210 или очередная бяка валидатора.

Уже невозможно просто бороться с валидатором, но может я всё-таки где-то не прав?
Условие:
Используем RandomAccessFile

В метод main приходят три параметра:
1) fileName — путь к файлу;
2) number — число, позиция в файле;
3) text — текст.

Считать текст с файла начиная с позиции number, длинной такой же как и длинна переданного текста в третьем параметре.

Если считанный текст такой же как и text, то записать в конец файла строку ‘true‘, иначе записать ‘false‘.
Используй RandomAccessFile и его методы seek(long pos), read(byte b[], int off, int len), write(byte b[]).
Используй convertByteToString(byte readBytes[]) для конвертации считанной строчки в текст
.

Вот мой код:
public class Solution {
public static void main(String... args) throws IOException {
    RandomAccessFile file=new RandomAccessFile(args[0],"rw");
    int n=Integer.parseInt(args[1]);
    file.seek(n);
    String text=args[2];
    byte[] fileText=new byte[(int)file.length()];
    file.read(fileText,0,text.length());
    file.seek(file.length());
    String shoudBeWritten="";
    if(convertByteToString(fileText).equals(text))shoudBeWritten="true";
    else if(!convertByteToString(fileText).equals(text))shoudBeWritten="false";
    file.writeChars(shoudBeWritten);
    file.close();
}
private static String convertByteToString(byte readBytes[]){
    return String.valueOf(readBytes);
}
}

task21.task2104

Задача решена!!! 
Хочу уточнить пару возникших вопросов.
1) Почему при создании нового объекта Solution вызывается метод hashCode()?
   Хотя фактически нет указаний на его вызов.
2) Мы вызываем метод contains(), а исполняется метод equals() ?



public class Solution {
    private final String first, last;

    public Solution(String first, String last) {
        this.first = first;
        this.last = last;
    }

    @Override
    public boolean equals(Object o) {
          *************
            }

    @Override
    public int hashCode() {
        ***************
    }

    public static void main(String[] args) {
        Set<Solution> s = new HashSet<>();
        s.add(new Solution("Donaldadd", "Duckfff"));
        System.out.println(s.contains(new Solution("Donald", "Duck")));
    }
}
  • ,

task01.task0134 - не проходит на корректном решении

public static long getVolume(final int a, final int b, final int c) {
        return 1000 * a * b * c;
    }

Решение выше принимается как верное, но если результат перемножения больше int — ответ получается не правильный.
public static long getVolume(final int a, final int b, final int c) {
        return 1000L * a * b * c;
    }

А это решение не принимается.

P.S.: проблема была актуальна на момент конца февраля.
  • ,

com.javarush.task.task19.task1918 - Все сделано простыми базовыми функциями

НЕ проходит валидацию :( что его беспокоит?

Все сделано простыми базовыми функциями (без Map, Stack и даже массивов), решение за один проход, вложенность тегов «ЗА» общим тегом решена рекурсией.

На мой взгляд все очень компактно и складно.

public static void getOuter(String html, String tag) {

int startPosition = 0;
int openTags = 0;
int firstOpenTag = 0;
int secondOpenTag = 0;
int secondCloseTag = 0;

while (html.indexOf(tag, startPosition) > 0) {
int pos = html.indexOf(tag, startPosition);
if ("<".equals(html.substring(pos — 1, pos))) {
++openTags;
if (openTags == 1)
firstOpenTag = pos;
else if (openTags == 2)
secondOpenTag = pos;
}
if ("/".equals(html.substring(pos — 1, pos))) {
if (openTags == 2)
secondCloseTag = pos;
--openTags;
}
startPosition = pos + 1;

if (openTags == 0) {
System.out.println(html.substring(firstOpenTag — 1, startPosition + tag.length()));
if ((secondCloseTag — secondOpenTag) != 0) {
getOuter(html.substring(secondOpenTag — 1, secondCloseTag + tag.length() + 1), tag);
secondOpenTag = secondCloseTag = 0;
}
}
}
}
  • ,

task35.task3513 задание 12 (игра 2048)

Приветствую. Не получается правильно реализовать функцию сэйва и вследствие этого функцию «отмена последнего действия».
Вот условие этого уровня + предыдущего:


2048 (12)

Ну что, попробуем наш алгоритм в действии? Осталось добавить сохранение игрового состояния в начало каждого метода движения, а также еще один кейс для обработки клавиши, которой будем выполнять отмену последнего хода. При сохранении текущего состояния в стек, обрати внимание на то, чтобы всегда сохранялось актуальное состояние и только однажды. Если ты послушал мой совет и реализовал методы right, up, down с помощью поворотов и вызова метода left, можешь использовать следующий подход:

В самом начале методов right, up, down вызываем метод saveState с gameTiles в качестве параметра.

В методе left организуем проверку того, вызывался ли уже метод saveState. За это у нас отвечает флаг isSaveNeeded, соответственно, если он равен true, выполняем сохранение. После выполнения сдвига влево устанавливаем флаг isSaveNeeded равным true. Также добавим в метод keyPressed класса Controller вызов метода rollback по нажатию на клавишу Z (код — KeyEvent.VK_Z).

2048 (11) Отличная работа! На этом этапе у нас уже есть полнофункциональное приложение, но ведь нет предела совершенству, давай еще поработаем. Если ты успел какое-то время поиграть в 2048, то заметил, что порой очень хочется иметь возможность отменить последний ход. Давай создадим в классе Model два стека, в одном будем хранить предыдущие состояния игрового поля, а в другом предыдущие счета. Назовем их previousStates и previousScores. Инициализировать можешь прямо в строке объявления или в конструкторе. Используй стандартную реализацию стека (java.util.Stack). Добавим boolean поле isSaveNeeded = true, оно нам понадобится в будущем.

Хранилище состояний у нас есть, теперь реализуем два метода для работы с ними.

Приватный метод saveState с одним параметром типа Tile[][] будет сохранять текущее игровое состояние и счет в стеки с помощью метода push и устанавливать флаг isSaveNeeded равным false.

Публичный метод rollback будет устанавливать текущее игровое состояние равным последнему находящемуся в стеках с помощью метода pop. Обрати внимание на то, что при сохранении массива gameTiles необходимо создать новый массив и заполнить его новыми объектами типа Tile перед сохранением в стек. В методе rollback достаточно просто выполнить присваивание (gameTiles = previousStates.pop()) и то же для счета, нет необходимости в глубоком копировании. Перед восстановлением игрового состояния с помощью метода rollback не забудь проверить что стеки не пусты, чтобы избежать возникновения исключения EmptyStackException.


Вот мой код.
public class Model {
    private static final int FIELD_WIDTH = 4;
    private Tile[][] gameTiles;
    int score,maxTile;
    private boolean isSaveNeeded = true;
    private Stack<Tile[][]> previousStates=new Stack<>();
    private Stack<Integer> previousScores=new Stack<>();



    public Model() {

        resetGameTiles();
    }
    public boolean canMove() {
        if(!getEmptyTiles().isEmpty())
            return true;
        for(int i = 0; i < gameTiles.length; i++) {
            for(int j = 1; j < gameTiles.length; j++) {
                if(gameTiles[i][j].value == gameTiles[i][j-1].value)
                    return true;
            }
        }
        for(int j = 0; j < gameTiles.length; j++) {
            for(int i = 1; i < gameTiles.length; i++) {
                if(gameTiles[i][j].value == gameTiles[i-1][j].value)
                    return true;
            }
        }
        return false;
    }

    public Tile[][] getGameTiles() {
        return gameTiles;
    }

    private ArrayList<Tile> getEmptyTiles(){
        ArrayList<Tile> emptyTiles=new ArrayList<>();
        for (int m = 0; m < FIELD_WIDTH ; m++) {
            for (int n = 0; n <FIELD_WIDTH ; n++) {
                if(gameTiles[m][n].value==0)emptyTiles.add(gameTiles[m][n]);
            }
        }
        return emptyTiles;
    }
    public void rotateToRight(){
        for (int k=0; k<FIELD_WIDTH/2; k++)
        {
            for (int j=k; j<FIELD_WIDTH-1-k; j++)
            {
                Tile tmp = gameTiles[k][j];
                gameTiles[k][j]  = gameTiles[j][FIELD_WIDTH-1-k];
                gameTiles[j][FIELD_WIDTH-1-k] = gameTiles[FIELD_WIDTH-1-k][FIELD_WIDTH-1-j];
                gameTiles[FIELD_WIDTH-1-k][FIELD_WIDTH-1-j] = gameTiles[FIELD_WIDTH-1-j][k];
                gameTiles[FIELD_WIDTH-1-j][k]  = tmp;
            }
        }

    }
    private void saveState(Tile[][] tiles){
        Tile[][] bufTiles=new Tile[FIELD_WIDTH][FIELD_WIDTH];
        for (int i = 0; i < tiles.length; i++) {
            for (int j = 0; j < tiles[i].length; j++) {
                bufTiles[i][j]=tiles[i][j];
                bufTiles[i][j].value=tiles[i][j].value;
            }
        }
        previousStates.push(bufTiles);
        previousScores.push(this.score);
        isSaveNeeded=false;
    }
    public void rollback(){
        if(!previousScores.isEmpty()&&!previousStates.isEmpty()) {
            gameTiles = previousStates.pop();
            score=previousScores.pop();

        }
    }

    public void right(){
        saveState(this.gameTiles);
        rotateToRight();
        rotateToRight();
        left();
        rotateToRight();
        rotateToRight();
    }
    public void up(){
        saveState(this.gameTiles);
        rotateToRight();
        left();
        rotateToRight();
        rotateToRight();
        rotateToRight();
    }
    public void down(){
        saveState(this.gameTiles);
        rotateToRight();
        rotateToRight();
        rotateToRight();
        left();
        rotateToRight();
    }

    public void left(){
        if(isSaveNeeded)saveState(this.gameTiles);
        boolean isChanged = false;
        for (int i = 0; i < FIELD_WIDTH; i++) {
            if (compressTiles(gameTiles[i]) | mergeTiles(gameTiles[i])) {
                isChanged = true;
            }
        }
        isSaveNeeded=true;
        if (isChanged) addTile();
    }

    private void addTile(){
        ArrayList<Tile> emptyTiles=getEmptyTiles();
        if(!emptyTiles.isEmpty()) {
            Tile randomEmptyTile = emptyTiles.get((int) (emptyTiles.size() * Math.random()));
            randomEmptyTile.value = Math.random() < 0.9 ? 2 : 4;
        }
    }
    private boolean compressTiles(Tile[] tiles){
        boolean isChanged=false;
        for (int i = 1; i < tiles.length; i++) {
            for (int j = 1; j < tiles.length; j++) {
                if (tiles[j - 1].isEmpty() && !tiles[j].isEmpty()) {
                    tiles[j - 1] = tiles[j];
                    tiles[j] = new Tile();
                    isChanged=true;
                }
            }
        }
        return isChanged;
    }
    private boolean mergeTiles(Tile[] tiles){
        boolean isChanged=false;
        for (int i = 1; i < tiles.length; i++) {
            if ((tiles[i - 1].value == tiles[i].value) && !tiles[i - 1].isEmpty() && !tiles[i].isEmpty()) {

                tiles[i - 1].value *= 2;
                if(tiles[i-1].value>maxTile){
                    maxTile = tiles[i-1].value;
                }
                score += tiles[i - 1].value;
                tiles[i] = new Tile();
                isChanged=true;
                compressTiles(tiles);
            }
        }
        return isChanged;
    }


    public void resetGameTiles(){

        gameTiles=new Tile[FIELD_WIDTH][FIELD_WIDTH];
        for (int m = 0; m < FIELD_WIDTH ; m++) {
            for (int n = 0; n <FIELD_WIDTH ; n++) {
                gameTiles[m][n]=new Tile();
            }
        }
        score=0;
        maxTile=2;
        addTile();
        addTile();

    }
}