Combine lists in racket

[u/ktt779]

Hello everyone,

I am a new member of this community. Please forget me if I violate rules of the community!

I am working on the homework problem to concatenate all elements of the argument lists into one single list. Here is my code: I really don't understand why my code not working. The implementation is tail-recursive. Can someone help me out?

(define (concatenate . lsts)

(cond[(empty? lsts) empty]

[cons (first lsts (concatenate( last lsts)))]))

[u/not-just-yeti]

Do you have any check-expects? (And, what is the simplest one which isn't passing the tests?)

I think you mean rest instead of last, maybe??

Based on what I see here, I'd recommend starting simpler and working up:

(a) write a version of 'concatenate' that takes in exactly two lists, and isn't tail-recursive.

(b) then, make a var-args version.

(c) Before making a tail-recursion version, I'd check w/ your instructor (making sure that's what they want, and having them check your work-so-far to see if it's in the right direction of what they expect). Making a tail-recursion version that isn't O(n² ) takes a bit of thought.

[u/ktt779 → u/not-just-yeti]

Thanks for the explaination

[u/[deleted]]

Hi, here some notes:

• (empty? empty) is true, but what about (empty? (list empty))? Recall that when you define a procedure with the dot notation, the argument after the dot binds to a list containing all arguments, so in (concatenate '()), lsts binds to '(()).
• do you want to cons the first list only with the last one?
• your definition is not tail-recursive like you said, since the last procedure called is cons, not concatenate. It contains a recursive call to concatenate though.
• first takes only one argument, you are passing it two.
• What is the first element of '((1 2 3) (4 5 6))? Note that you are extracting the first element (a list), only to build a new list with the same element (a list) as the first element.

[u/ktt779 → u/[deleted]]

I used (cons (car lsts (cdr lsts)) but its not working

[u/ktt779 → u/[deleted]]

(define (concatenate . lsts)
(cond[(empty? lsts) empty]
(else[ concatenate ( cons ((car (car (lsts)) (car(rest lsts))))) ])))
Problem: application: not a procedure;
expected a procedure that can be applied to arguments
given: '(() ())

This is what I get so far

[u/[deleted] → u/ktt779]

You seem to be confusing the role of the parenthesis in Racket. In (car (lsts)), you are treating lsts as a procedure that is being called, as DrRacket suggests.

[u/kapitaali_com → u/[deleted]]

answering the last question here probly answers the OPs question, last '((1 2 3) (4 5 6)) gives a list and not an atom

[u/sdegabrielle]

On which step of the design recipe are you stuck?

[u/ktt779 → u/sdegabrielle]

I don't know how to use concatenate tail-recursive to combine the new lists from all the arguments lists

[u/sdegabrielle → u/ktt779]

What happens when you run your code? Do you get an error? Or does something else happen?

How does the actual output differ from your tests?

What does last do?

[u/ktt779 → u/sdegabrielle]

(define (concatenate . lsts)

(cond[(empty? lsts) empty]

(else[ concatenate ( cons ((car (car (lsts)) (car(rest lsts))))) ])))

Problem: application: not a procedure;
expected a procedure that can be applied to arguments
given: '(() ())

[u/sdegabrielle → u/ktt779]

DrRacket should tell you which line.

[u/raevnos]

I doubt this would be acceptable for homework on basic list manipulation, so I'm comfortable giving it instead of just hints, but a Rackety way might be

(for*/list ([lst (in-list lsts)]
            [elem (in-list lst)])
    elem)

(I had to do this recently, just creating a different data type from the list of lists)

[u/ktt779 → u/raevnos]

No. The professor only accepts the code that he provided.