3026: Linear Sort - Revision history

CalibansCreations: /* Transcript */ it's complete enough to me

2025-02-05T09:38:04Z

‎Transcript: it's complete enough to me

Whoop whoop pull up: /* Explanation */

2025-01-16T00:49:38Z

‎Explanation

162.158.74.49: /* Explanation */ Whether this comic is a reference to it is debatble, but there are definite similarities

2025-01-11T20:44:22Z

‎Explanation: Whether this comic is a reference to it is debatble, but there are definite similarities

Firestar233: i don't see how this is related to statistics, added by same user who added another weird category

2025-01-11T08:21:38Z

i don't see how this is related to statistics, added by same user who added another weird category

162.158.154.124 at 08:17, 11 January 2025

2025-01-11T08:17:56Z

172.69.225.244: /* Explanation */ Specified that no linear time sorting algorithms exist.

2025-01-04T11:42:07Z

‎Explanation: Specified that no linear time sorting algorithms exist.

172.68.205.93: Undo revision 360906 by 172.71.214.52 (talk) Sleep != Dream

2025-01-03T01:06:01Z

Undo revision 360906 by 172.71.214.52 (talk) Sleep != Dream

172.71.214.52 at 23:57, 2 January 2025

2025-01-02T23:57:16Z

172.71.214.53 at 02:02, 26 December 2024

2024-12-26T02:02:42Z

162.158.74.25: /* Explanation */ A bit of a rewrite of the rewrite of the rewrite.

2024-12-23T20:33:26Z

‎Explanation: A bit of a rewrite of the rewrite of the rewrite.

@@ Line 19: / Line 19: @@
 ==Transcript==
 :[The panel shows five lines of code:]
 :function LinearSort(list):

@@ Line 12: / Line 12: @@
 {{w|Sorting algorithm}}s are a fundamental part of computer science, with various methods differing in efficiency, ease of implementation, and resource usage. Efficiency is often described using {{w|Big O notation}}, which expresses how the runtime of an algorithm scales with the size of the input. For example, "O(''n'')" ("linear time") means the runtime grows proportionally to the size of the input, while "O(''n'' log ''n'')" means it grows slightly faster than linear. Faster algorithms, like O(''n''), are generally preferred for large datasets. However, it is known that no general sorting algorithms with linear runtime exist.
-The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on. Another 'sort' that technically works but takes more time is necessary, by definition, is the [https://www.geeksforgeeks.org/sleep-sort-in-python/ sleep sort].
+The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on. Another 'sort' that technically works but takes more time than is necessary, by definition, is the [https://www.geeksforgeeks.org/sleep-sort-in-python/ sleep sort].
 The humor lies in the absurdity of intentionally slowing down a sorting algorithm to match a desired runtime profile. This defeats the purpose of optimization, as the goal of sorting algorithms is typically to minimize time spent, not to pad it with unnecessary delays. (Delays may be necessary for other functional reasons, but are an antithesis of the kind of optimality sought here.) If the artificial sleep were removed, the algorithm would revert to its true O(''n'' log ''n'') efficiency, making the "linear sort" label both deceptive and wastefully unnecessary.

@@ Line 12: / Line 12: @@
 {{w|Sorting algorithm}}s are a fundamental part of computer science, with various methods differing in efficiency, ease of implementation, and resource usage. Efficiency is often described using {{w|Big O notation}}, which expresses how the runtime of an algorithm scales with the size of the input. For example, "O(''n'')" ("linear time") means the runtime grows proportionally to the size of the input, while "O(''n'' log ''n'')" means it grows slightly faster than linear. Faster algorithms, like O(''n''), are generally preferred for large datasets. However, it is known that no general sorting algorithms with linear runtime exist.
-The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on. This is also a reference to [https://www.geeksforgeeks.org/sleep-sort-in-python/ sleep sort], a well known joke algorithm for sorting.
+The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on. Another 'sort' that technically works but takes more time is necessary, by definition, is the [https://www.geeksforgeeks.org/sleep-sort-in-python/ sleep sort].
 The humor lies in the absurdity of intentionally slowing down a sorting algorithm to match a desired runtime profile. This defeats the purpose of optimization, as the goal of sorting algorithms is typically to minimize time spent, not to pad it with unnecessary delays. (Delays may be necessary for other functional reasons, but are an antithesis of the kind of optimality sought here.) If the artificial sleep were removed, the algorithm would revert to its true O(''n'' log ''n'') efficiency, making the "linear sort" label both deceptive and wastefully unnecessary.

← Older revision		Revision as of 08:21, 11 January 2025
Line 33:		Line 33:

	[[Category:Programming]]		[[Category:Programming]]
−	~~[[Category:Statistics]]~~

@@ Line 12: / Line 12: @@
 {{w|Sorting algorithm}}s are a fundamental part of computer science, with various methods differing in efficiency, ease of implementation, and resource usage. Efficiency is often described using {{w|Big O notation}}, which expresses how the runtime of an algorithm scales with the size of the input. For example, "O(''n'')" ("linear time") means the runtime grows proportionally to the size of the input, while "O(''n'' log ''n'')" means it grows slightly faster than linear. Faster algorithms, like O(''n''), are generally preferred for large datasets. However, it is known that no general sorting algorithms with linear runtime exist.
-The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on.
+The comic presents a humorous "linear time" sorting algorithm that first uses {{w|merge sort}}, a well-known O(''n'' log ''n'') algorithm, to sort the list. It then "sleeps" for an additional amount of time to artificially make the runtime scale linearly with the size of the input. Specifically, it pauses for <code>(1 million) * length(list) - (time spent sorting)</code> seconds, which is perhaps large enough (in the case of all practical implementations) to stretch to a knowable point beyond the actual time spent sorting, ensuring the overall runtime appears to grow linearly. This is a joke because the actual sorting is still O(''n'' log ''n''); the additional sleep time is simply wasted time to give the illusion of linear time. It's also a joke because it makes the sort so slow that it's useless, with a "sort" of one item taking upwards of 11 ''days'', two items taking 23 days, three taking 34 days, and so on. This is also a reference to [https://www.geeksforgeeks.org/sleep-sort-in-python/ sleep sort], a well known joke algorithm for sorting.
 The humor lies in the absurdity of intentionally slowing down a sorting algorithm to match a desired runtime profile. This defeats the purpose of optimization, as the goal of sorting algorithms is typically to minimize time spent, not to pad it with unnecessary delays. (Delays may be necessary for other functional reasons, but are an antithesis of the kind of optimality sought here.) If the artificial sleep were removed, the algorithm would revert to its true O(''n'' log ''n'') efficiency, making the "linear sort" label both deceptive and wastefully unnecessary.

← Older revision		Revision as of 01:06, 3 January 2025
Line 35:		Line 35:
	[[Category:Programming]]		[[Category:Programming]]
	[[Category:Statistics]]		[[Category:Statistics]]
−	~~[[Category:Dreams]]~~

← Older revision		Revision as of 23:57, 2 January 2025
Line 35:		Line 35:
	[[Category:Programming]]		[[Category:Programming]]
	[[Category:Statistics]]		[[Category:Statistics]]
		+	[[Category:Dreams]]

← Older revision		Revision as of 02:02, 26 December 2024
Line 34:		Line 34:

	[[Category:Programming]]		[[Category:Programming]]
		+	[[Category:Statistics]]