Add same character check algorithm.

Description

It checks if all the characters of a string are same.

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/1e541a09eb9d7eb0dbec7feebb3d1d13d7f4c06a/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L35

Bucket sort, or bin sort, is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm. It is a distribution sort, a generalization of pigeonhole sort, and is a cousin of radix sort in the most-to-least significant digit flavor.

Contributing Guidelines

• Add the missing implementation of the Bucket Sort
• Add a test case in the spec that targets the CommonSorting object
• Don't be afraid to submit a new PR
• Have fun!

It would be nice to have a set of templates for bugs, feature requests and Pull Requests.

• create templates on the repository's master branch, inside .github directory

I've added a list of resources to learn the Scala programming language in learning_resources.md. Feel free to improve this file or even to create new useful documentation files within the docs directory.

Add alphabetical ordering algorithm.

Description

Alphabetical order is a system whereby character strings are placed in order based on the position of the characters in the conventional ordering of an alphabet. Wikipedia: https://en.wikipedia.org/wiki/Alphabetical_order

Update the whole project to Scala 3

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/1e541a09eb9d7eb0dbec7feebb3d1d13d7f4c06a/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L34

Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value. A positional notation is required, but because integers can represent strings of characters (e.g., names or dates) and specially formatted floating point numbers, radix sort is not limited to integers.

Contributing Guidelines

• Add the missing implementation of the Radix Sort
• Add a test case in the spec that targets the CommonSorting object
• Don't be afraid to submit a new PR
• Have fun!

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/1e541a09eb9d7eb0dbec7feebb3d1d13d7f4c06a/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L111

Contributing Guidelines

• Add the missing implementation of the Comb Sort
• Add a test case in the spec that targets the CommonSorting object
• Don't be afraid to submit a new PR
• Have fun!

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/356882e5429755c4a52d2553e800c473f710a5d4/src/main/scala/io/github/sentenza/hacktoberfest18/adt/Tree.scala#L56

Contributing Guidelines

• Add the missing implementation
• Add a test case in the specs
• Don't be afraid to submit a new PR
• Have fun!

Add vowel counting algorithm.

Description

Count the number of occurrences of vowels in a given string.

We should aim at refactoring the current CommonSortings object in order to create two different implementations: the first one will use scala.collection.immutable, while the second one will keep the current implementation provided by the CommonSorting object.

The trait that has to be refactored is:

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/1e541a09eb9d7eb0dbec7feebb3d1d13d7f4c06a/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L25

We could have something like a GeneralSorting trait, and two implementations:

• MutableSorting
• ImmutableSorting

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/356882e5429755c4a52d2553e800c473f710a5d4/src/main/scala/io/github/sentenza/hacktoberfest18/adt/Tree.scala#L48

Contributing Guidelines

• Add the missing implementation
• Add a test case in the specs
• Don't be afraid to submit a new PR
• Have fun!

Contributing Guidelines

• Each new contribution should be added to the /sort folder

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/456108fbc8e36072099debb2704f8b37002e8795/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L28

• It is your choice to include only a function or an entire trait/object/class to describe the algorithm you worked on .
• If the folder/file does not exist, create a new one.
• Don't be afraid to make a Pull Request!

Link back all the algorithms already implemented in our codebase with DIRECTORY.md

Resources:

https://www.geeksforgeeks.org/binary-search/

Add an algorithm to search for the longest palindromic sub-string in a given string

Implement this method

(From Wikipedia)

In computer science, the Boyer–Moore–Horspool algorithm or Horspool's algorithm is an algorithm for finding substrings in strings. It was published by Nigel Horspool in 1980.

https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore%E2%80%93Horspool_algorithm

Add check anagrams algorithm.

Two strings are anagrams if they are made of the same letters arranged differently (ignoring the case).

Fix combSort

What we should aim for is to change the way we fetch the input from the console and then manage the loop that keeps showing the prompt.

We need:

• out of the loop - print the LOGO and disclaimer
• on request and at the very beginning: show the list of types (searching, sorting)
• a showPrompt(): Unit method to print out a prompt to select the type of algorithm to execute
• after selecting the type, we should give the user the ability to pick up one of the implemented algorithms
• print out the results, and the loop begins again
• the loop must be annotated with @tailrec

/**
  * A fairly standard "print this out" / "read this in" Scala recursive function
  */
@tailrec
def mainLoop(appState: AppState) {
    // a) prompt the user for input
    // b) get the user's input
    // c) execute the chosen algorithm / show a menu
    // d) write the output
    // e) if the user didn't type 'q' or 'quit' loop again
    mainLoop(newAppState)
}

Definition of Pangram https://en.wikipedia.org/wiki/Pangram

Add implementation of this method

Describe the bug
After selecting "Sorting Algorithms" we should prompt the user for choosing a particular category of algos and then list the elements in that category.

To Reproduce
Run the program:

1. Choose 1. Sorting
2. The main loop runs again

Expected behavior
We should see, at the very least the sorting algos and then ask for a list of comma separated integers.

https://github.com/sentenza/hacktoberfest-scala-algorithms/blob/1e541a09eb9d7eb0dbec7feebb3d1d13d7f4c06a/src/main/scala/io/github/sentenza/hacktoberfest18/sort/CommonSortings.scala#L33

Counting sort is an algorithm for sorting a collection of objects according to keys that are small integers; that is, it is an integer sorting algorithm. It operates by counting the number of objects that have each distinct key value, and using arithmetic on those counts to determine the positions of each key value in the output sequence.

Contributing Guidelines

• Add the missing implementation of the Counting Sort
• Add a test case in the spec that targets the CommonSorting object
• Don't be afraid to submit a new PR
• Have fun!