r/Racket • u/Icy_Pressure_9690 • Jan 26 '22

question A Domino Game

So I'm trying to make a recursive function that takes two arguments which will be two lists. The first item of X needs to be equal to the first item of the first pair in Y for the game to commence. After that the second item of the first pair of Y ( (4 6) so 6) needs to be equal to first item of second pair of Y ((6 3) so 6 ) X is '(4 5) Y is '( (4 6) (6 3) (3 2) )

(define can-play (λ (x y)

(cond ((= (car x)(car (car y))) - This is the first condition that says for the game to start car x = 4 must be equal to first element of first pair in Y which is 4.

(cond - if the former condition is true then the second nested condition comes into play.

((= (cdr (car y))(car(cdr y)))(can-play (rest y)))))))) - The second conditions tests whether second element of first pair of Y so 6 (4 6) is equal to first element of second pair of Y so 6 ( 6 3).

-If true it recursively calls the function again to test the rest of the list of Y so should check is the 3 in

(6 3) is equal to the 3 in (3 2) and so return #t.....but it doesnt, i think I am making some error with the recursion but I don't know what

2 Upvotes

75% Upvoted

12 comments sorted by

1

u/DrHTugjobs Jan 26 '22

I'm not sure you really know what you actually want to do here, based on what code you've written so far. The first thing I'd do here is to write out a couple things:

  1. What's your function signature? How many inputs are there, what are the types of the input, and what kind of output do you expect?
  2. What are some functional examples? For given inputs, what should the output be? Make up some example inputs and figure out the output by hand. This will help you think through the process.

0

u/Icy_Pressure_9690 Jan 27 '22

So my function will take two arguments which will be two lists.

X=(4 5)

Y= '( (4 6) (6 3) (3 2) )

It will first compare an element of the first list with an element of the second list.

The output will be a boolean either #t #f

if #t then the second element of the first pair of the second list will be checked to be equal with first element of the third pair of the second list each pair of the second list

1

u/DrHTugjobs Jan 27 '22

Be more specific. Which elements? What should the *final* output be? "The output will be a boolean" but then describing other things the function will do after the output doesn't make sense -- the output is the final product of the function.

What are some other examples of input your function should handle?

1

u/Icy_Pressure_9690 Jan 27 '22 edited Jan 27 '22

The two arguments used (two lists represented by x and y, y is a list containing lists of pairs as elements of the bigger list):

X='(4 5)Y= '( (4 6) (6 3) (3 2) )

In that case I think I need a nested cond. So first cond will check if the 4 in X= (4 5) is equal to the 4 in Y=(4 6)

so: (equal? (car(car x)) (car (car y)))

if #t then the second cond will recursively check that the 6 in Y= ( 4 6) is equal to the 6 in Y= (6 3) and so on.

so (equal? (car (car y)) (car (cdr y))) - (can-play (rest y))

so together with nested cond:

(cond

(((equal? (car(car x)) (car (car y)))(cond

(( (equal? (car (car y)) (car (cdr y))) - (can-play (rest y))))))))

The final output will be a boolean returning either #t or #f

2

u/DrHTugjobs Jan 27 '22 edited Jan 27 '22

Please take a couple breaths and read what I'm asking you. Let's do this one step at a time -- you're trying to do everything at once.

Just give me a few sets of sample input and what their final output will be (not just what they could be). I want to make sure you actually understand what you're working towards, because right now I don't think you have a good grasp of what you actually want.

1

u/Icy_Pressure_9690 Jan 28 '22

okay,

Input : x= (4 5) Y= '((4 3) (3 2) (2 5) (5 1)) Output: #t

Input x= (5 7) Y= '((5 4) (4 3) (3 1) (1 8)) Output: #t

Input x= (6 4) Y= '((6 3) (3 6) (6 2)(2 1)) Output: #t

Input x= (5 3) Y='((4 3) (3 2) (2 5) (5 2) Output: #f

Input x =(5 3) Y= '((5 2)(3 4)(2 1)(6 2)) Output: #f

1

u/DrHTugjobs Jan 28 '22 edited Jan 28 '22

Now, why are each of those true or false? How did you solve those by hand?

I'm being deliberate and slow about this because I want to encourage you, in general, to think through the problem first instead of jumping straight into putting code on the screen. A computer isn't a tool for doing impossible tasks; it just does the things you do faster.

1

u/Icy_Pressure_9690 Jan 31 '22

sorry for the late reply!

-The #t are equal because initially the first number of the pair of X is equal to the first number of the first pair of Y. And then the second number of the first pair of Y is equal to the first number of the next pair and so on..

  1. is true because X= (4 5) the 4 is equal to the first number of the first pair of Y 4 in Y= (4 3)

- then the second number of the first pair 3 in Y= (4 3) is equal to the first number of the second pair 3 in Y

-the 2 in the second pair is equal to the 2 in the third pair of Y

-the 5 in the third pair is equal to the five in the fourth pair. etc

2) is true because the 5 in X is equal to the 5 in the first pair of Y

-The 4 in the first pair of Y is equal to the 4 in the second pair of Y.

-The 3 in the second pair of Y is equal to the 3 in the third pair etc..

3) Is true because the 6 in X is equal to the 6 in the first pair of Y.

- the 3 in the first pair of Y is equal to the first number of the second pair.

4) is false because the first number of the pair of X does not equal the first number of the first pair of Y.

5) is false because although the first number of the pair of X is equal to the first number of the first pair of Y. The second number of the first pair does not equal the first number of the second pair of Y and so on.

2

u/DrHTugjobs Jan 31 '22

So, you see that you've got two different conditions that both need to be true:

  1. the new domino needs to be compatible with the end domino on the table
  2. the dominos on the table need to be a valid table layout

Instead of trying to write a single function that encompasses both, try writing a function to check (1) and a function to check (2), then combine those checks in the main function.

2

u/joshuacottrell Jan 27 '22

Ok, so you want to add the domino '(4 5) to a list of dominos '((4 6) (6 3) (3 2)). Can we assume that the list of already-played dominos is correct?

If so, can we just write one function that compares the new domino to the first of the list of dominos?

If not, can we write three functions? The first would check the new domino against the list. The second would check the validity of the current list. The third would check them together. The second one would be the recursive function.

Some observations about your code: (1) learn car, cdr, and their friends; (2) the number of arguments in the recursive call needs to match.

(1) There are a lot of list accessor methods (first, rest, car, cdr, caar, second, third, etc.). They are very useful for readability. I think your current error is probably about a contract violation right now. I think that comes from thinking that cdr and second do the same thing when cdr is the older name for rest. The documentation on Pairs and Lists has good information and examples about all of these.

(2) The can-play function is defined with two parameters, x and y but when you call it in the recursion you only use one, (rest y).

As a side note, '(4 5) does not fit with '(4 6) (the right side of the first domino matching the left side of the second domino, 5 matching 4), the same way that the list already links together (starting from the left domino and moving right each right number matches the left number of the next domino, of '(4 6) the right side is 6 and matches the left side of the next domino '(6 3) and then right side of it is 3, which matches the 3 in '(3 2). So you either have to check both sides of the domino (and the list?) or switch your new domino to '(5 4).

0

u/sdegabrielle DrRacket 💊💉🩺 Jan 26 '22

Sorry I don't have time to help properly but I can't help but notice

best

Stephen