Find the date of your birthday in the number pi
mypiday.com
mypiday.com
Edit:
- "enter date in any format"
- Okay, interesting... I enter day-year-month
- "there's something wrong with the date you entered!"
Lol
~167 millionth digit for me.
Also, very interesting how it works (https://www.angio.net/pi/how.html)
I'm definitely a systems programmer, not a UI person. Suggestions or questions welcome, of course, but I usually only spend a day per year on the pi searcher. I re-wrote it in rust last year for fun, though.
I do want the site to be at least "self-maintaining", though.
Maybe you can try to setup a custom t-shirt with the desired number in the Pi sequence, like the original article has.
Thanks again for the site!
And very welcome. It turns 25 this year, which is really weird - it's older than my students! grins
> I'm frequently asked where people can get such a ridiculously large amount of pi. Be warned that 50 million digits of pi takes up 50 megabytes. This can take up to 4 hours to download with a 28.8k modem!
I love the old internet. Users gave a shit about other users.
Longest "Pi" sequence found: 31415926
For the digits 0-9, there are stretches 8 (i.e. 11111111) long for all the digits, but 6, 7, and 8 have 9 digit stretches (which given the property that a 9 digit random number would be in there at ~9.5%, is an anomaly!).
12345678 exists, but not 123456789. Similarly counting backward, but 876543210 exists. 012345678 does not.
And, yes, my birthday is in there, both at MMDDYYYY and YYYYMMDD.
Anyway, silly amount of fun.
'Enter your birthdate (or other date) in any format'
It even pings this script first
https://www.wolframcloud.com/objects/user-ca9f3e2e-1c45-4ace...
to get a checksum ("ck") that it then passes to the Pi searcher in the query string, which appears to be the last 8 digits of the MD5 checksum of the date, e.g.
import hashlib
print(hashlib.md5("12-30-56".encode()).hexdigest()[-8:])
Unfortunately passing invalid dates seem to once again crash the image generator that presents the results.Valid:
https://www.wolframcloud.com/objects/microsites/mypiday/pida...
Invalid:
https://www.wolframcloud.com/objects/microsites/mypiday/pida...
In all seriousness, why isn't this just "find any number in pi"?
Some results are without the first 2 year digits.
Some results are plain bogus, a 2012-03-XX date returned a 2012-10 number (without the day component and wrong month).
If this is an ad for the power of Wolfram Alpha it is very poorly executed.
) Consider 1st billion digits of pi ) Search your exact date string ) If it doesn't hit, try reformatting and search again until something hits ) Return
If you're suggesting they should replace the 'try reformatting' step with 'try the next billion digits', then the complexity of calculating digits increases as you go so this is going to become impractical in any language, not just Wolfram
I don't know that that's a good argument, but it's a fun one.
[0] and while we don't know for sure signs point to yes
(Also, even if the code exists somewhere in pi, finding it there requires more effort than coming up with it in the first place. There are interesting mathematical/philosophical consequences of this reasoning.)
What if you have access to [enter arbitrary number] computers?
Assuming the binary digits of π are randomly distributed[0], any given n-bit binary sequence is going to come up with a probability of 1-in-2^n at any given point in the whole thing. A 1 kB file of any kind, app or data, is already one in 1-in-2^(8*(2^10))).
The Hitch Hiker's Guide to the Galaxy says that if you hold a lungful of air you can survive in the total vacuum of space for about thirty seconds. However it goes on to say that what with space being the mind boggling size it is the chances of getting picked up by another ship within those thirty seconds are two to the power of two hundred and sixty-seven thousand seven hundred and nine to one against.
This probability corresponds to a file just fractionally smaller than 33464 bytes.
For scale: The universe can have performed no more than 10^120 ops on 10^90 bits[1] (~2^399 and ~2^299 respectively), meaning that no IP-protected content over 299 bits in length is likely to be found even when the entire universe is dedicated to this task, and even if your algorithm for finding extra digits of π is efficient enough that you're not limited by it.
[0] is this proven for any value of "random"? I genuinely don't know.
(of course that will eventually run into a problem with the state of the RNG exceeding available memory, so it will ultimately fail on resource exhaustion, but it won't repeat)
There is this: https://en.m.wikipedia.org/wiki/Bailey%E2%80%93Borwein%E2%80... , so you can calculate later digits of pi without the earlier ones.
[0]: https://corecursive.com/sloot-digital-coding-system/
[1]: https://en.m.wikipedia.org/wiki/Sloot_Digital_Coding_System
Simple counterexample: 0.101001000100001... which is 1 followed by one 0, then 1 followed by two 0s, then 1 followed by three 0s, and so on. It never repeats, but "11" will never appear.
"Almost all" real numbers do contain all finite sequences, but it hasn't been proven for pi (https://en.wikipedia.org/wiki/Normal_number).
This isn't actually proven though, as far as I know.
There are plenty of infinite non-repeating sequences that we know that don't contain a given sequence. (E.g. 0.1101001000100001000001...)
But pi is not among them. It might very well have everyone's source code. It also might not.
Depends on the uniformity of matter and energy and physical laws in the universe. If matter and energy are uniformly distributed with no large scale variation, and the laws of physics are constant then eventually somewhere in the universe you’d be able to find an Earth arbitrarily close to ours.
No, that is not a typo.
Yes, it's exactly as stupid as it sounds.
You would think that lenders should be on the hook for handing out money to the wrong person, but they’ve framed accepting uniquely identifying personal information like ssn, or date of birth with postal code, as conducting business with an entire identity that has been misappropriated.
Private keys on the other hand can remain secret even when someone is confirming their validity. To oversimplify a little, the way it works is that the private key is input into a one-way algorithm that generates an output they check against their saved values. If the output matches twice then they know you have the same key as the one you used in the past. They cannot used the output of a one-way algorithm to discover what the input was that generated said output.
The link in sibling comment by brynbryn [0] is a much better (not to mention faster) implementation IMO.
C10 = 0. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ...
([0..]>>=show in Haskell) which is provably normal in base 10 (for pi it's widely believed but unproven).Of course the minimal index i(w) at which digit sequence w appears is about as long as w itself...
n * dec - (10^(n-1)-1) `div` 9 + 1 - 10^(n-1)
In the different numbers would have been my birth-minute represented in decimal unix time, hex, binary, etc. Then different date systems from around the world, Islamic, Hebrew, Devanagari, Chinese Lunar, Japanese, and Mayan long count. I gave up because I couldn't find enough people that I trusted to verify that the different language date strings were correct.
Your iconoclasm has broken my reverential mnemonic, but for honorable purposes.
However, I will never have baked beans for breakfast, handle spotted dick, omit the phonetic k from my schedule, nor other things that would simply be going too far, however rational they may be.
Did anything interesting happen on 3/14/1592?
For the rest of us it is a bit trickier but should still work: use two consequtive digits (00-99) and a modulo function that loops over an alphabet (and possibly discards some padded values as not having a map to a letter).
πfs – A data-free filesystem (github.com/philipl)
155 points by zapdrive 4 months ago | 108 comments
consider this a phishing op until proven otherwise
If you use full dates, the lowest is 01-01-1978 at 109,223.
Starting with year first, the lowest is 1-12-12 at 79.
The string 91790 occurs at position 66638. The string 66638 occurs at position 29666.
I'm two levels deep, and the reoccurrence of 666 has me worried.
now would you mind telling me the name of your first pet?
also what’s your mother’s maiden name?
Joke's on you (until I lose the answers, then it's on me)
> We may collect both Personal Information (PI) and non-Personal Information (non-PI) about you through your experience on our websites, from your use of our services and products and via other voluntary contact with you (collectively "Services").
> The PI we collect through our Services primarily consists of information you submit to us. Because participation in our Services is voluntary, you have a choice of whether or not to disclose such information. The following are categories of PI we have collected in the past 12 months:
> Identifiers
> Examples include: a real name, alias, postal address, unique personal identifier, online identifier, Internet Protocol address, email address, account name, Social Security number, driver's license number, passport number or other similar identifiers
Now add birth date to the list.
Use the stick as long term storage for your code.
(Fortunately, pi compression is not particularly amenable to one of the other basic "tricks" of fake compression algorithms, which is failing to count filenames or other metadata as part of the compressed data set, if you use them in the decompression algorithm. Pi "compression" is, in practice, a much better data expansion algorithm than a decompression algorithm. So you don't generally have to deal with having to explain how they've still failed even though their file sizes seem smaller.)
This should be the standard answer, along with some probing questions like:
- "So if you can always compress data, what happens when you compress the compressed data over and over? Surely you see this can't always work or everything could be compressed down to 1 bit?"
- "Do you realize that there are 2^N strings with N bits, but fewer strings with less than N bits? Surely you don't think you can always represent N bits in fewer than N bits?" (i.e. something along the lines of the pigeonhole principle)
If that doesn't convince them or they're unwilling to think through those fundamental questions or the implementation, it's a hopeless case that is best left alone.