Eight months later haha, but yeah looks good! Cheers

-deleted

My only complaint about this Kata resides in the instructions.

Since this Kata is mostly aimed at novices, I think it would be important that the instructions be as clear as possible.

Comments about the instructions:

• Your section on which types must be supported is superfluous.
• Some sentence structure is a bit confusing.
• you can add csharp to the beginning of a code block (right after the 3 initial backticks) to add syntax highlighting to your code block.

Here's my suggestion for replacing your current instructions:

In this kata, you need to write a generic extension method for List<T> that returns an array of indices that correspond to items in the list that are equal to the given item parameter.

For Example: 
      List<int> myList = new List<int>() { 1, 2, 3, 4, 5, 6, 3, 2 };
      int item = 3;
      myList.GetAllIndex((item); // returns {2, 6}

Note: the returned array should be in ascending order.

Pretty good Kata, I think maybe just missing some clarity in the instructions.

1. I see you've added shuffled input order. I'd update the instructions to reflect this with something like:
   

The order of statements is not guaranteed. As an example: you could receive a purchase instruction before knowing the cost of the product.

And then maybe add an actual shuffled example, like:

For Example:
var input = new List<string>() {  "John has 41$.",
                                  "Apple is 5$.",
                                  "Alice buys 2 apples.",
                                  "Alice has 26$.",
                                  "John buys 1 banana.",
                                  "Alice buys 5 oranges."
                                  "Banana is 7$.",
                                  "Orange is 2$.",
                                  };

2. I'd also make the following changes to your Notes section:
   

• Replace the "Notes" and the "PS" section with a "Notes" and a "Tips" section.
  
• Make some of the constraints and comments more explicit.
  
  Result:
  

Notes:

• Currency is always followed by the $ symbol.
• Output must be ordered by the placement of customers in the input list.
  • Products must be ordered by the order in which they were bought by that customer.
• All input statements will be valid. No need to check for invalid statements.
• Customers will always have enough money for their purchases. No need to validate for negative balances.
• Inputs guarantee that the same customer will not perform multiple purchases for the same product. No need to validate for this.

Tips:

• Be careful about plural suffixes.

haha, nice dude. We have pretty much exactly the same solution, just different variable names.

I enjoyed the challenge, but it in the end it was more an exercise in trial and error and debugging (but not in a good way).

Specifically, unless I missed some vital clue or piece of information, I found it frustrating that in some of the tests the rates were spread out in a way that made it impossible to logically deduce what the ranges for "short" and "medium" rates were meant to be.

Or, as another example, why 10001 == EE, and 100001 == E E

This makes me sad :(

Seemed simple at first, but ended up being much more complex than I originally anticipated. Great challenge, thank you!

Very fun little challenge! Highly recommend doing the Level 2 follow up Kata afterwards!

I really enjoyed working on this! Compared to other difficult Katas, the challenge in this one was making sure the structure of my solution was solid.
Great addition to the Simple Interpreter Kata. Highly recommend completing it first as the author said.

Very simple, felt more on par with a level 6 Kata, but great fun nonetheless. Enjoyed trying to make my solution as short and elegant as possible.

Simple but fun! Thanks for the challenge.

Hella challenging. I feel embarrassed, but I had to inspire myself from a solution I found online. Definitely a mind bender. Thanks for the challenge!

Pretty fun little challenge! Maybe the challenge rating is language dependent, but I completed it in C# and it felt more on par with level 5 Katas I've previously completed.