Есть код программы, выполняющий алгоритм Обхода коня всех клеток шахматной доски.Нужно перевести этот код на Java.Пожалуйста помогите это сделать, сам в с++ совершенно не разбирась((
вот ссылка на сам код: http://iguania.ru/article/knights-tour

M LSD

Для домашних заданий, курсовых и т.п. существует \"Центр Помощи\".

Тема перенесена. 

Насколько я вижу, там код на java будет почти такой же. Единственное отличие, на первый взгляд, будет в  организации ввода/вывода.

Насколько я помню, у швейцарцев есть такая программа-конвертер. Услуга стоит $10 за строку кода. Или можно потратить 40 минут на изучение основ C++.

Этот ответ добавлен с нового Винграда - http://vingrad.com

https://www.mtsystems.com/

Этот ответ добавлен с нового Винграда - http://vingrad.com

не хило. А если в файле несколько тысяч строк, это не для бедных :)

Этот ответ добавлен с нового Винграда - http://vingrad.com

Ну как то так :)

import java.util.Scanner;

public class main {
    
    private final int hor = 8;
    private final int ver = 8;
    
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        
        //выделяем память для массива, эмитирующего шахматную доску
        int[][] board = new int[8][8];
        //описываем этими двумя массивами варианты ходов конем на доске(их всего восемь от 0 до 7)
        int[] horizontal = { 2, 1,-1,-2,-2,-1, 1, 2};
        int[] vertical   = {-1,-2,-2,-1, 1, 2, 2, 1};
        //массив доступности ходов конем
        int[][] accessibility = {{2,3,4,4,4,4,3,2},
                                {3,4,6,6,6,6,4,3},
                                {4,6,8,8,8,8,6,4},
                                {4,6,8,8,8,8,6,4},
                                {4,6,8,8,8,8,6,4},
                                {4,6,8,8,8,8,6,4},
                                {3,4,6,6,6,6,4,3},
                                {2,3,4,4,4,4,3,2}};
        
        //переменные, запоминающие текущие координаты нахождения коня
        int currentRow, currentColumn;
        //переменная, определяющая вариант хода конем(от 0 до 7)
        int moveNumber;
        //счетчик ходов конем
        int counter = 0;

        //предложение ввода координаты нахождения коня по горизонтали
        System.out.println("Enter a horizontal coordinate(0 - 7): ");
        //сохранение введенных данных в переменной
        currentRow = scanner.nextInt();
        //ввод координаты по вертикали
        System.out.println("Enter a vertical coordinate(0 - 7): ");
        //сохранение данных ввода
        currentColumn = scanner.nextInt();

        //переменные currentRow и currentColumn модифицируються для изменения доступностей, поэтому сохраняем их
        int mainRow = currentRow, mainColumn = currentColumn;
        //переменные для записи координат следующего хода конем
        int Row = 0, Column = 0;
        
        //начинаем поиск решения
        for(int i = 1; i <= 64; i++)
        {
            board[mainRow][mainColumn] = ++counter;

            //делаем равным максимально возможной доступности
            int minAccessibility = 8;
            //временные переменные для исследования субдоступностей
            int minA = 8, minB = 8;

            //уменьшение доступности на единицу клеток, расположенных в одном ходу от выбранной
            for(moveNumber = 0; moveNumber <= 7; moveNumber++)
            {
                //запоминаем положение коня на доске перед модификацией для изменения доступностей
                currentRow = mainRow;
                currentColumn = mainColumn;

                //исследуем доступность всех возможных ходов не выходящих за границы доски
                currentRow += horizontal[moveNumber];
                currentColumn += vertical[moveNumber];

                //не выходит ли за границы доски
                if(currentRow >= 0 && currentRow <= 7 && currentColumn >= 0 && currentColumn <= 7)
                {
                    //уменьшаем доступность всех клеток в одном ходу
                    accessibility[currentRow][currentColumn]--;

                    //если доступность больше, то меняем на меньшую
                    if(minAccessibility > accessibility[currentRow][currentColumn] && board[currentRow][currentColumn] == 0)
                    {
                        //нашли минимальную доступность и ее координаты
                        minAccessibility = accessibility[currentRow][currentColumn];

                        //если не ходили на нее еще то делаем на нее ход
                        if(board[currentRow][currentColumn] == 0)
                        {
                            //подготовили координаты к ходу на эту клетку
                            Row = currentRow;
                            Column = currentColumn;
                        }
                        //временных переменные для нахождения минимальной доступности у тех, что меньше
                        int RowA = currentRow, ColumnA = currentColumn;

                        for(int moveA = 0; moveA <= 7; moveA++)
                        {
                            RowA += horizontal[moveA];
                            ColumnA += vertical[moveA];

                            if(RowA >= 0 && RowA <= 7 && ColumnA >= 0 && ColumnA <= 7)
                            {
                                if(minA >= accessibility[RowA][ColumnA] && board[RowA][ColumnA] == 0)
                                    //наименьшая доступность следующего хода
                                    minA = accessibility[RowA][ColumnA];
                            }
                        }
                    }

                    //если доступности равны
                    if(minAccessibility == accessibility[currentRow][currentColumn] && board[currentRow][currentColumn] == 0)
                    {
                        minAccessibility = accessibility[currentRow][currentColumn];

                        //временных переменные для нахождения минимальной доступности у тех, что равны
                        int RowB = currentRow, ColumnB = currentColumn;

                        for(int moveB = 0; moveB <= 7; moveB++)
                        {
                            RowB += horizontal[moveB];
                            ColumnB += vertical[moveB];

                            if(RowB >= 0 && RowB <= 7 && ColumnB >= 0 && ColumnB <= 7)
                            {
                                if(minB >= accessibility[RowB][ColumnB] && board[RowB][ColumnB] == 0)
                                    //наименьшая доступность следующего хода
                                    minB = accessibility[RowB][ColumnB];
                            }
                        }

                        //если не ходили на нее еще то делаем на нее ход
                        if(board[currentRow][currentColumn] == 0 && minB < minA)
                        {
                            //изменяем подготовленные для следующего хода координаты в случае, если доступность следующего хода меньше
                            Row = currentRow;
                            Column = currentColumn;
                        }
                    }
                }
            }

            mainRow = Row;
            mainColumn = Column;
        }

        //вызов функции для печати массива, моделирующего шахматную доску
        printBoard(board);
        
        System.out.println("End"); 
    }
    
    //вывод массива, печатающего шахматную доску, на экран
    static void printBoard(int[][] board)
    {
        for(int j = 0; j < 8; j++)
        {
            for(int i = 0; i < 8; i++)
            {
             System.out.print(board[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

Этот ответ добавлен с нового Винграда - http://vingrad.com

Кому нужно вот под C#

using System;

namespace Journey_of_the_horse
{
    class Program
    {
        //глобальные константы, определяющие размерность массива board
        const int hor = 8, ver = 8;
        
        //прототип функции для вывода массива, имитирующего шахматную доску, на экран

        public static void Main(string[] args)
        {            
            //выделяем память для массива, эмитирующего шахматную доску
            int[,] board = new int[hor, ver];
            
            //описываем этими двумя массивами варианты ходов конем на доске(их всего восемь от 0 до 7)
            int[] horizontal = { 2, 1,-1,-2,-2,-1, 1, 2};
            int[] vertical   = {-1,-2,-2,-1, 1, 2, 2, 1};
            
            //массив доступности ходов конем
            int[,] accessibility = new int[hor, ver]
                                          {{2,3,4,4,4,4,3,2},
                                           {3,4,6,6,6,6,4,3},
                                           {4,6,8,8,8,8,6,4},
                                           {4,6,8,8,8,8,6,4},
                                           {4,6,8,8,8,8,6,4},
                                           {4,6,8,8,8,8,6,4},
                                           {3,4,6,6,6,6,4,3},
                                           {2,3,4,4,4,4,3,2}};
            
            //переменные, запоминающие текущие координаты нахождения коня
            int currentRow, currentColumn;
            //переменная, определяющая вариант хода конем(от 0 до 7)
            int moveNumber;
            //счетчик ходов конем
            int counter = 0;
        
            //предложение ввода координаты нахождения коня по горизонтали
            Console.Write("Enter a horizontal coordinate(0 - 7): ");
            //сохранение введенных данных в переменной
            currentRow = int.Parse(Console.ReadLine());
            //ввод координаты по вертикали
            Console.Write("Enter a vertical coordinate(0 - 7): ");
            //сохранение данных ввода
            currentColumn = int.Parse(Console.ReadLine());
        
            //переменные currentRow и currentColumn модифицируються для изменения доступностей, поэтому сохраняем их
            int mainRow = currentRow, mainColumn = currentColumn;
            //переменные для записи координат следующего хода конем
            int Row = 0, Column = 0;
            
           //начинаем поиск решения
            for(int i = 1; i <= 64; i++)
            {
                board[mainRow, mainColumn] = ++counter;
        
                //делаем равным максимально возможной доступности
                int minAccessibility = 8;
                //временные переменные для исследования субдоступностей
                int minA = 8, minB = 8;
        
                //уменьшение доступности на единицу клеток, расположенных в одном ходу от выбранной
                for(moveNumber = 0; moveNumber <= 7; moveNumber++)
                {
                    //запоминаем положение коня на доске перед модификацией для изменения доступностей
                    currentRow = mainRow;
                    currentColumn = mainColumn;
        
                    //исследуем доступность всех возможных ходов не выходящих за границы доски
                    currentRow += horizontal[moveNumber];
                    currentColumn += vertical[moveNumber];
        
                    //не выходит ли за границы доски
                    if(currentRow >= 0 && currentRow <= 7 && currentColumn >= 0 && currentColumn <= 7)
                    {
                        //уменьшаем доступность всех клеток в одном ходу
                        accessibility[currentRow,currentColumn]--;
        
                        //если доступность больше, то меняем на меньшую
                        if(minAccessibility > accessibility[currentRow,currentColumn] && board[currentRow,currentColumn] == 0)
                        {
                            //нашли минимальную доступность и ее координаты
                            minAccessibility = accessibility[currentRow,currentColumn];
        
                            //если не ходили на нее еще то делаем на нее ход
                            if(board[currentRow,currentColumn] == 0)
                            {
                                //подготовили координаты к ходу на эту клетку
                                Row = currentRow;
                                Column = currentColumn;
                            }
                            //временных переменные для нахождения минимальной доступности у тех, что меньше
                            int RowA = currentRow, ColumnA = currentColumn;
        
                            for(int moveA = 0; moveA <= 7; moveA++)
                            {
                                RowA += horizontal[moveA];
                                ColumnA += vertical[moveA];
        
                                if(RowA >= 0 && RowA <= 7 && ColumnA >= 0 && ColumnA <= 7)
                                {
                                    if(minA >= accessibility[RowA,ColumnA] && board[RowA,ColumnA] == 0)
                                        //наименьшая доступность следующего хода
                                        minA = accessibility[RowA,ColumnA];
                                }
                            }
                        }
        
                        //если доступности равны
                        if(minAccessibility == accessibility[currentRow,currentColumn] && board[currentRow,currentColumn] == 0)
                        {
                            minAccessibility = accessibility[currentRow,currentColumn];
        
                            //временных переменные для нахождения минимальной доступности у тех, что равны
                            int RowB = currentRow, ColumnB = currentColumn;
        
                            for(int moveB = 0; moveB <= 7; moveB++)
                            {
                                RowB += horizontal[moveB];
                                ColumnB += vertical[moveB];
        
                                if(RowB >= 0 && RowB <= 7 && ColumnB >= 0 && ColumnB <= 7)
                                {
                                    if(minB >= accessibility[RowB,ColumnB] && board[RowB,ColumnB] == 0)
                                        //наименьшая доступность следующего хода
                                        minB = accessibility[RowB,ColumnB];
                                }
                            }
        
                            //если не ходили на нее еще то делаем на нее ход
                            if(board[currentRow,currentColumn] == 0 && minB < minA)
                            {
                                //изменяем подготовленные для следующего хода координаты в случае, если доступность следующего хода меньше
                                Row = currentRow;
                                Column = currentColumn;
                            }
                        }
                    }
                }
        
                mainRow = Row;
                mainColumn = Column;
            }
                    
            //вызов функции для печати массива, моделирующего шахматную доску
         printBoard(board);
            Console.ReadKey(true);
        }
        
        //вывод массива, печатающего шахматную доску, на экран
        static void printBoard(int[,] board)
        {
            Console.WriteLine();
            for(int j = 0; j < ver; j++)
            {
                for(int i = 0; i < hor; i++)
                {
                 Console.Write("{0,4:D}", board[i,j]);
                }
                Console.Write("\r\n");
            }
        }
        

    }
}

Этот ответ добавлен с нового Винграда - http://vingrad.com