In Haskell, the test contains an array which is not of type [Int], but it should be so if you look at the task and function's type declaration.
Also (-6850,[7003,-6850,7003]) is an even length array.

I definitely think the description needs to specify that the "yes" answers must be strictly increasing sequences. Thus, anything such as [1 2 2 3] and [1 2 3 3] are considered "no".

To be clear, I did solve it in the way the author intended, but I think the description needs to be a bit more precise.

In Haskell, the test contains an array which is not of type [Int], but it should be so if you look at the task and function's type declaration.

Also (-6850,[7003,-6850,7003]) is an even length array.

This comment is hidden because it contains spoiler information about the solution

"return" doesn't mean "assign to the arguments".

This comment is hidden because it contains spoiler information about the solution

Clojure: duplicate entries automatically render an entire collection as unsorted. Please either adjust the instructions or adjust the tests.

This comment is hidden because it contains spoiler information about the solution

Tests should include scenario where 2 array elements are same value (especially the first 2)

Or it should guarantee such scenario is not possible.

C translation is ready. Let me know if there are any issues / fixes you'd like to see.

Your sample test maybe hava mistake,it can't run correctly.

log

before Node {

data: -8,

next: Node { data: 23, next: Node { data: -8, next: [Object] } } }

after Node {

data: -7,

next: Node { data: 23, next: Node { data: -8, next: [Object] } } }

before Node {

data: 23,

next: Node { data: -8, next: Node { data: 74, next: [Object] } } }

after Node {

data: 24,

next: Node { data: -8, next: Node { data: 74, next: [Object] } } }

before Node {

data: -8,

next: Node { data: 74, next: Node { data: 70, next: [Object] } } }

after Node {

data: -7,

next: Node { data: 74, next: Node { data: 70, next: [Object] } } }

before Node {

data: 74,

next: Node { data: 70, next: Node { data: 89, next: [Object] } } }

after Node {

data: 75,

next: Node { data: 70, next: Node { data: 89, next: [Object] } } }

before Node {

data: 70,

next: Node { data: 89, next: Node { data: 83, next: [Object] } } }

after Node {

data: 71,

next: Node { data: 89, next: Node { data: 83, next: [Object] } } }

before Node {

data: 89,

next: Node { data: 83, next: Node { data: 1, next: [Object] } } }

after Node {

data: 90,

next: Node { data: 83, next: Node { data: 1, next: [Object] } } }

Expected: [-8, 23, -8, 74, 70, 89, 83, 1, 3, 1, 43, 50, 20, -3, 44, 6, 12, -2, 49, 38, 84, -8, 29], instead got: [-7, 24, -7, 75, 71, 90, 84, 2, 4, 2, 44, 51, 21, -2, 45, 7, 13, -1, 50, 39, 85, -7, 30]

why it same input

An array containing one number twice can't be considered strictly ascending or descending. Please fix your testcases or description.

Cofee Script translation description fixed please accept

The code i've written passed the sample and the random test but i keep on getting a signal code: 11 that's preventing me from completing this Kata.

I'm kinda new to programming, does anyone know what signal code: 11 means?

This comment is hidden because it contains spoiler information about the solution

This comment is hidden because it contains spoiler information about the solution

I definitely think the description needs to specify that the "yes" answers must be strictly increasing sequences. Thus, anything such as [1 2 2 3] and [1 2 3 3] are considered "no".

To be clear, I did solve it in the way the author intended, but I think the description needs to be a bit more precise.

## Loading more items...