Проверить правильность расстановки кораблей. Морской бой

@Aymurat · Регистрация: 07.11.2014

Есть матрица NxM, где расставлены корабли. Корабли не стоят на краю матрицы, кол-во 4-х клеточных кораблей - 1, 3-х клет. - 2, 2-х клеточных - 3, 1-х - 4
Нужно проверить правильно ли расстановлены и ответить YES,NO;
Матрица заполняется 0 и 1, где 1 это клетка корабля.
Корабли не должны соприкасаться друг с другом и должны быть все корабли(не меньше, не больше),задача взята из книги Динман Максима C++ Освой на примерах.
Там есть первый пример, который очень схож с этой задачей, код не выполняется:

Кликните здесь для просмотра всего текста

C++

#include <iostream>
#include <conio.h>
const int N = 8, M = 8;
void Add(int x, int y);
void Test();
void Find();
int Label,p,i,j,a,b;
int Start, Last;
int array[N+2][M+2] = {
    {0,0,0,0,0,0,0,0,0,0},
    {0,1,0,0,1,1,1,0,1,0},
    {0,1,0,1,0,0,0,1,0,0},
    {0,1,0,0,0,1,0,0,0,0},
    {0,1,0,1,1,0,1,1,1,0},
    {0,0,0,0,0,0,0,0,0,0},
    {0,1,1,0,1,1,0,1,1,0},
    {0,0,0,0,0,0,0,0,0,0}};
int Queue[2][N*M];
int main() {
    Start = 0;
    Last = 0;
    Label = 0;
    p = 1;
    do
    {
        Find();
        if (p == 1) Test();
    } while (p == 1);
    std::cout << Label;
    _getch();
    return 0;
}
void Test()
{
    Label++;
    while (Start != Last)
    {
        a = Queue[0][Start];
        b = Queue[1][Start];
        if (array[a - 1][b] == 1) Add(a - 1, b);//++
        if (array[a + 1][b] == 1) Add(a + 1, b);
        if (array[a][b + 1] == 1) Add(a, b + 1);
        if (array[a][b - 1] == 1) Add(a, b - 1);
        Start++;
    }
}
void Find()
{
    p = 0;
    for (i = 1; i <= N && p == 0; i++)
        for (j = 1; j <= M && p == 0; j++)
            if (array[i][j] == 1)
            {
                p = 1;
                Add(i, j);
            }
}
void Add(int x, int y)
{
    Queue[0][Last] = x;
    Queue[1][Last] = y;
    array[x][y] = Label;
    Last++;
}

Строка, где //++, крашит программу, помогите с примером и задачей...

@nmcf · 27.09.2016, 15:24

Почему строк только 8 задано? Так и задумано?

@Aymurat · 27.09.2016, 15:27 **[ТС]**

nmcf, можно вообще любое кол-во, но не вместится на 4х4 и т.д., а 2 столбца и 2 строки дополнительных - это для того, чтобы не выйти за пределы матрицы.

@nmcf · 27.09.2016, 15:51

У тебя 10 строк указано в размере (N + 2), а задаёшь только 8. Это нормально?

@Aymurat · 27.09.2016, 15:57 **[ТС]**

nmcf, так при проверке смежных клеток через Test чтобы не выйти за пределы матрицы же) Нормально

@nmcf · 27.09.2016, 15:59

Но столбцов-то ты 10 инициализируешь нулями/единицами, а строк 8. Не понятно.

@Aymurat · 27.09.2016, 16:06 **[ТС]**

nmcf, аа, щас исправлю, спасибо. Теперь код такой:

Кликните здесь для просмотра всего текста

C++

#include <iostream>
#include <conio.h>
const int N = 8, M = 8;
void Add(int x, int y);
void Test();
void Find();
int Label,p,i,j,a,b;
int Start, Last;
int array[N+2][M+2] = {
    {0,0,0,0,0,0,0,0,0,0},
    {0,1,0,0,1,1,1,0,1,0},
    {0,1,0,1,0,0,0,1,0,0},
    {0,1,0,0,0,1,0,0,0,0},
    {0,1,0,1,1,0,1,1,1,0},
    {0,0,0,0,0,0,0,0,0,0},
    {0,1,1,0,1,1,0,1,1,0},
    {0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0}};
int Queue[2][N*M];
int main() {
    Start = 0;
    Last = 0;
    Label = 0;
    p = 1;
    do
    {
        Find();
        if (p == 1) Test();
    } while (p == 1);
    std::cout << Label;
    _getch();
    return 0;
}
void Test()
{
    Label++;
    while (Start != Last)
    {
        a = Queue[0][Start];
        b = Queue[1][Start];
        if (array[a - 1][b] == 1) Add(a - 1, b);//++
        if (array[a + 1][b] == 1) Add(a + 1, b);
        if (array[a][b + 1] == 1) Add(a, b + 1);
        if (array[a][b - 1] == 1) Add(a, b - 1);
        Start++;
    }
}
void Find()
{
    p = 0;
    for (i = 1; i <= N && p == 0; i++)
        for (j = 1; j <= M && p == 0; j++)
            if (array[i][j] == 1)
            {
                p = 1;
                Add(i, j);
            }
}
void Add(int x, int y)
{
    Queue[0][Last] = x;
    Queue[1][Last] = y;
    array[x][y] = Label;
    Last++;
}

Проблема не решена, все равно крашится

@nmcf · 27.09.2016, 16:46

Отладчиком смотрел? Индексы правильные?

@Aymurat · 27.09.2016, 16:58 **[ТС]**

nmcf, не смотрел, индексы вроде правильные, именно та строка(42) рушит программу
А как посмотреть? VS есть, после ошибки прерываю, дальше что?)

Добавлено через 1 минуту
nmcf, желтая стрелка вот на эту строку показывает:

C++

1	Queue[1][Last] = y;

@nmcf · 27.09.2016, 18:57

Текст ошибки какой?
В пошаговом режиме смотри за индексами.

@Aymurat · 29.09.2016, 16:59 **[ТС]**

nmcf, ошибка не при компилировании, а при запуске программы. Такое ощущение, будто делаю что-то невозможное(делю на ноль/выхожу за пределы массива/бесконечный цикл)
Но такого не замечаю, да и условие примитивное...

@nmcf · 29.09.2016, 18:21

Ну вот отладчиком и смотри в пошаговом режиме.

@Aymurat · 29.09.2016, 20:49 **[ТС]**

nmcf, Ну не умею я((

@Mr.X · 30.09.2016, 13:11

Сообщение от Aymurat

задача взята из книги Динман Максима C++ Освой на примерах.
Там есть первый пример, который очень схож с этой задачей, код не выполняется:

Кошмар! Программа спроектирована просто ужасно, в стиле программ на древнем Бейсике. Иногда поражаешься, какие дебилы пишут книги с поучениями.
Во-первых, непонятно при чем тут С++. Какие-то сплошь глобальные переменные с дурацкими буковками вместо имен.
Слепые, ничего не объясняющие имена функций. Ну и автор книги таки алфавита не знает! У него N предшествует M!
Завидую мужеству автора темы, который может в этом ковыряться. Кроме острого желания поблевать эта программа ничего не вызывает, и единственное, что с ней можно сделать, - это показывать детям, чтобы, не дай Бог, никогда такого не писали.

Мой вариант:

C++

//Есть матрица NxM, где расставлены корабли. Корабли не стоят на краю матрицы,
//кол-во 4-х клеточных кораблей - 1, 3-х клет. - 2, 2-х клеточных - 3, 1-х - 4
//Нужно проверить правильно ли расстановлены и ответить YES,NO;
//Матрица заполняется 0 и 1, где 1 это клетка корабля.
//Корабли не должны соприкасаться друг с другом и должны быть все корабли
//(не меньше, не больше)
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <iostream>
#include <set>
#include <utility>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
const   int     M   =   10;
const   int     N   =   10;
///////////////////////////////////////////////////////////////////////////////
typedef int                             (& T_matr_ref)[M][N];
typedef int                             T_coord;
typedef std::complex    < T_coord   >   T_cell;
typedef std::vector     < int       >   T_counters;
typedef std::set        < T_cell    >   T_cells;
typedef T_cells                         T_ship;
///////////////////////////////////////////////////////////////////////////////
namespace std
{
    bool    operator<
        (
            T_cell  const   &   L,
            T_cell  const   &   R
        )
    {
        return      std::make_pair( L.real(),   L.imag()    )
                <   std::make_pair( R.real(),   R.imag()    );
    }
}
///////////////////////////////////////////////////////////////////////////////
bool    cells_are_neighbors
    (
        T_cell  A,
        T_cell  B
    )
{
    return          std::abs    (
                                    A.real()    -   B.real()
                                )
 
                +   std::abs    (
                                    A.imag()    -   B.imag()
                                )
 
            ==  1;
}
///////////////////////////////////////////////////////////////////////////////
bool    cell_on_edge( T_cell    cell )
{
    return      cell.real()   ==  0
            ||  cell.real()   ==  M - 1
 
            ||  cell.imag()   ==  0
            ||  cell.imag()   ==  N - 1;
}
///////////////////////////////////////////////////////////////////////////////
bool    ship_is_correct( T_ship     const   &   ship )
{
    int     i_min   =   M;
    int     j_min   =   N;
 
    int     i_max   =   -1;
    int     j_max   =   -1;
 
    for( auto   cell    :   ship )
    {
        auto    i   =   cell.real();
        auto    j   =   cell.imag();
 
        if  (
                cell_on_edge( cell )
            )
        {
            return  false;
        }
 
        if( i < i_min )     {   i_min    =   i; }
        if( i > i_max )     {   i_max    =   i; }
 
        if( j < j_min )     {   j_min    =   j; }
        if( j > j_max )     {   j_max    =   j; }
    }//for
 
    auto    delta_i     =   i_max  -   i_min;
    auto    delta_j     =   j_max  -   j_min;
 
    return      delta_i     *   delta_j     ==  0
 
            &&  ++delta_i   *   ++delta_j   ==  int (
                                                        ship.size()
                                                    );
}
///////////////////////////////////////////////////////////////////////////////
void    search_ship
    (
        T_cell      &   cell,
        T_matr_ref      matr,
        T_ship      &   ship,
        T_cells     &   marked_cells
    )
{
    marked_cells    .emplace    ( cell );
    ship            .emplace    ( cell );
 
    int     i   =   cell.real();
    int     j   =   cell.imag();
 
    for (
            int
            ii  =   std::max( i - 1,    0       );
            ii  <=  std::min( i + 1,    M - 1   );
            ++ii
        )
    {
        for (
                int
                jj  =   std::max( j - 1,    0       );
                jj  <=  std::min( j + 1,    N - 1   );
                ++jj
            )
        {
            T_cell  cell_cur(ii, jj);
 
            if  (
                        matr[ii][jj]
                    &&  !marked_cells.count( cell_cur           )
                    &&  cells_are_neighbors( cell_cur,  cell    )
                )
            {
                search_ship (
                                cell_cur,
                                matr,
                                ship,
                                marked_cells
                            );
            }
        }//for
    }//for
}
///////////////////////////////////////////////////////////////////////////////
bool    ships_matr_is_correct   ( T_matr_ref    matr )
{
    T_cells     marked_cells;
    T_counters  counters    {0,4,3,2,1};
 
    for( size_t  i{}; i < M; ++i )
    {
        for( size_t  j{}; j < N; ++j )
        {
            if  (
                    matr[i][j]  ==  0
                )
            {
                continue;
            }
 
            T_cell  cell_cur(i, j);
 
            if  (
                    marked_cells.count( cell_cur )
                )
            {
                continue;
            }
 
            T_ship  ship;
 
            search_ship
                (
                    cell_cur,
                    matr,
                    ship,
                    marked_cells
                );
 
            if  (
                    ship_is_correct( ship )
                )
            {
                --counters[ ship.size() ];
            }
            else
            {
                return  false;
            }
        }//for
    }//for
 
    return  counters    ==  T_counters  (
                                            counters.size()
                                        );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    int     matr[M][N]  =   {
                                {0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,1,1,1,0,1,0},
                                {0,0,0,1,0,0,0,0,0,0},
 
                                {0,0,0,0,0,1,0,0,0,0},
                                {0,0,0,1,1,0,1,1,1,0},
                                {0,0,0,0,0,0,0,0,0,0},
 
                                {0,1,1,0,1,1,0,0,1,0},
                                {0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,1,1,1,1,0},
 
                                {0,0,0,0,0,0,0,0,0,0}
                            };
 
    std::cout   <<  (
                        ships_matr_is_correct( matr )
                            ?   "YES"
                            :   "NO"
                    )
 
                <<  std::endl;
}

@nmcf · 30.09.2016, 14:17

Что там уметь? Точку останова перед этим циклом сделай, запусти, и программа там остановится. Дальше пошагово - в меню посмотри какие клавиши нажимать.

@Aymurat · 01.10.2016, 11:12 **[ТС]**

Mr.X, спасибо, программа работает, но много непонятных моментов, можете прокомментировать код?

@Mr.X · 01.10.2016, 16:19

Сообщение от Aymurat

Mr.X, спасибо, программа работает, но много непонятных моментов, можете прокомментировать код?

Да он вроде бы самодокументируемый. А что непонятно?
Кстати, там можно обойтись без комплексных чисел:

C++

//Есть матрица NxM, где расставлены корабли. Корабли не стоят на краю матрицы,
//кол-во 4-х клеточных кораблей - 1, 3-х клет. - 2, 2-х клеточных - 3, 1-х - 4
//Нужно проверить правильно ли расстановлены и ответить YES,NO;
//Матрица заполняется 0 и 1, где 1 это клетка корабля.
//Корабли не должны соприкасаться друг с другом и должны быть все корабли
//(не меньше, не больше)
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <set>
#include <utility>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
const   int     M   =   10;
const   int     N   =   10;
///////////////////////////////////////////////////////////////////////////////
typedef int                                     (&  T_matr_ref)[M][N];
typedef int                                     T_coord;
typedef std::pair       < T_coord,  T_coord >   T_cell;
typedef std::vector     < int       >           T_counters;
typedef std::set        < T_cell    >           T_cells;
typedef T_cells                                 T_ship;
///////////////////////////////////////////////////////////////////////////////
bool    cells_are_neighbors
    (
        T_cell  A,
        T_cell  B
    )
{
    return          std::abs( A.first   -   B.first     )
                +   std::abs( A.second  -   B.second    )
            ==  1;
}
///////////////////////////////////////////////////////////////////////////////
bool    cell_on_edge( T_cell    cell )
{
    return      cell.first      ==  0
            ||  cell.first      ==  M - 1
 
            ||  cell.second     ==  0
            ||  cell.second     ==  N - 1;
}
///////////////////////////////////////////////////////////////////////////////
bool    ship_is_correct( T_ship     const   &   ship )
{
    int     i_min   =   M;
    int     j_min   =   N;
 
    int     i_max   =   -1;
    int     j_max   =   -1;
 
    for( auto   cell    :   ship )
    {
        auto    i   =   cell.first;
        auto    j   =   cell.second;
 
        if  (
                cell_on_edge( cell )
            )
        {
            return  false;
        }
 
        if( i < i_min )     {   i_min    =   i; }
        if( i > i_max )     {   i_max    =   i; }
 
        if( j < j_min )     {   j_min    =   j; }
        if( j > j_max )     {   j_max    =   j; }
    }//for
 
    auto    delta_i     =   i_max  -   i_min;
    auto    delta_j     =   j_max  -   j_min;
 
    return      delta_i     *   delta_j     ==  0
 
            &&  ++delta_i   *   ++delta_j   ==  int (
                                                        ship.size()
                                                    );
}
///////////////////////////////////////////////////////////////////////////////
void    search_ship
    (
        T_cell      &   cell,
        T_matr_ref      matr,
        T_ship      &   ship,
        T_cells     &   marked_cells
    )
{
    marked_cells    .emplace    ( cell );
    ship            .emplace    ( cell );
 
    int     i   =   cell.first;
    int     j   =   cell.second;
 
    for (
            int
            ii  =   std::max( i - 1,    0       );
            ii  <=  std::min( i + 1,    M - 1   );
            ++ii
        )
    {
        for (
                int
                jj  =   std::max( j - 1,    0       );
                jj  <=  std::min( j + 1,    N - 1   );
                ++jj
            )
        {
            T_cell  cell_cur(ii, jj);
 
            if  (
                        matr[ii][jj]
                    &&  !marked_cells.count( cell_cur           )
                    &&  cells_are_neighbors( cell_cur,  cell    )
                )
            {
                search_ship (
                                cell_cur,
                                matr,
                                ship,
                                marked_cells
                            );
            }
        }//for
    }//for
}
///////////////////////////////////////////////////////////////////////////////
bool    ships_matr_is_correct   ( T_matr_ref    matr )
{
    T_cells     marked_cells;
    T_counters  counters    {0,4,3,2,1};
 
    for( size_t  i{}; i < M; ++i )
    {
        for( size_t  j{}; j < N; ++j )
        {
            T_cell  cell_cur(i, j);
 
            if  (
                        matr[i][j]  ==  0
                    ||  marked_cells.count( cell_cur )
                )
            {
                continue;
            }
 
            T_ship  ship;
 
            search_ship
                (
                    cell_cur,
                    matr,
                    ship,
                    marked_cells
                );
 
            if  (
                    ship_is_correct( ship )
                )
            {
                --counters[ ship.size() ];
            }
            else
            {
                return  false;
            }
        }//for
    }//for
 
    return  counters    ==  T_counters  (
                                            counters.size()
                                        );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    int     matr[M][N]  =   {
                                {0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,1,1,1,0,1,0},
                                {0,0,0,1,0,0,0,0,0,0},
 
                                {0,0,0,0,0,1,0,0,0,0},
                                {0,0,0,1,1,0,1,1,1,0},
                                {0,0,0,0,0,0,0,0,0,0},
 
                                {0,1,1,0,1,1,0,0,1,0},
                                {0,0,0,0,0,0,0,0,0,0},
                                {0,0,0,0,0,1,1,1,1,0},
 
                                {0,0,0,0,0,0,0,0,0,0}
                            };
 
    std::cout   <<  (
                        ships_matr_is_correct( matr )
                            ?   "YES"
                            :   "NO"
                    )
 
                <<  std::endl;
}

@Aymurat · 01.10.2016, 16:46 **[ТС]**

Mr.X, я вообще не работал с контейнерами, векторами и комплексными числами. Хотя бы на словах объясните алгоритм? Да и из-за typedef путаюсь где что, новичку сложно разобраться в таком коде... Да и стиль у вас какой-то странный, везде пробелы) Вот в такую форму привел я:

Кликните здесь для просмотра всего текста

C++

#include <algorithm>
#include <complex>
#include <iostream>
#include <set>
#include <utility>
#include <conio.h>
#include <vector>
const int M = 10;
const int N = 10;
typedef int(&T_matr_ref)[M][N];
typedef int T_coord;
typedef std::complex<T_coord> T_cell;
typedef std::vector<int> T_counters;
typedef std::set<T_cell> T_cells;
typedef T_cells T_ship;
namespace std
{
    bool    operator< (T_cell  const   &   L, T_cell  const  &  R)
    {
        return    std::make_pair(L.real(), L.imag())< std::make_pair(R.real(), R.imag());
    }
}
bool    cells_are_neighbors (T_cell  A, T_cell  B)
{
    return  std::abs(A.real() - B.real()) + std::abs(A.imag() - B.imag()) == 1;
}
bool    cell_on_edge(T_cell    cell)
{
    return   cell.real() == 0 || cell.real() == M - 1 || cell.imag() == 0   || cell.imag() == N - 1;
}
bool    ship_is_correct(T_ship     const   &   ship)
{
    int     i_min = M;
    int     j_min = N;
 
    int     i_max = -1;
    int     j_max = -1;
 
    for (auto cell : ship)
    {
        auto    i = cell.real();
        auto    j = cell.imag();
 
        if (cell_on_edge(cell)) return  false;
 
        if (i < i_min) { i_min = i; }
        if (i > i_max) { i_max = i; }
 
        if (j < j_min) { j_min = j; }
        if (j > j_max) { j_max = j; }
    }//for
 
    auto    delta_i = i_max - i_min;
    auto    delta_j = j_max - j_min;
 
    return   delta_i*delta_j==0 && ++delta_i*++delta_j == int(ship.size());
}
void    search_ship(T_cell & cell,T_matr_ref matr,T_ship  & ship,T_cells & marked_cells)
{
    marked_cells.emplace(cell);
    ship.emplace(cell);
 
    int     i = cell.real();
    int     j = cell.imag();
 
    for (int ii = std::max(i - 1, 0);   ii <= std::min(i + 1, M - 1); ++ii)
    {
        for (int jj = std::max(j - 1, 0);   jj <= std::min(j + 1, N - 1);   ++jj)
        {
            T_cell  cell_cur(ii, jj);
            if (matr[ii][jj] && !marked_cells.count(cell_cur) && cells_are_neighbors(cell_cur, cell))
                search_ship(cell_cur,matr,ship, marked_cells);
        }//for
    }//for
}
bool    ships_matr_is_correct(T_matr_ref    matr)
{
    T_cells     marked_cells;
    T_counters  counters{ 0,4,3,2,1 };
 
    for (size_t i{}; i < M; ++i)
    {
        for (size_t j{}; j < N; ++j)
        {
            if (matr[i][j] == 0) continue;
            T_cell  cell_cur(i, j);
            if (marked_cells.count(cell_cur))continue;
            T_ship  ship;
            search_ship (cell_cur,matr,ship,marked_cells);
            if (ship_is_correct(ship))  --counters[ship.size()];
            else
            return  false;
        }//for
    }//for
    return  counters == T_counters( counters.size() );
}
int main()
{
    int matr[M][N] = {
        { 0,0,0,0,0,0,0,0,0,0 },
        { 0,0,0,0,1,1,1,0,1,0 },
        { 0,0,0,1,0,0,0,0,0,0 },
        { 0,0,0,0,0,1,0,0,0,0 },
        { 0,0,0,1,1,0,1,1,1,0 },
        { 0,0,0,0,0,0,0,0,0,0 },
        { 0,1,1,0,1,1,0,0,1,0 },
        { 0,0,0,0,0,0,0,0,0,0 },
        { 0,0,0,0,0,1,1,1,1,0 },
        { 0,0,0,0,0,0,0,0,0,0 }
    };
    std::cout << (ships_matr_is_correct(matr)? "YES": "NO") << std::endl; 
    _getch();
}

Перегрузка оператора < , для чего она?

@Mr.X · 01.10.2016, 18:29

Сообщение от Aymurat

Вот в такую форму привел я

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

Сообщение от Aymurat

я вообще не работал с контейнерами, векторами и комплексными числами.

Ну, вы же задачи решаете чтобы язык освоить? Тут как раз удобный случай, чтобы с ними ознакомиться, тем более, что в них ничего сложного нет. Как только освоите незнакомые слова, так все сразу ясно станет.

Сообщение от Aymurat

Перегрузка оператора < , для чего она?

Ну, комплексные числа не имеют встроенного оператора <. В моем втором варианте они не используются.

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	27.09.2016, 15:24	2
	Почему строк только 8 задано? Так и задумано? 0

@Aymurat 125 / 117 / 67 Регистрация: 07.11.2014 Сообщений: 788
	27.09.2016, 15:27 [ТС]	3
	nmcf, можно вообще любое кол-во, но не вместится на 4х4 и т.д., а 2 столбца и 2 строки дополнительных - это для того, чтобы не выйти за пределы матрицы. 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	27.09.2016, 15:51	4
	У тебя 10 строк указано в размере (N + 2), а задаёшь только 8. Это нормально? 0

@Aymurat 125 / 117 / 67 Регистрация: 07.11.2014 Сообщений: 788
	27.09.2016, 15:57 [ТС]	5
	nmcf, так при проверке смежных клеток через Test чтобы не выйти за пределы матрицы же) Нормально 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	27.09.2016, 15:59	6
	Но столбцов-то ты 10 инициализируешь нулями/единицами, а строк 8. Не понятно. 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	27.09.2016, 16:46	8
	Отладчиком смотрел? Индексы правильные? 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	27.09.2016, 18:57	10
	Текст ошибки какой? В пошаговом режиме смотри за индексами. 0

@Aymurat 125 / 117 / 67 Регистрация: 07.11.2014 Сообщений: 788
	29.09.2016, 16:59 [ТС]	11
	nmcf, ошибка не при компилировании, а при запуске программы. Такое ощущение, будто делаю что-то невозможное(делю на ноль/выхожу за пределы массива/бесконечный цикл) Но такого не замечаю, да и условие примитивное... 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	29.09.2016, 18:21	12
	Ну вот отладчиком и смотри в пошаговом режиме. 0

@Aymurat 125 / 117 / 67 Регистрация: 07.11.2014 Сообщений: 788
	29.09.2016, 20:49 [ТС]	13
	nmcf, Ну не умею я(( 0

@nmcf 7362 / 6284 / 2856 Регистрация: 14.04.2014 Сообщений: 27,223
	30.09.2016, 14:17	15
	Что там уметь? Точку останова перед этим циклом сделай, запусти, и программа там остановится. Дальше пошагово - в меню посмотри какие клавиши нажимать. 1

@Aymurat 125 / 117 / 67 Регистрация: 07.11.2014 Сообщений: 788
	01.10.2016, 11:12 [ТС]	16
	Mr.X, спасибо, программа работает, но много непонятных моментов, можете прокомментировать код? 0

@Mr.X 3220 / 1747 / 435 Регистрация: 03.05.2010 Сообщений: 3,867
	01.10.2016, 18:29	19
	Сообщение от Aymurat Вот в такую форму привел я Вам правда в такой записи читать легче? Я в ней ни бельмеса не вижу! Сообщение от Aymurat я вообще не работал с контейнерами, векторами и комплексными числами. Ну, вы же задачи решаете чтобы язык освоить? Тут как раз удобный случай, чтобы с ними ознакомиться, тем более, что в них ничего сложного нет. Как только освоите незнакомые слова, так все сразу ясно станет. Сообщение от Aymurat Перегрузка оператора < , для чего она? Ну, комплексные числа не имеют встроенного оператора <. В моем втором варианте они не используются. 1

Проверить правильность расстановки кораблей. Морской бой

Решение