last day (18 days later) » 

Feeds
Feeds
22:36
0
A: Largest Number Printable

BlackCapHaskell, 100 bytes, unknown score f!x|x<' '=f|q<-(!pred x),r<-(q$q f)[x]=foldl(.)q[q|_<-r,_<-r]f main=print$(\x->x++x)!'�'$[pred ':'] The special character (2^16 - 3 ascii) counts as 2 bytes. pred ':' is equal to '9'. I'll be severely impressed if someone can tell me what my score is. Argua...

Simply Beautiful Art
Simply Beautiful Art
Can you explain your number in non-code form? If so, I can probably analyze and provide a score for you.
BlackCap
BlackCap
@SimplyBeautifulArt Not easily, no. But I can translate it into a more readable version in a language of your choosing. I updated my answer with something c-like
Simply Beautiful Art
Simply Beautiful Art
Sadly I don't use C, but I do use Ruby/Python. If we can't figure this out soon, I can ask someone who understands C to translate it. Or we can go to a private chat room?
I don't see where your code increases any numbers. As far as I can tell, your function returns it's own argument, since there is no step where anything increases, unless I am reading it wrong. (But of course, I don't fully understand C, so...)
BlackCap
BlackCap
@SimplyBeautifulArt I pass in a function that concatenates a string with itself. Ruby translation: pastebin.com/xUhiBTp6 (hopefully I got that right)
Simply Beautiful Art
Simply Beautiful Art
You sure it terminates rather than goes on an infinite loop between fa and q?
BlackCap
BlackCap
22:36
yes, the q fa chain produces a function that takes a function and repeats it over its input some number of times. It is passed f after the loop, which is going to be the concatenation function at the top most level.
Simply Beautiful Art
Simply Beautiful Art
Could you walk me through how your function works? I am not familiar with lambda calculus
Any chance you could provide a purely mathematical or algorithmic explanation?
6
A: Largest Number Printable

Simply Beautiful ArtRuby: score is approximately (much greater than) fω²(fω²(fω²(fω²(fω²(fω²(966))))) where fα(n) is the fast growing hierarchy. Assuming online interpreter where printing the result is automatically done: def f(a,b=a,c=a,y=?!.ord)(c>y)?a.times{a+=f a,b,c-y}&&a:(b<y)?a:f(a,b-y)end;f(f(f(f(f(f ?φ.o...

Like I did with my answer?
I'll be eating, so brb
BlackCap
BlackCap
Thanks for helping me btw
Simply Beautiful Art
Simply Beautiful Art
No prob @BlackCap
If you take a look around, I've edited nearly every answer with a ranking/approximation of score
Can't leave you out :P
BlackCap
BlackCap
22:57
I actually have to leave for a few hours too
The gist of my function is that it takes another function, and then feeds the result of that function back into itself- It recursively builds a super function that repeat functions that repeats functions, over their own result.
Eventually you pass in the primitive concatenation function, that will double the length of the number on each iteration
Simply Beautiful Art
Simply Beautiful Art
@BlackCap So... how does it terminate? And if what you describe is what I think you are doing, you get something like 2^65502 I think
But f(1) doesn't terminate no matter how I fix it up, so... some test values would be nice
BlackCap
BlackCap
23:57
it terminates because we have an edge case that checks whether n=0, and we decrement n on each lever, so no matter how many branches we have it's going to return eventually
You get much more than 2^65502..

n=0: 2 9's, because we simply return f

n=1: 36893488147419103232 9's, because:
(1) q = myFunc (0) - q is a function that doubles a function (2)
(2) r = q(q(f)) ("a") - we double a double a double, we get 8 a's (2^3)
(3) fa = q - q is still a single doubling (2)
(4) we double fa 8^2=64 times, so fa becomes a function that doubles a function 2^(8^2)=18446744073709551616 times
(5) we pass in f, which is one final doubeling, return (2^65) 9's

n=2:
(1) q = myFunc (1) - 2^65 doubelings
n=10: pastebin.com/uw9kjGcu

  last day (18 days later) »