Форум программистов, компьютерный форум CyberForum.ru

Шахматы. Каждый ферзь бьет ровного одного ферзя - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Segmentation fault http://www.cyberforum.ru/cpp-beginners/thread1196172.html
Доброго времени суток. Столкнулся в программе с ошибкой Segmentation fault. Вообще, задача отсортировать данные по одному из параметров, но из-за ошибки я до до написания сортировки не доберусь. Сигнал SIGSEGV отладчик возвращает с указанием на 99 строку: #include <iostream> #include <stdio.h> #include <cstdio> #include <cstdlib> #include <string> using namespace std; int main()
C++ Объяснить работу программы Здравствуйте. Такая задача была: Задача 2. Дано натуральное число. Определить, является ли число палиндромом, т.е. читается одинаково слева направо и справа налево. Массивы и строки не использовать. Нашёл на форуме подходящую рабочую программу, но не могу полностью понять (и объяснить), как она работает. Вроде в цикле с предусловием аналоги mod/div, а в цикле с параметром что - не понятно.... http://www.cyberforum.ru/cpp-beginners/thread1196167.html
C++ Вывод двумерного массива
Нужно сделать вывод как на картинке. я пробовал но у меня возникли некоторые сложности for(int i = 0; i<26; ++i) { for ( int j=0; j<26; ++j) { int sdvig = i+j;
Организовать класс треугольник, определенный по координатам вершин и содержащий конструктор, деструктор C++
помогите пожалуйста исправить лабораторную, так как треугольник задан векторами, в нем надо убрать переменные Р h и Dlina и сделать функции возвращающими, задание гласит:Организовать класс треугольник, определенный по координатам вершин и содержащий конструктор, деструктор, функции нахождения длин сторон, периметра, и высоты на большую сторону. Исходный код: #include <iostream> #include...
C++ Ввести одномерный массив из n элементов. Определить число различных элементов в нем http://www.cyberforum.ru/cpp-beginners/thread1196131.html
Возникла небольшая проблема. Нужно сделать элементарное задание, но чтобы было несколько функций пользователя. Задание: Ввести одномерный массив из n элементов. Определить число различных элементов в нем. #include "iostream" #include "conio.h" using namespace std; void mass (int *i) { int j, A; j=0; while (j<*i)
C++ Описание функции getopt Распишите описание функции getopt и её использование с ключами. подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
3040 / 1685 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
03.06.2014, 20:30     Шахматы. Каждый ферзь бьет ровного одного ферзя
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
/////////////////////////////////////////////////////////////////////////////////////////
//Расставить на шахматной доске максимальное число ферзей так, чтобы каждый нападал 
//ровно на одного ферзя.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <conio.h>
#include <functional>
#include <iostream>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
int     const   BOARD_SIZE  =   8;
int     const   MAX_COORD   =   BOARD_SIZE - 1;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_queen
{
    int     x_;
    int     y_;
    int     attack_counter_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_queen
        (
            int     x   =   0,
            int     y   =   0
        )
        :
        x_                  ( x ),
        y_                  ( y ),
        attack_counter_     ()
    {}
    //-----------------------------------------------------------------------------------
    void  print()                               const
    {
        std::cout   <<  std::complex<int>
                            (
                                x_ + 1,
                                y_ + 1
                            );
    }
    //-----------------------------------------------------------------------------------
    void  clear_attack_counter()
    {
        attack_counter_  =   0;
    }
    //-----------------------------------------------------------------------------------
    T_queen  get_queen_with_next_pos()          const
    {
        T_queen     queen( *this );
        queen.inc_pos();
        return  queen;
    }
    //-----------------------------------------------------------------------------------
    bool  is_max_pos()                          const
    {
        return      x_  ==  MAX_COORD
                &&  y_  ==  MAX_COORD;
    }
    //-----------------------------------------------------------------------------------
    void  inc_pos()
    {
        if( x_ < MAX_COORD )
        {
            ++x_;
        }
        else if( y_ < MAX_COORD )
        {
            x_  =   0;
            ++y_;
        }
    }
    //-----------------------------------------------------------------------------------
    void  check_attack( T_queen  &   queen )
    {
        int     X_abs_dist  =   abs( x_ - queen.x_ );
        int     Y_abs_dist  =   abs( y_ - queen.y_ );
 
        bool    is_attack   =           ( X_abs_dist - Y_abs_dist ) 
                                    *   X_abs_dist 
                                    *   Y_abs_dist
                                ==  0;
 
        if( is_attack )
        {
            inc_attack_counter          ();
            queen.inc_attack_counter    ();
        }
    }
    //-----------------------------------------------------------------------------------
    void  inc_attack_counter()
    {
        ++attack_counter_;
    }
    //-----------------------------------------------------------------------------------
    operator int()          const
    {
        return  attack_counter_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector< T_queen    >  T_position;
typedef std::vector< T_position >  T_positions;
/////////////////////////////////////////////////////////////////////////////////////////
void  clear_all_attack_counters( T_position   &   position )
{
    std::for_each
        (
            position.begin(),
            position.end(),
            std::mem_fun_ref( &T_queen::clear_attack_counter )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  count_attacks( T_position   &   position )
{
    for( size_t  i = 0; i < position.size(); ++i )
    {
        for( size_t  j = i + 1; j < position.size(); ++j )
        {
            position[i].check_attack( position[j] );
        }//for
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int  max_attack_counter( T_position  const   &   position )
{
    return  *std::max_element
                (
                    position.begin  (),
                    position.end    ()
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  position_is_bad( T_position   &   position )
{
    clear_all_attack_counters    ( position );
    count_attacks                ( position );
    return  max_attack_counter   ( position )    >   1;
}
/////////////////////////////////////////////////////////////////////////////////////////
int  min_attack_counter( T_position  const   &   position )
{
    return  *std::min_element
                (
                    position.begin  (),
                    position.end    ()
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  position_is_good( T_position  &   position )
{
    clear_all_attack_counters    ( position );
    count_attacks                ( position );
 
    return      min_attack_counter( position )  ==  1
            &&  max_attack_counter( position )  ==  1;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  go_to_next_not_bad_position( T_position  &   position )
{
    if  (
            position.back().is_max_pos()
        )
    {
        position.pop_back();
 
        if  (
                position.empty()
            )
        {
            return;
        }
        else
        {
            position.back().inc_pos();
        }//else
    }
    else
    {
        position.push_back
            (
                position.back().get_queen_with_next_pos()
            );
    }
 
    while   (
                position_is_bad( position )
            )
    {
        if  (
                position.back().is_max_pos()
            )
        {
            go_to_next_not_bad_position( position );
        }
        else
        {
            position.back().inc_pos();
        }
    }//while
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_queens_position( T_position  const   &   position )
{
    std::for_each
        (
            position.begin      (),
            position.end        (),
            std::mem_fun_ref    ( &T_queen::print )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  find_and_print_good_positions( T_position   &   good_position_with_max_size )
{
    size_t      max_good_position_size   =   0;
 
 
    T_position  position
                    (
                        1,
                        T_queen()
                    );
 
 
    while   (
                !position.empty()
            )
    {
        if  (
                    position_is_good    ( position )
                &&      position.size   ()
                    >=  max_good_position_size
            )
        {
            good_position_with_max_size     =   position;
            max_good_position_size          =   position.size();
            print_queens_position( position );
            std::cout   <<  std::endl;
        }//if
 
        go_to_next_not_bad_position( position );
    }//whle
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
    T_position  position;
    find_and_print_good_positions( position );
}
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru