Simple C++ problem - C++ 101

[nicholas_ian_reese]

Hi all,

I am tutoring introductory computer science in the Solomon Islands and
we are using C++ as the language of choice (nice). Please note that I
am no way a C++ programmer, but have but I have programmed in most
mainstream languages over the paste 20 years. We are learning HOW to
code, not just C++. The dudes in the class have their final assignment
in a couple of days and we have a simple problem to overcome. The
problem is this:

The program reads in an array of integers which instructs a robot which
direction to go in, in a 20 x 20 grid. The first two integers (read in
from a file) are the starting position of the robot, and have to be
validated in a function as a valid position within the 20 x 20 grid.
The starting postions are global variables in the file. The boolean
'valid' is declared as false also as a global. The code to validate is
as follows:

void check_valid( )
{
if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 || start_y <=
20)) // you know what I mean
{
valid = true;
}
}

The problem is that if the initial start_x and start_y positions ARE
valid, the 'if' logic never work. Any replies come with a big Thanks In
Advance for these guys trying to get through their course in a time of
great uncertainty in the Solomons (just do a Google search and find out
about the troubles we've been through in the last few weeks).

Nick

[sillyemperor]

ni****************@hotmail.com wrote:

Hi all,

I am tutoring introductory computer science in the Solomon Islands and
we are using C++ as the language of choice (nice). Please note that I
am no way a C++ programmer, but have but I have programmed in most
mainstream languages over the paste 20 years. We are learning HOW to
code, not just C++. The dudes in the class have their final assignment
in a couple of days and we have a simple problem to overcome. The
problem is this:

The program reads in an array of integers which instructs a robot which
direction to go in, in a 20 x 20 grid. The first two integers (read in
from a file) are the starting position of the robot, and have to be
validated in a function as a valid position within the 20 x 20 grid.
The starting postions are global variables in the file. The boolean
'valid' is declared as false also as a global. The code to validate is
as follows:

void check_valid( )
{
if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 || start_y <=
20)) // you know what I mean
{
valid = true;
}
}

The problem is that if the initial start_x and start_y positions ARE
valid, the 'if' logic never work. Any replies come with a big Thanks In
Advance for these guys trying to get through their course in a time of
great uncertainty in the Solomons (just do a Google search and find out
about the troubles we've been through in the last few weeks).

Nick

i run your code like this

//main.cpp
#include <iostream>

using namespace std;

bool valid = false;
int start_x = 2;
int start_y = 3;

int main()
{
if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 || start_y <=
20))
{
valid = true;
cout<<"hello"<<endl;
}
return 0;
}

//output
hello

what`s wrong!

[Abdo Haji-Ali]

ni****************@hotmail.com wrote:

void check_valid( )
{
if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 || start_y <=
20)) // you know what I mean
{
valid = true;
}
}

The problem is that if the initial start_x and start_y positions ARE
valid, the 'if' logic never work. Any replies come with a big Thanks In
Advance for these guys trying to get through their course in a time of
great uncertainty in the Solomons (just do a Google search and find out
about the troubles we've been through in the last few weeks).

On the contrary, valid is set to true whatever the value of start_x and
start_y because any number is "bigger than 0 *or* less than 20", you
probably meant:
if ((start_x >= 0 && start_x <= 20) && (start_y >= 0 && start_y <=
20))
valid = true;

This would set valid to true if both start_x and start_y are in the
range [0,20]

Abdo Haji-Ali
Programmer
In|Framez

[Abdo Haji-Ali]

Abdo Haji-Ali wrote:

ni****************@hotmail.com wrote:

void check_valid( )
{
if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 || start_y <=
20)) // you know what I mean
{
valid = true;
}
}

The problem is that if the initial start_x and start_y positions ARE
valid, the 'if' logic never work. Any replies come with a big Thanks In
Advance for these guys trying to get through their course in a time of
great uncertainty in the Solomons (just do a Google search and find out
about the troubles we've been through in the last few weeks).

On the contrary, valid is set to true whatever the value of start_x and
start_y because any number is "bigger than 0 *or* less than 20", you
probably meant:
if ((start_x >= 0 && start_x <= 20) && (start_y >= 0 && start_y <=
20))
valid = true;

This would set valid to true if both start_x and start_y are in the
range [0,20]

Forgot to mention that you probably need a range of [0,19] if the size
of the grid is 20...

Abdo Haji-Ali
Programmer
In|Framez

[Henryk]

Good point.

But then you could write a one-liner like

void check_valid( )
{
valid = (start_x >= 0) && (start_x < 20) && (start_y >= 0) &&
(start_y < 20);
}

Looks nicer... :o)

Henryk

[Zara]

## Abdo Haji-Ali wrote:
## > ni****************@hotmail.com wrote:
## > >
## > > void check_valid( )
## > > {
## > > if ((start_x >= 0 || start_x <= 20) && (start_y >= 0 ||
start_y <=
## > > 20)) // you know what I mean
## > > {
## > > valid = true;
## > > }
## > > }
## > >
## >
## > On the contrary, valid is set to true whatever the value of
start_x and
## > start_y because any number is "bigger than 0 *or* less than
20", you
## > probably meant:
## > if ((start_x >= 0 && start_x <= 20) && (start_y >= 0 && start_y
<=
## > 20))
## > valid = true;
## >
## Forgot to mention that you probably need a range of [0,19] if the
size
## of the grid is 20...
##

On 18 May 2006 03:38:09 -0700, "Henryk" <he************@gmx.de> wrote:

Good point.

But then you could write a one-liner like

void check_valid( )
{
valid = (start_x >= 0) && (start_x < 20) && (start_y >= 0) &&
(start_y < 20);
}

I thnik it could be nicer if:
- you quote previous messages
- you use unsigned int instead of signed int for the values start_x
and start_y, so that the test shrinks to:

void check_valid( )
{
valid = (start_x < 20) && (start_y < 20);
}
Regards,

Zara

[Jerry Coffin]

In article <g4********************************@4ax.com>,
yo****@terra.es says...

[ ... ]

- you use unsigned int instead of signed int for the values start_x
and start_y, so that the test shrinks to:

void check_valid( )
{
valid = (start_x < 20) && (start_y < 20);
}

As long as we're at it, why not use the return value:

bool isValidPos(unsigned x, unsigned y) {
return x < 20 && y < 20;
}

Of course, that has the minor problem that it spreads
magic numbers all over the place. For real code, I'd
prefer something like:

class SizeChecker() {
unsigned max_x, max_y;
public:
isValid(unsigned x, unsigned y)
: max_x(x), max_y(y)
{}

bool operator()(unsigned x, unsigned y) {
return x<max_x && y < max_y;
}
};

This makes life a lot easier when you decide to allow
their robot to roam in 200x200 grid instead of 20x20. You
create the isValid object specifying the maximum
dimensions, then use it as a function object to check the
size:

const unsigned max_x = 20, max_y = 20;

SizeChecker isValid(max_x, max_y);

if (isValid(their_x, their_y))
std::cout << "Valid starting point\n";
else
std::cout << "Invalid starting point\n";

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Puppet_Sock]

Zara wrote:
[snip]

I thnik it could be nicer if:
- you quote previous messages
- you use unsigned int instead of signed int for the values start_x
and start_y, so that the test shrinks to:

void check_valid( )
{
valid = (start_x < 20) && (start_y < 20);
}

Sure. But the context of the OP does not provide enough
information to know if the values can ever meaningfully
be less than 0. For example, is the start grid simply the
"legal" start position in a larger grid? Or is that the entire
range allowed and negative numbers are meaningless?

Maybe when they are outside the valid range the robot
has to "hunt" for its home instead of doing the normal
thing it does at home. Just as an example.
Socks

[Diego Martins]

Puppet_Sock wrote:

Zara wrote:
[snip]

I thnik it could be nicer if:
- you quote previous messages
- you use unsigned int instead of signed int for the values start_x
and start_y, so that the test shrinks to:

void check_valid( )
{
valid = (start_x < 20) && (start_y < 20);
}

Sure. But the context of the OP does not provide enough
information to know if the values can ever meaningfully
be less than 0. For example, is the start grid simply the
"legal" start position in a larger grid? Or is that the entire
range allowed and negative numbers are meaningless?

Maybe when they are outside the valid range the robot
has to "hunt" for its home instead of doing the normal
thing it does at home. Just as an example.
Socks

so, can we discuss algorithms here? I have many problems to expose...

[Puppet_Sock]

Diego Martins wrote:
[snip]

so, can we discuss algorithms here? I have many problems to expose...

If the question is how to do it in standard C++ language, probably it
is on topic.

If the question is what is the algorithm for particular tasks, probably
it is off topic and likely there are better places to ask.

Check out groups.google.com and see if any group discusses the
issues you have in mind. Maybe the answer to your questions are
already posted.
Socks

[Diego Martins]

Puppet_Sock wrote:

Diego Martins wrote:
[snip]

so, can we discuss algorithms here? I have many problems to expose...

If the question is how to do it in standard C++ language, probably it
is on topic.

If the question is what is the algorithm for particular tasks, probably
it is off topic and likely there are better places to ask.

Check out groups.google.com and see if any group discusses the
issues you have in mind. Maybe the answer to your questions are
already posted.
Socks

people who spend too much time in the Internet lose their capabilities
about irony detection

:-(

[Puppet_Sock]

Diego Martins wrote:
[snip]

people who spend too much time in the Internet lose their capabilities
about irony detection

Except that this is usenet.
Socks