No, I won't give you my github.
this post was submitted on 24 Apr 2024
61 points (98.4% liked)
Programmer Humor
19623 readers
411 users here now
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.
Rules
- Keep content in english
- No advertisements
- Posts must be related to programming or programmer topics
founded 1 year ago
MODERATORS
That's ok. I've only just met you and am not sure that I'm ready to commit.
slow inverse square root:
float slowinvsqrt(float x)
{
const long accuracy = 100000000; // larger number = better accuracy
if (x <= 0.0f) {
return NAN;
}
if (x == 1.0f) {
return 1.0f;
}
if (x < 1.0f) {
return 1.0f / slowinvsqrt(1.0f/x);
}
int max_power = log(accuracy) / log(x);
long pow1 = pow(x, max_power - 1);
long pow2 = pow(x, max_power);
double current = 1.0;
double previous = 1.0;
for (long i = 0; i<10*accuracy; i++) {
current = sin(current);
if (i == pow1) {
previous = current;
}
if (i == pow2) {
return current / previous;
}
}
}
There are subfields of computer science dedicated to this question. A good starting point for the theory would be Pessimal algorithms and simplexity analysis, which lays out two concepts:
- The time & space simplexity of an algorithm indicates best-case lower bounds on resource usage, and
- An algorithm is pessimal if no equivalent algorithm wastes more time/space/etc.
For example, common folklore is that sorting has O(n lg n) time complexity, depending on assumptions. In the paper, they give that sorting has Ω(n ** (lg n / 2)) time simplexity; any algorithm which takes more time, like bogosort, must do so through some sort of trickery like non-determinism or wasting time via do-nothing operations.
"EvErYtHiNg ShOuLd Be A mIcRo SeRvIcE" --Executive Who Doesn't Have to Maintain Said Microservices
I unironically had a screening interview with a recruiter that asked "If you were creating a startup, would you use microservices?". She didn't like that my answer was "It depends, I don't have enough information to answer".
"If you were making food, would you use onion powder?"
sleep sort
Technically, sleep sort is O(n), so faster than the theoretical optimal sorting algorithm O(n.log n) ... not so bad ;)
Sleep sort is kind of like count sort but with added overhead. Both have a complexity of O(n+m) with n being the length and m the value of the max element.
The optimum of O(n * log n) is based on the assumption that the only information about the values is obtained by comparison. If you operate on integer keys I would recommend radix sort. It has a complexity of O(n * w) where w is the length (read logarithm) of the key.
Sounds like you should look at a few years of https://thedailywtf.com entries. Enough to make the staunchest man (or woman) weep.
https://thedailywtf.com/articles/gotta-catch-em-all
Dear God.
try
{
/* ... some important code ... */
}
catch (OutOfMemoryException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (OverflowException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (InvalidCastException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (NullReferenceException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (IndexOutOfRangeException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (ArgumentException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (InvalidOperationException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (XmlException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (IOException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (NotSupportedException exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
catch (Exception exception)
{
Global.Insert("App.GetSettings;", exception.Message);
}
I can't find the name/source at the moment, but if you enumerate all turing machines and run them concurrently* you will find the optimal algorithm for your problem in O(1) and executed that.
To my knowledge the algorithm is so inefficient on small input that it takes hours to solve integer addition.
* You run the first turing machine one step, than the first two one additional step, that the first tree... This allows you to run an unlimited amount of TMs an unlimited amount of steps.