Algorithm Speed (2.00) :

Array Size (100) :

Spaghetti Sort :

Author(s) : A. K. Dewdney Date : 1984

Spaghetti sort, similar to bead sort, is a theoretical sorting algorithm that involves manipulating physical spaghetti strands. The strands are initially mixed, and then sorting is achieved by repeatedly picking a random pair of strands and swapping them if they are in the wrong order. Due to its reliance on physical manipulation and randomness, spaghetti sort is not a practical sorting method for most applications.

Time Complexity	O(n)
Best Case	O(n)
Worst Case	O(n)
Space Complexity	O(n²)
Stable	Yes

import random

def spaghetti_sort(noodles):
	sorted_noodles = []
	while len(noodles) > 0:
		longest_noodle = max(noodles)
		sorted_noodles.append(longest_noodle)
		noodles.remove(longest_noodle)
	return sorted_noodles

# Example usage with random noodle lengths
noodle_lengths = [random.randint(1, 100) for _ in range(20)]
print("Original noodles:", noodle_lengths)
sorted_noodles = spaghetti_sort(noodle_lengths.copy())  # Avoid modifying the original list
print("Sorted noodles:", sorted_noodles)

function spaghettiSort(noodles) {
	// Sorts a list of noodle lengths (integers) using the spaghetti sort method.
	const sortedNoodles = [];
	while (noodles.length > 0) {
		const longestNoodle = Math.max(...noodles);
		sortedNoodles.push(longestNoodle);
		noodles.splice(noodles.indexOf(longestNoodle), 1);
	}
	return sortedNoodles;
}

// Example usage with random noodle lengths
const noodleLengths = Array.from({ length: 20 }, () => Math.floor(Math.random() * 100) + 1);
console.log("Original noodles:", noodleLengths);
const sortedNoodles = spaghettiSort([...noodleLengths]);
console.log("Sorted noodles:", sortedNoodles);

public class SpaghettiSort {
	public static int[] spaghettiSort(int[] noodles) {
		// Sorts a list of noodle lengths (integers) using the spaghetti sort method.
		List<Integer> sortedNoodles = new ArrayList<>();
		while (noodles.length > 0) {
			int longestNoodle = Arrays.stream(noodles).max().getAsInt();
			sortedNoodles.add(longestNoodle);
			int[] remainingNoodles = Arrays.stream(noodles).filter(n -> n != longestNoodle).toArray(Integer[]::new);
			noodles = remainingNoodles;
		}
		return sortedNoodles.stream().mapToInt(i -> i).toArray();
	}

	public static void main(String[] args) {
		int[] noodleLengths = new int[20];
		for (int i = 0; i < noodleLengths.length; i++) {
			noodleLengths[i] = (int) (Math.random() * 100) + 1;
		}
		System.out.println("Original noodles:" + Arrays.toString(noodleLengths));
		int[] sortedNoodles = spaghettiSort(noodleLengths.clone());
		System.out.println("Sorted noodles:" + Arrays.toString(sortedNoodles));
	}
}

package main

import (
	"fmt"
	"math/rand"
)

func spaghettiSort(noodles []int) []int {
	// Sorts a list of noodle lengths (integers) using the spaghetti sort method.
	sortedNoodles := []int{}
	for len(noodles) > 0 {
		longestNoodle := 0
		for _, n := range noodles {
			if n > longestNoodle {
				longestNoodle = n
			}
		}
		sortedNoodles = append(sortedNoodles, longestNoodle)
		noodles = remove(noodles, longestNoodle)
	}
	return sortedNoodles
}

func remove(noodles []int, longestNoodle int) []int {
	result := []int{}
	for _, n := range noodles {
		if n != longestNoodle {
			result = append(result, n)
		}
	}
	return result
}

func main() {
	noodleLengths := make([]int, 20)
	for i := range noodleLengths {
		noodleLengths[i] = rand.Intn(100) + 1
	}
	fmt.Println("Original noodles:", noodleLengths)
	sortedNoodles := spaghettiSort(append([]int{}, noodleLengths...))
	fmt.Println("Sorted noodles:", sortedNoodles)
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int *spaghettiSort(int *noodles, int n) {
	// Sorts a list of noodle lengths (integers) using the spaghetti sort method.
	int *sortedNoodles = malloc(n * sizeof(int));
	for (int i = 0; i < n; i++) {
		sortedNoodles[i] = 0;
	}
	while (n > 0) {
		int longestNoodle = noodles[0];
		for (int i = 1; i < n; i++) {
			if (noodles[i] > longestNoodle) {
				longestNoodle = noodles[i];
			}
		}
		sortedNoodles[n - 1] = longestNoodle;
		int *remainingNoodles = malloc((n - 1) * sizeof(int));
		int j = 0;
		for (int i = 0; i < n; i++) {
			if (noodles[i] != longestNoodle) {
				remainingNoodles[j++] = noodles[i];
			}
		}
		free(noodles);
		n = n - 1;
		noodles = remainingNoodles;
	}
	return sortedNoodles;
}

int main() {
	srand(time(NULL));
	int noodleLengths[20];
	for (int i = 0; i < 20; i++) {
		noodleLengths[i] = rand() % 100 + 1;
	}
	printf("Original noodles: ");
	for (int i = 0; i < 20; i++) {
		printf("%d ", noodleLengths[i]);
	}
	printf("\n");
	int *sortedNoodles = spaghettiSort(noodleLengths, 20);
	printf("Sorted noodles: ");
	for (int i = 0; i < 20; i++) {
		printf("%d ", sortedNoodles[i]);
	}
	printf("\n");
	free(sortedNoodles);
	return 0;
}