text:
Largest number in ten bytes of code
Your goal is to print (to the standard output) the largest number possible, using just ten characters of code.

You may use any features of your language, except built-in exponentiation functions.

Similarly, you may not use scientific notation to enter a number. (Thus, no 9e+99.)

The program must print the number without any input from the user. Similarly, no reading from other files, or from the Web, and so on.
Your program must calculate a single number and print it. You can not print a string, nor can you print the same digit thousands of times.
You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the print x syntax, you can use up to 16 characters for your program.
The program must actually succeed in the output. If it takes longer than an hour to run on the fastest computer in the world, it's invalid.
The output may be in any format (so you can print 999, 5e+100, etc.)
Infinity is an abstract concept, not a number. So it's not a valid output.

Did you look at these two?
http://codegolf.stackexchange.com/questions/185/print-largest-integer-you-can-with-the-fewest-characters
http://codegolf.stackexchange.com/questions/18028/largest-number-printable

What do you exactly mean by "calculate". Also, If it takes longer than an hour to run on any computer in the world, it's invalid. is not objective. I could (theoretically) manufacture a computer that takes an hour to change one T-state

@user80551 I clarified what I meant by "any".

@MadTux None of the top answers on those questions are valid here, since they either take millions of years to run, or are way longer than 10 characters.

Do imports count to the 10 char limit too?

I've voted to close as "Too broad", for reasons which will be obvious if you read the answers to the first question linked by MadTux above.

@PeterTaylor Well, it is getting all sorts of entertaining answers, and the 10-character limit makes things interesting, so I'm beginning to like it.

Does bit-shift count as an exponentiation operator since it is equivalent to * 2^x ?

@PeterTaylor: This is far less broad than that, though. There is actually a scoring criterion (the number), a program criterion (<= 10 chars), and a time limit (< 1 hour running time)

@Claudiu: "the output may be in any format"

The fact that the time limit depends on the performance of the fastest computer in the world makes it impossible for us to determine the set of valid answers... I don't really like that

@DavidZ: True. I'd like to see it changed to "1 hour on X computer", and also clarify the rules as to bit-shift, and whether other large built-in functions (e.g. ack in Wolfram) are allowed. I guess not the best question, but I enjoyed playing to the spirit of the rules

As I see it, the problem with ack as used in the current Wolfram answers is that it doesn't calculate the result, it just estimates it.

Are importing the libraries is counted as a code?

So you want the longest number possible in 10 bytes but not the largest number possible?

I don't like the rules. I could have posted this last [1..]. It extracts the last element of an infinite list.

@Ypnypn One of the rules currently says, "you may not use scientific notation to enter a number". The rules appear to barely leave open the possibility for our code to use scientific notation inside a string literal. Is that so? I suppose eval("9e9") still isn't quite as large as 9999999999.

Exponentiation functions are not allowed, but ackermann function is allowed? That seems really arbitrary. It remains unclear why a symbolic manipulation is considered "calculating" the number.

It would be fun to see this for each of 1..10 bytes.

what about Aceto, where you can do: 9pppppppppppppppp (9 pushes 9 on the stack, and p prints out 9('0'*p)s

@Dennis It's not an estimate, it's an exact result, but it's a trivial conversion from Ackermann to arrow notation, like taking a square root and turning it into a negative exponent.  Literally, ack(m,n) = 2 ↑ ⁽ᵐ⁻²⁾ (n+3) - 3

-1 for arbitrary Do X Without Y (banning exp), feature assumption (number), subjective validity criteria (an hour on any computer), subjective scoring criteria (the print rule). How did this get 88 upvotes?

Now I want to know in 9,8,7,6... bytes of code.

Does this answer your question? Largest Number Printable

Note that you can already exceed Graham's Number with a program less than 8 bytes long: https://codegolf.stackexchange.com/questions/6430/shortest-terminating-program-whose-output-size-exceeds-grahams-number/219734#comment533337_219734

Wolfram Language
ack(9!,9!)

Try it online!
$$\text{ack}(9!,9!) = 2 \uparrow^{362878} 362883 - 3$$
Output is in Arrow Notation.

This goes against the rule that says you can't get it from the Web.

@KyleKanos It doesn't my interpreter happens to be on the web.
Like some other REPLs.

Not sure how that's different. Web access is web access, and it's not allowed as per the rules.

@KyleKanos Its different because the code/program isn't calling out to the web. Other Examples
http://www.typescriptlang.org/Playground
http://www.tryfsharp.org/Learn/getting-started

Pretend you're on a deserted island in the middle of the Pacific Ocean and no internet (and solar powered laptop), can you say definitively that this code of yours will work on your laptop? If yes, then it passes the test & I'm wrong; if no (the case here), then it fails the test & you're wrong.

@KyleKanos You're changing the rules of the challenge. Where does it say your on a desert island? Does my Laptop have Mathematica. Do I have a raspberry PI?

It says "no Web access" pretty clearly; your answer says WolframAlpha (a website) explicitly. No further discussion is necessary.

@KyleKanos It doesn't say "no Web access" any where in the challenge.

Please read the 2nd bullet point carefully. See also this answer on loopholes that are not funny.

The Wolfram Language is available to use an Raspberry Pi and doesn't require web access. So isn't in violation of that rule.

I think it is very valid answer.  Stupid reasoning for being on island and having no access to internet.  'No web' requirement is only to prevent printing output from a already available resource.  All answers are valid as long as they 'run' a piece of code to calculate the output.  Latest Visual Studio is coming that runs your code on the Azure cloud, so you want to restrict C#?  Or you are ineligible if you have chromebook?

ack(99!,9) is much, much larger.

I think 9! !~ack~9 should also work. But I can't test it in WolframAlpha.

Does it complete within an hour? Can we actually use Arrow notation as the output?

One of the other answers says that ack(4,2) is the largest he can calculate in an hour so I would be surprised if this did...

What happened to the time limit?!

I'm not sure I'd say it's calculating it. Trying doing ack(9!,9!) + 1 and watch it not even know what's going on — if it were at least keeping things in a symbolic representation, it'd be able to show something.  This is basically equivalent to a google search.

Perl, >1.96835797883262e+18
time*time

Might not be the largest answer... today! But wait enough millennia and it will be!

Edit:
To address some of the comments, by "enough millenia," I do in fact mean n100s of years.
To be fair, if the big freeze/heat death of the universe is how the universe will end (estimated to occur ~10100 years), the "final" value would be ~10214, which is certainly much less than some of the other responses (though, "random quantum fluctuations or quantum tunneling can produce another Big Bang in 101056 years"). If we take a more optimistic approach (e.g. a cyclic or multiverse model), then time will go on infinitely, and so some day in some universe, on some high-bit architecture, the answer would exceed some of the others.
On the other hand, as pointed out, time is indeed limited by the size of integer/long, so in reality something like ~0 would always produce a larger number than time (i.e. the max time supported by the architecture).
This wasn't the most serious answer, but I hope you guys enjoyed it!

Upvoted because I like the eventuality

Won't time wrap around and return a small number at some point? Depends on whether it's 32-bit or 64-bit perl I guess

@AllenG: Where does perl get the data source for time from? If it's from the system which uses unsigned ints, then it will wrap around.

Right, I misinterpreted the comment. Well, hopefully by the time the universe is ready, computers/Perl will have increased the size of their integers :).

Wait, reading the clock doesn't count as an input? We can do that? I guess I'll exploit it after all.

1000 years ~ 3e10 seconds, so you'll still be hovering around 1e21 as your output. Perhaps if you waited 1e50 years, you might start competing against the other answers?

That’s only 9 characters, why not time**time?

@Timwi : Exponentiation operators not allowed

Do you pronounce this "time times time"? :-) (hi Timwi!)

Is the time on death heat of the universe accounting for daylight savings? You could earn a few more seconds of existence.

Eventually when the big freeze occurs this answer won't be so relevant anymore

Wolfram ≅ 2.003529930 × 1019728
Yes, it's a language! It drives the back-end of the popular Wolfram Alpha site.
It's the only language I found where the Ackermann function is built-in and abbreviated to less than 6 characters.
In eight characters:
$ ack(4,2)

200352993...719156733

Or ≅ 2.003529930 × 1019728
ack(4,3), ack(5,2) etc. are much larger, but too large. ack(4,2) is probably the largest Ackermann number than can be completely calculated in under an hour.
Larger numbers are rendered in symbolic form, e.g.:
$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

The rules say any output format is allowed, so this might be valid. This is greater than 101019727, which is larger than any of the other entries here except for the repeated factorial.
However,
$ ack(9,9)

2↑⁷12 - 3

is larger than the repeated factorial. The largest number I can get in ten characters is:
$ ack(99,99)

2↑⁹⁷102 - 3

This is insanely huge, the Universe isn't big enough to represent a significant portion of its digits, even if you took repeated logs of the number.

Why does the exponent look weird? Is it 10 ^ 19278  or something else?

Not bad, but it's no match for my ack(4,2)+1 solution.

ack(4,2)+2, I WIN

Is the source available for the Wolfram language?

@Claudiu - Superscripts 1-3 are in a different UNICODE block from 0,4-9. Automatic font substitution tries to match the fonts but can't always.

@KyleKanos - No, you have to pay for it. It's used in Mathematica, too.

I think you won.

"As large as it is, Graham's number surpasses anything expressible as an Ackermann number." Counter-example: ack(g_64, g_64). BOOM

@ColeJohnson: as far as I know, there is only one meaning of the word 'source' when it comes to programming languages.

@ColeJohnson: except my question was precise: is the source of the Wolfram language available. It is very hard to misinterpret that to mean something about a calculation.

@Kyle Well, there's a free interpreter available online. :P

@Yimin Mathematica actually makes a server call to WolframAlpha when you do an = line.

@Riking: the free one online is not allowed for this competition though.

@ColeJohnson That's like saying you can express g_64 using addition, and then saying g_64+0! Boom! The reasoning is ultimately circular.

@Kyle, Yimin There are lots of misleading statements in this post and the comments under it.  This is not the Wolfram Language, and not what's used as the backend of W|A.  It is simply "natural language" input to Wolfram|Alpha. In the Wolfram Language ack(4,2) is invalid input.  W|A's natural language input shouldn't even count as a programming language.  It is not Turing complete, and you can't write even basic programs in it such as Euclid's algorithm.  For this reason I don't think this is a valid answer any more than a Google query would be.

The Wolfram Language is the programming language used in Mathematica, documented here.  Wolfram|Alpha takes natural language as input, not the Wolfram Language.

@Cruncher except that you can. Graham's number is a computable number unlike Chaitlin's constant (which is an uncomputable number). How about a googolplex (10^googol)? It's a computable number, but it's so massive we won't be able to store it. Computability of a number isn't based off how big it is. Graham's number is orders of magnitude larger than a googolplex, but it's still computable. As such, I can use it in numerical formula calculations.

@ColeJohnson Expressible and Computable are two very different concepts

@Cruncher from the question: "Your program must calculate a single number..." As in computable numbers. I really don't get what your getting at.

@ColeJohnson not even really talking about the question. Just responding to "Counter-example: ack(g_64, g_64). BOOM" which was in response to "As large as it is, Graham's number surpasses anything expressible as an Ackermann number."

@Cruncher and I'm saying that if your Ackermann number is generated with Graham's number in both arguments, it will be bigger than Graham's number. i.e. A[g_64, g_64] > g_64

The only problem with this language is that it melts at 3695 degrees Kelvin.

Python2 shell, 3,010,301 digits
9<<9999999

Calculating the length: Python will append a "L" to these long numbers, so it reports 1 character more than the result has digits.
>>> len(repr( 9<<9999999 ))
3010302

First and last 20 digits:
40724177878623601356... ...96980669011241992192

Darn it! This showed up whilst I was writing the same answer

That's really just 9 * 2**9999999, so one could argue it uses exponentiation.

Wait, ***built-in*** exponentiation functions are not allowed so this might slip under the rules. +1

Mathematical way of computing the length: floor(log10(9 * 2**9999999))+1

@Quincunx: Yes... because showing the length is no proof for really having calculated the number I added 40 digits of it. If needed I can add a shasum or something similar too...

@Quincunx It does calculate it, but printing would take a long time. Actually, I couldn't get to make it a string on my machine. See http://pastebin.com/PDTc28P3

It's pretty slow in CPython, but in PyPy it should calculate in a few minutes. If you just want to verify the length, it's quicker to calculate floor(log10(9) + log10(2) * 9999999) + 1.

9<<(9<<99) is a lot bigger, if it terminates.

@KeithRandall: Yes! I am playing with it already. Or to be mor precise: Waiting. Calculating this terminates relatively quickly... try printing it in hexadecimal instead of decimal, that's a lot faster and gives a number of more than 280megabytes of "hex-digits". If I get it printed in decimal I'll mention it here. More than 9<<27 as argument to << is rejected by python. Maybe some other language will accept more there... :-(

Got no luck with 9<<(9<<99) up to now: sdf.org rebooted while my calculation was running (nice 19, I wasn't mean!) and on sdfeu.org it got a kill signal after lots of hours, maybe piping the output into xz -9e >outfile was failing (xz -9e may have been too much of a RAM hog?). I've one more job running on an old notebook (I'm on the road with not much cpu-power)... patience... ommmmmmmmmmmmm... ;-)

@yeti It sounds like you are basically describing my answer, http://codegolf.stackexchange.com/questions/31695/largest-number-in-ten-bytes-of-code/31756#31756

@isaacg: (a): I am trying to get it printed in decumal because printing in hex is no big deal. And (b): I have no Python3 at hand right now, so i'm stuck with 9<<27 as maximum argument to 9<<X. So don't worry: It is different from your answer in two aspects! At least until weekend... when I'm back in my home compouting center, things will look different... mwhuaahahaahahahahahahahahahhahahahahahaaaaa!

CJam, 2 × 10268,435,457
A28{_*}*K*

This computes b, defined as follows:

a0 = 10
an = an - 12
b = 20 × a28

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Background
This follows the same idea as Claudiu's answer, but it isn't based on it. I had a similar idea which I posted just a few minutes after he posted his, but I discarded it since it didn't come anywhere near the time limit.
However, aditsu's suggestion to upgrade to Java 8 and my idea of using powers of 10 allowed CJam to calculate numbers beyond the reach of GolfScript, which seems to be due to some bugs/limitations of Ruby's Bignum.
How it works
A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8.1 × 101,826,751
KK,{)*_*}/

Takes less than five minutes on my machine, so there's still room for improvement.
This computes a20, defined as follows:

a0 = 20
an = (n × an - 1)2

How it works
KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Haha, is that Kirby? :)

Could you describe what this is doing?

FYI, I ran some tests to check BigInteger performance - I calculated 100000! and converted to string. Results: java 6: 21 sec calculation, 44 sec toString; java 7: 14 sec calculation, 42 sec toString; java 8: 5 sec calculation, 1 sec toString!

@aditsu: Upgrading Java reduced the runtime from 5 minutes to 2 seconds!

Any language with short enough constant names, 18 digits approx.
99/sin(PI)

I would post this as a PHP answer but sadly M_PI makes this just a little too long! But PHP yields 8.0839634798317E+17 for this. Basically, it abuses the lack of absolute precision in PI :p

Can't you do tan(PI/2)?

@user80551 Could do, but I just noticed that I could make use of that last remaining character in the limit to boost my result by 99 times.

Too long in Common Lisp: (/ 99(sin pi)) (14 characters). Error in TI-83: 99/sin(π (8 characters) causes division by zero. Works in LibreOffice Calc: =99/SIN(PI( (10 characters, not counting =) computes 808423047055000000. LibreOffice auto-inserts the last two )) in =99/SIN(PI()).

It's depending on the precision of the language. In PHP 14 decimal digits is a common value.

@kernigh It doesn't matter in this case, but would 99/sin(π be five bytes or eight? I know TI-BASIC stores a bunch of commands as single bytes; is sin( one of them?

@WChargin sin( acts like one character, but I know not many bytes. See http://meta.codegolf.stackexchange.com/questions/1541/how-to-score-ti-basic

You can do this in Clip v4 or higher (though I can't find an interpreter for any such version)  with only 6 chars: /99.sP.

This reminds me of a time I took a series that involved tan(pi/2) or something similar in Wolfram.  When the calculations get rough, Wolfram approximates, and it has very long approximations of pi handy.

@bcsb1001 then I suppose that can be boosted higher

PHP_INT_MAX sadly is 11 chars

PHP_INT_MAX = 9223372036854775807

sin(pi)^-9 = 1.6081E+143

Python 3, 9*2^(7*2^33) > 10^18,100,795,813
9*2^(2^35) > 10^10,343,311,894
Edit:
My new answer is:
9<<(7<<33)

Old answer, for posterity:
9<<(1<<35)

Ten characters exactly.
I am printing the number in hex, and

You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the print x syntax, you can use up to 16 characters for your program.

Therefore, my actual code is:
print(hex(9<<(7<<33)))

Proof that it runs in the specified time and generates a number of the specified size:
time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py
15032385541 bignumoutput.py

My number > 10^(15032385538*log(16)) > 10^18100795813
3 less hex digits than the above wc printout because of the initial 0x9.
Python 3 is necessary because in python 2, 7<<33 would be a long, and << doesn't take longs as inputs.
I can't use 9<<(1<<36) instead because:
Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Thus, this is the largest possible number of the form a<<(b<<cd) printable on my computer.
In all likelihood, the fastest machine in the world has more memory than I do, so my alternate answer is:
9<<(9<<99)

9*2^(9*2^99) > 10^(1.7172038461*10^30)
However, my current answer is the largest anyone has submitted, so it's probably good enough. Also, this is all assuming bit-shifting is allowable. It appears to be, from the other answers using it.

So far this looks to be the largest answer by far. It's a 10,000,000,000 digit number, after all.

@nneonneo : I believe my solution is larger :)

Your alternate answer requires juuuuust less than 1 MiYiB of memory, and requires 100 bits of addressable memory (so it won't work until at least 128-bit Python). (Source: my similar answer)

HTML, 9999999999
9999999999

.. nailed it.

not a programming language, though.

Use PHP, it's better!

@cat In this case, it's fine, as this is reminiscent of kolmogorov complexity challenges.

9^9999 prints 9^9999. Just sayin :)

saddly PHP_INT_MAX is 11

Haskell
Without any tricks:
main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Arguably without calculating anything:
main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Adapting Niet's answer:
main = print
    $99/sin pi -- 8.083963479831708e17

Third bullet says "Your program must calculate..."

floor(infinity) is a finite number? What the heck Haskell?

1/0 != infinity, it's undefined.

Are you sure about that, @ckuhn203? In both GHC 7.6.3 and 7.8.2, I get isInfinite $ 1 / 0 -- True. As far as I can tell, IEEE 754 defines 1 / 0 as infinity.

I'm absolutely positive about it @TaylorFausak. Just because IEEE defined it that way, doesn't make it true. See this answer on Math Exchange.

Oh, you mean mathematically. I agree completely. But as far as programming with IEEE floating point (and Haskell in particular) is concerned, 1 / 0 == Infinity.

@ckuhn203 The IEEE convention is correct in the sense that the reciprocal of any sequence that tends to 0 tends to infinity.

Why do you include $ in the code?

@CatsAreFluffy without the $ I would have to use parentheses for grouping, which would take an extra character. So my first answer could only have been main=print(9999*999). See http://stackoverflow.com/questions/19521246/what-does-mean-do-in-haskell for more about $ in Haskell.

Can't $ be included in the print boilerplate?

No. It's not necessary to "print anything". You can do main=print"hello" without the $ or parentheses.

And why is $floor$0/0 so big? Even bigger than everything here, as far as magnitude.

I like the 1/0 trick. Nice and big!

$cosh 710 is good for 1.1169973830808557e308, if we eschew the exponential definition in favor of the more fundamental geometric definition.

Powershell - 1.12947668480335E+42
99PB*9E9PB

Multiplies 99 Pebibytes times 9,000,000,000 Pebibytes.

98901 sq petabytes? Is that some sort of method to measure the surface bit density of (future high-capacity)hard-disks?

Oh, nice. Didn't know pebibytes were possible by now. I always thought it stopped at tebibytes.

@Joey Now if MS would only hurry up and add yobibytes, the answer could be even better.

I could add that to Pash if it helps ... ;-)

1+"1"*309 outputs 1.1111e308 though I suppose this breaks the spirit, if not the word of the rule on printing characters. It's cast to a double for output.

Unfortunately you can't use 9E9.

J (((((((((9)!)!)!)!)!)!)!)!)
Yeah, that's a lot. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425))))))) to be not very exact.
!!!!!!!!9x

Can't that be mathematically expressed as 9!!!!!!!!?

@TheRare afaik 9!! = 97531, whereas (9!)! is a lot more!

@Flonk Really? My calculator says 9!! = 362880!.

@TheRare http://www.wolframalpha.com/input/?i=9%21%21

@TheRare it's called the double factorial! I think !! is a weird choice for a mathematical operator aswell, but that's how it is.. http://en.wikipedia.org/wiki/Double_factorial

@Synthetica As my studies in J are... incomplete, what does the x do?

@TheRare It uses arbitrary precision integers: the 64 bit ones J uses normally would overflow, otherwise this expression would result in _ (infinity)

@Flonk Wow, I've never heard about that.

@Synthetica Since The output may be in any format , using _ for infinity might be valid.

@user80551 It feels against the spirit of the question. It might be technically valid though.

Does it actually output the number? Is there a free J compiler out there?

I did find a compiler, but after 20 minutes, !!9x hasn't printed anything to screen. I sincerely doubt that !!!!!!!!9x will ever be computed.

Does it use built-in exponentiation? If yes, I don't think this example is valid the same as mine.

My previous comment makes a lot of sense since (9!)! is a number that has over 90k digits to it.

"If it takes longer than an hour to run on the fastest computer in the world, it's invalid." Not sure this would be valid since it doesn't run within an hour

@kenorb: ! is the factorial function, it's straight multiplication.

It took 70 minutes, but !!9x finally printed to screen. I'm impressed that it actually computed the value, but it still completely fails bullet 5.

Considering that ((9!)!)! is about 10^(10^6.269498812196425) digits long, even !!!9x probably will never be printed to a screen. However, the program might end up finishing computing it. @KyleKanos It's likely that the reason why it took so long for !!9x is because it is ~10^6.269497348270999 digits long, so the outputting it takes a lot longer. The program probably finished computing the number long before 70 minutes.

@Quincunx: Likely true, however the condition for a valid answer is that the program must succeed in output; this answer completely fails that criterion. Sadly, the upvoters have neglected all the comments pointing this out and still upvote it over the CJam & Golfscript answers that are insanely huge and compute in reasonable time.

@KyleKanos Not what I meant. I meant to agree with you. I was saying that this program will never be able to print the number, so it was invalid. I presented that it might be able to compute it, but not print it.

@Quincunx: I think I skipped the last half of your first sentence :$.

@KyleKanos 70 minutes is within an order of magnitude for this comp. If you can find someone with a faster computer I'd call that a valid answer. Would it be winning?

@curiousdannii: Seeing how there are a few different answers that compute numbers larger than (9!)!~1e1,859,933, I don't think this would win, even if it computed that within the hour requirement.

Why use !!!!9x when you can use !^:!9x? You're already tossing out the time restriction, so why not go all out?

Downvoted because it doesn't print out the answer.

K/Kona: 8.977649e261 1.774896e308
*/1.6+!170

!170 creates a vector of numbers from 0 to 169
1.6+ adds one to each element of the vector & converts to reals (range is 1.6 to 170.6)
*/ multiplies each element of the array together

If Kona supported quad precision, I could do */9.+!999 and get around 1e2584. Sadly, it doesn't and I'm capped to double precision.

old method
*/9.*9+!99

!99 creates a vector of numbers from 0 to 98
9+ adds 9 to each element of the vector (now ranges 9 to 107)
9.* multiplies each element by 9.0 (implicitly converting to reals, so 81.0 through 963.0)
*/ multiplies each element of the vector together

Python - Varies, up to 13916486568675240 (so far)
Not entirely serious but I thought it would be kinda fun.
print id(len)*99

Out of all the things I tried, len was most consistently getting me large ids.
Yielded 13916486568675240 (17 digits) on my computer and 13842722750490216 (also 17 digits) on this site. I suppose it's possible for this to give you as low as 0, but it could also go higher.

Great idea but unfortunately it doesn't calculate anything.

I do believe the *99 part invokes a calculation.

Oh yes, /me feels stupid now.

If you use something shorter - say id(id) or id(0j), you can multiply by 999

@gnibbler id(1) works too.

Out of smaller named ones in https://docs.python.org/2/library/functions.html , vars consistently gives the highest value(but 4 chars) followed by sum. Use print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1]) to check.

Why *99? Why not **9?

@Trimsty, ** is the built in exponent calculation, forbidden by bullet point 1

@user80551 map followed by zip consistently gives the highest value in my interpreter (CPython 3.9 64-bit)

Golfscript, 1e+33,554,432
10{.*}25*

Computes 10 ^ (2 ^ 25), without using exponents, runs in 96 seconds:
$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

It can compute up to 9 ^ (2 ^ 9999), if only given enough time, but incrementing the inner exponent by one makes it take ~triple the time, so the one hour limit will be reached pretty soon.
Explanation:
Using a previous version with the same idea:
8{.*}25*

Breaking it down:
8         # push 8 to the stack
{...}25*  # run the given block 25 times

The stack at the start of each block consists of one number, the current number. This starts off as 8. Then:
.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

So the stack, step by step, looks like this:
8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... etc. Written in math notation the progression is:
n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

What's the deal with the two one's in front of the 2564 in your output?

@KyleKanos: That's not my output, it's the output of wc. I'll edit to make it clearer

you could use wc -c to make the output clearer

Nice! I had the same idea a few minutes ago, but it runs much slower with CJam (which is surprising, since it's faster than GolfScript in general).

Isn't that using built-in exponentiation?

@YiminRong: no, it's using multiplication and looping, I just described the answer using ^ to make it more clear what the program was doing

Could you describe what's going on to those not familiar with Golfscript? :D

@Dennis It seems that java's BigInteger is pretty slow :( I don't know about ruby, but I tested a python program that calculates a factorial and it was significantly faster

@KyleKanos: Sure! Updated

Holy crapola that's awesome. Thanks a lot!

It should be 30 million digits, not billion.

@Dennis: Oops, I got over-excited. Thanks.

Minor improvement: 10{.*}25 delivers 33,554,434 digits and finishes in 90 second on my machine. I don't know why, but 10{.*}26* prints nothing.

@Dennis: Oh interesting, I guess multiply by powers of 10 is way more efficient for whatever reason .. I got 36 seconds for 10^(2^24)

@Dennis: Interesting I found the same (26* ran for 40 minutes with no output, yet 25 ran in 2 minutes). maybe we found a bug in teh ruby codes

wxMaxima ~3x1049,948 (or 108,565,705,514 )
999*13511!

Output is
269146071053904674084357808139[49888 digits]000000000000000000000000000000

Not sure if it quite fits specs (particularly the output format one), but I can hit even larger:
bfloat(99999999!)

Output is
9.9046265792229937372808210723818b8565705513

That's roughly 108,565,705,514 which is significantly larger than most of the top answers and was computed in about 2 seconds. The bfloat function gives arbitrary precision.

Haskell, 4950

Aww man, that's not a lot! 10 characters start after the dollar sign.
main=putStr.show$sum[1..99]

Why not just print? Also, 9/0.000001 is greater than sum[1..99].

At that rate, we might consider 9 999 999 999 to be a lower bound on results.

@TaylorFausak This answer is obviously not to be taken seriously!

Mathematica, 2.174188391646043*10^20686623745
$MaxNumber

Ten characters exactly.

Is it technically calculating anything, and is it outputting all the digits and not just scientific notation?

@Yimin: The output may be in any format (so you can print 999, 5e+100, etc.)

The value is not set at compile-time, but depends on the particular machine on which the command is run. I think it counts.

APL (Dyalog), 1.79769e308 (float64) or 9.99999e6144 (decimal128), 3 bytes
This is the minimum reduction of an empty list:
⌊/⍬

⌊ minimum
/ reduction
⍬ empty list
When reducing an empty list, APL will return the identity element of the function used (if known). For minimum reduction of a system without infinities (e.g. ISO APL, to which Dyalog APL adheres), the identity element for minimum is the largest representable number:
Try it online! (IEEE 754 64-bit floating-point)
Try it online! (IEEE 754-2008 128-bit decimal floating-point)

Casio fx-350 ES PLUS, approx. 9.999882753E99
Do calculators count?

At 70! the calculator throws error because apparently it has a number range limit -1E100 ~ 1E100

I... don't think this counts as a programming language?

Well I guess there's another calculator answer so this is probably fine.

Binary Lambda Calculus, \$ f_{\omega+2} (2)\$, 9.75 bytes
This program outputs a number larger than Graham's Number while using 78 bits, which is 9.75 bytes, within the 10-byte budget given to me:
010101000001110011101000000101011000000101101101011010000110100000011100111010

If you prefer an ASCII display of the binary number, here it is:
T��mhh:

(Inspired, but not copied, by the entry mentioned here)
How it works:
This Binary Lambda Calculus expression encodes the following expression below:
(\f x.f (f x))(\f n.n (\g m.m g m) f n)(\x.x x)(\f x.f (f x))

This Lambda Calculus expression uses Church Numerals. Church Numerals are generally considered to be the standard representation of natural numbers. What makes Church Numerals powerful is that they are defined using recursion:
[n] f m = f (f (f (...(f m)...))) with n f's.
What this means is that if we have a function \$f\$ and a natural number \$n\$, we can simply concatenate them into \$n f\$ to make a much faster function. You can read the article I linked above if you want to see how Church Numerals can be encoded in Lambda Calculus.
Exponentiation
What is more, Church Numerals can even act on themselves! n m represents \$m^n\$ using exponentiation!
Example: \$2^3\$
(Here, we will apply that to the function f n, to show the true power of recursion)

3 2 f n
2 (2 (2 f)) n
(2 (2 f)) ((2 (2 f)) n)
(2 f) ((2 f) ((2 f) ((2 f) n)))
f (f (f (f (f (f (f (f n)))))))
= 8 f n

We can create a function that captures the true power of exponentiation!
\x.x x

When applied to a Church Numeral \$n\$, it returns \$n^n\$. Viola! Let's call our exponential combinator \$E\$, such that:
E = (\x.x x)

Recursion
In order to get beyond exponentiation, we must recurse our \$E\$ combinator. Remember how popping a number before a function recurses it? Well, we can do this with the E combinator, provided that it is a unary function. Define the \$R\$ combinator as followed:
R = (\g. \m.m g m)

Here, how it works is that for a function \$f\$ applied to an number \$n\$, \$Rfn\$ reduces down to \$nfn\$. This is awesome, because Church numerals naturally recurse functions, meaning \$nfn\$ reduces down to \$f (f (f ...(f n)...))\$.
What if we let our function be our exponential combinator \$E\$? \$REn\$ grows tetrationally. But there is no reason to stop here. We can merge \$R\$ and \$E\$ into a single combinator, \$(RE)\$, and recurse that to have \$R(RE)n\$. This grows pentationally.
We can have \$R(R(RE))n\$, \$R(R(R(RE)))n\$, and so on. But notice how the \$R\$ combinator is being recursed over \$E\$. Well, this is where Church Numeral Recursion comes back into play.
Super-Recursion
Define a new combinator, \$S\$, as the following:
S = (\f n.n R f n) = (\f n.n (\g m.m g m) f n)

Cool, now one thing that makes this powerful is that while the \$R\$ combinator recurses over a function \$f\$, the \$S\$ combinator repeatedly applies the \$R\$ combinator to a function \$f\$. Consider this:
$$SE3$$
The first thing that \$S\$ combinator is going to do is to reduce to \$nR\$ where n is the number after the \$E\$. So our reduction will look like this:
$$3RE3$$
The Church Numeral recursion applies on \$R\$ over \$E\$, thus nesting \$R\$ three times, thus giving us this:
$$R(R(RE))3$$
As we seen above, each \$R\$ increases the size of the number considerably, and now the \$S\$ combinator recurses over the \$R\$ combinator! The combinator (SE) grows at \$f_{\omega}\$ in the Fast Growing Hierarchy, about the limit of the Ackermann Function. We can take this a step forward.

\$R(SE)\$ recurses over the (SE) combinator, growth rate similar to Graham's Number
\$R(R(SE))\$ has \$f_{\omega+2}\$ growth in the fast growing hierarchy
\$S(SE)\$ has \$f_{\omega2}\$ growth in the fast growing hierarchy
\$S(S(SE))\$ has \$f_{\omega3}\$ growth in the fast growing hierarchy

Similar to how inserting a church numeral before \$R\$ can recurse the recursion function over \$E\$, inserting a church numeral before \$S\$ recurse the super-recursion function over \$E\$. For example, \$2SE\$ = \$S(SE)\$.
The Number:
The number is \$2SE2\$ using Church Numerals and the combinators defined above. This translates to about \$f_{\omega+2} (2)\$ in the Fast Growing Hierarchy, which is greater than Graham's Number. Graham's Number is far greater than even \$Ack(9!,9!)\$ in Wolfram-Alpha. Expanding \$2SE2\$ will yield:
(\f x.f (f x))(\f n.n (\g m.m g m) f n)(\x.x x)(\f x.f (f x))

The lambda expression for \$2\$ is (\f x.f (f x)), as you can see it is a Church Numeral. By decoding this Lambda Calculus Expression in Binary Lambda Calculus, one could expect a 9.75-byte expression:
010101000001110011101000000101011000000101101101011010000110100000011100111010

We proved that we can beat Graham's Number in 10 bytes! Ridiculous?

(\t. t t S E t) 3 -> 3 3 S E 3 -> 27 S E 3 this reaches $f_{\omega27}(3)$ using 79 bits: 0100010101011010000001010110000001011011010110100001101010000001110011100111010

Python shell, 649539 999890001
Beats Haskell, not really a serious answer.
99999*9999

9999999999 is larger, isn't it?

@MadTux There is an ambiguous restriction to calculate the answer.

If this answer is correct, then mine 9**9**9**9 is correct either, as it's arithmetic operator (not built-in func).

@kenorb It's built in exponentiation that's not allowed.

I'd rather post this as a comment above, but apparently I can't since I'm a noob.
Python:
9<<(2<<29)
I'd go with a larger bit shift, but Python seems to want the right operand of a shift to be a non-long integer.  I think this gets closer to the theoretical max:
9<<(7<<27)
The only problem with these is that they might not satisfy rule 5.

Befunge-93 (1,853,020,188,851,841)
Glad nobody has done Befunge yet (it's my niche), but dammit I can't find any clever trick to increase the number.
9:*:*:*:*.

So it's 9^16.
:*

Basically multiplies the value at the top of the stack with itself. So, value at the top of the stack goes:
9
81
6561
43046721
1853020188851841

and
.

Outputs the final value.
I would be interested to see if anybody has any better ideas.

I have a better idea

At least Python 3.5.0 (64-bit), more than 10^242944768872896860
print("{:x}".format( 9<<(7<<60) ))

In an ideal world, this would be 9<<(1<<63)-1, but there aren't enough bytes for that. This number is so big that it requires almost 1 EiB of memory to hold it, which is a little bit more than I have on my computer. Luckily, you only need to use around 0.2% of the world's storage space as swap to hold it. The value in binary is 1001 followed by 8070450532247928832 zeros.
If Python comes out for 128-bit machines, the maximum would be 9<<(9<<99), which requires less than 1 MiYiB of memory. This is good, because you'd have enough addressable space left to store the Python interpreter and the operating system.

"Only 0.2% of the world's storage space"

@BenjaminUrquhart If you think it's good, why not upvote?

There's your double upvote ;)

Matlab (1.7977e+308)
Matlab stores the value of the largest (double-precision) floating-point number in a variable called realmax. Invoking it in the command window (or at the command line) prints its value:
>> realmax

ans =

  1.7977e+308

Since the OP asked to return a calculated value, you should put realmax+1. I tried it for fun and surprise it returns exactly the same number than you have (then I laughed when I realized ... eps(realmax)=1.99584030953472e+292 ).

Python, ca. 1.26e1388
9<<(9<<9L)

Gives:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

><>
2020 update:
'*:*l1=?n!
Try it online!
A nice, big number.
6607775919524790651439701166707789489378797865523309469653600804966653717124420234900643695716633983263105744751733811265946551350757473520290996592227365993351117075631863250858664418726460620430636874466736708735091515674858617262672061392356105274688381926671523379031815127376998794734801639561117309008230181917173237247958670364395979998445068443549603086925428413456037483510188036968643022754136876546302694036337733250775972540791054488317803988268522700511802405629821189614545680714572177873101991977461377780062066275613653646526353437038254323542049537486740164431723433218814788820554530926749282165106713414138827765731299184793201063834591836604608194080942136186867241173559749340134123556348756219648917627921044482452298279885527390296021299809895208344965720017693561708427752229404713795765501476321809083160697802384075712539404128882728723305116462257211512254983151160419880169748505483542215949682009001146040637299350914438311533945478015790682139849329365319957805121129755402607972548916020445921204515251014341335241310585757251648664383763145215969276240907124147926204015695626240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

3147440830160257032480100000000 319626579315078487616775634918212890625
Edit:
Seems like I am allowed to exclude the characters needed for printing, the n in this case, so here is an updated version:
':*:*:*:*nÿ

Original answer:
'*:*:*:*n;

Here, ' activates stringmode, and pushes all the following characters to the stack, before wrapping and exiting stringmode. Then it does a multiply-and-copy chain, printing the number, and exits. Of interest here is the ascii value of n 110, and ; 59.
However, if we allow it to terminate with an error, we can abuse the fact that the official interpreter supports Unicode. The title of the question says bytes, but the text says characters, so the following program is just for the fun of it.
'*:*:*:*n

Outputting 1867215243681462552708446358738678532523702556144100000000
Alternatively, to stick to bytes, ÿ at the end gives us 383233022803952503175039062500000000, and that is still nice.
(New "for fun" program ':*:*:*:*n prints 7587624076546380447593767884781979512738274729546264306618287972087303430335365121)

Perl, non competing
I'm using this to highlight a little know corner of perl.
Perl can't really compete on this one because it doesn't have builtin bignums (of course you could load a bignum library).
But what everybody knows isn't completely true. One core function actually can handle big numbers.
The pack format w can actually convert any size natural number between base 10 and base 128. The base 128 integer is however represented as string bytes. The bitstring xxxxxxxyyyyyyyzzzzzzz become the bytes:  1xxxxxxx 1yyyyyyy 0zzzzzzz (every byte starts with 1 except the last one). And you can convert such a string to base 10 with unpack. So you can write code like:
unpack w,~A x 4**4 .A

which gives:
17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

You can replace the 4**4 by larger values until you feel it takes too long or uses too much memory.
Unfortunately this is way too long for the limit of this challenge, and you can argue that the base 10 result is converted to a string before it becomes the result so the expression doesn't really produce a number. But internally perl really does the needed arithmetic to convert the input to base 10 which I always considered rather neat.

TI-36 (not 84, 36), 10 bytes, approx. 9.999985426E99
Older calculators can be programmed to an extent as well ;)
69!58.4376
This is very close to the maximum range a TI calculator can display: -1E100<x<1E100

ARM Thumb, multiword integer, ~1.157921e+77 ~4.973232e+86
Machine code:
2306 1fd9 000a b407 b407

Assembly
        .globl main
        .thumb
        .thumb_func
main:
        push    {r4, lr}
        // start number generation code
        movs    r3, #6             // 2
        subs    r1, r3, #7         // 4
        movs    r2, r1             // 6
        push    {r1, r2, r3}       // 8
        push    {r1, r2, r3}       // 10
        // end number generation code
        // now printf everything
        adr     r0, .Lprintf_str
        bl      printf
        pop     {r1, r2, r3}
        pop     {r1, r2, r3, r4, pc}
        // print 32 bits at a time
.Lprintf_str:
        .asciz "%#08x%08x%08x%08x%08x%08x%08x%08x%08x\n"

Try it online! (sorta)
Assembles a 288-bit big endian unsigned integer (with little endian words) with the high 96 bits in r1-r3 and the low 192 bits on the stack.
The number is, in hex, 0xffffffffffffffff00000006ffffffffffffffff00000006ffffffffffffffff00000006, or in base 10, 497323236409786642128422301523609912453495901056838330362914156057471888398396751347718.
Explanation
You may be wondering why I chose 6 and 7. The reason is because of the limitations of narrow instructions.
movs Rd, #imm can only encode an 8-bit immediate from 0-255. No negatives allowed, which would make this almost too easy.
subs Rd, Rn, #imm can only encode a 3-bit immediate from 0-7. I can only subtract 0-255 if I use the same destination register, which isn't very helpful.
So therefore, since r1 will be more significant, we put 6 in r3, then subtract 7 to get -1, or 0xFFFFFFFF, in r1.
        movs    r3, #6             // 2
        subs    r1, r3, #7         // 4

Now, time for things to get super dumb.
First, we duplicate 0xFFFFFFFF to r2 using movs.
        movs    r2, r1             // 6

Then, we (ab)use ARM's push instruction. ARM's push instruction (as well as its sibling stm) can push multiple registers at once to the stack, effectively doing a block copy.
We abuse this to copy r1, r2, and r3 to the stack twice, tripling the width of the integer.
You could say this is some form of exponentiation, but all I'm doing is pushing to the stack. Nothing suspicious here.
        push    {r1, r2, r3}       // 8
        push    {r1, r2, r3}       // 10

Now, it looks like this:
   r1: 0xFFFFFFFF    r2: 0xFFFFFFFF
   r3: 0x00000006
 sp+0: 0xFFFFFFFF  sp+4: 0xFFFFFFFF
 sp+8: 0x00000006 sp+12: 0xFFFFFFFF
sp+16: 0xFFFFFFFF sp+20: 0x00000006

ARM Thumb-2, softfloat, 1.797693e+308
Machine code:
f248 0310 041b 17da 43db

Assembly:
        .thumb
        .globl main
        .thumb_func
main:
        push    {r4, lr}
        // Begin number generation code
        movw    r3, #0x8010     // 4
        lsls    r3, r3, #16     // 6
        asrs    r2, r3, #31     // 8
        mvns    r3, r3          // 10
        // End number generation code
        adr     r0, .printf_str
        bl      printf
        pop     {r4, pc}

        .align 4
.printf_str:
        .asciz "%f\n"

Try it online! (sorta)
Creates the 64-bit constant 0x7fefffffffffffff, which is DBL_MAX, in r2-r3 (since the AAPCS aligns 64-bit integers to even registers)
Specifically, 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000
We do this by first putting ~(*(long long*)&DBL_MAX) >> 48 in r3, shifting left by 16, doing an arithmetic shift right into r2 to make it 0xFFFFFFFF, then do a one's complement to get r3 to 0x7fefffff.
ARM Thumb-2, (non-competing), softfloat + printf merging, 2.148532e+319
Machine code:
f248 0110 0409 43ca 0013

Assembly:
        .thumb
        .globl main
        .thumb_func
main:
        push    {r4, lr}
        // Begin number generation code
        movw    r1, #0x8010     // 4
        lsls    r1, r1, #16     // 6
        mvns    r2, r1          // 8
        movs    r3, r2          // 10
        // End number generation code
        adr     r0, .printf_str
        bl      printf
        pop     {r4, pc}

        // Combine 0x80100000u (2148532224) with the same double we had before.
.printf_str:
        .asciz "%u%f\n"

Try it online! (sorta)
This is obviously cheating, as it is actually generating an unsigned integer and a double and printing them together, but decided to add it for the lulz.
It basically does this:
uint32_t r1 = (~0x7fef) & 0xffff;
// 0x80100000
r1 <<= 16;
uint32_t r2 = ~r1;
uint32_t r3 = r2;
// 0x7fefffff7fefffff
uint64_t r2r3 = r2 | ((uint64_t)r3 << 32);
double d = *(double*)&r2r3;
printf("%u%f\n", r1, d);

Scala, 263-1
Poor, poor Scala. Takes at least 8 characters to get a BigInt value, which doesn't leave enough room to actually make it big.
But with only 7 characters of (counted) code, we can print the largest possible positive Long:
print(-1L>>>1)

Brainf**k  256 - 2147483647
>+[<+>+]<.

If you ignore the fact that most compilers & interpreters output data as it's ascii equivalent (be leanient, it is what it is ;) ), this will return the maximum value of the interpreter/compiler's datatype.
On some systems this is just 256, although on some (mine for example), this is the max value of a 32 bit integer, ie 2 147 483 647.
Edit:
-.

Will print the same thing in many fewer characters

That second answer will print -1 on interpreters that use signed values for the tape

Braingolf, I don't even know [non-competing]
#~U&^^^^^^

Doesn't work on TIO as I need to get Dennis to pull, but as you can see here, U in Braingolf calculates a range from 1 to the last item on the stack, in this case ~ or 126
Then reduces the entire stack with exponentiation, meaning the stack now contains 1 value which is equal to 126^125^124...^2^1
We'll call this value n from now on.
Then I had some bytes left, so I filled them with some monadic ^ operators.
This means the final output is (((((n^n)^n)^n)^n)^n)
For reference, 126^125 is 3.518180682714907e+262 and (126^125)^124 is ~35000 digits long

For all intended purposes, this is approximately a_127 in the exponential factorial.

Aceto
kτ\p******u

Prints out
1 * 10846 (2017)
1.1 * 10846 (2018)
1.3 * 10846 (2019)
6.89 * 1013537 (2019)
Explanation
k - makes the stack 'sticky' so that values when popped are only copied,
 not removed
τ - pushes the date on the stack (the year is on the top, 2017 right now...)
\ - escapes the next character (print)
p - (ignored on first go-around)
*
 *
  *
   *        Multiplies top element by second, but stack has one element so it does it by itself
    *
     *
      *
       *
u - reverses instruction pointer direction
       *
      *
     *
    *
   *
  *
 *
*
p - prints
\ - escapes the date
k - makes stack sticky

Try it online!

actually you can add another * since p is excluded from bytecount

Runic
This answer is only works, if the following things are true:

I implement the Ackermann function using a non stack overflowing implementation.

Which I did briefly last night, but removed as there is no useful reason to keep it
It did successfully calculate Ack(4,3) over the course of 20-30 seconds, a number with 19729 digits.

If there are no arbitrary execution limits (e.g. TIO's 60 second timeout)
The executing computer has an arbitrary amount of memory to store exceedingly large stacks of BigIntegers

But if given those, then this program...
'ÿY:A:A:A@

...prints a number so large simply calculating how many digits it has is impossible, due to the explosive nature of the Ackermann sequence. Heck the inputs to the first call are both 255000!
The output (and thus input to the next call) is (in Knuth up-arrow notation): 2 ↑254998255003 - 3
(that's 254 BILLION arrows!)
Explanation
>                Implicit entry
 'ÿ              Pushes the character ÿ onto the stack (which will be implicitly converted to an `int`
                    whenever a math operator is called on it).
   Y             Multiply by 1000 (the 'biggest' thing we can apply to a single stack value in 1 byte)
    :            Duplicate top item on the stack
     A           Pop x and y, call Ack(x,y)
      :          Duplicate top item on the stack
       A         Pop x and y, call Ack(x,y)
        :        Duplicate top item on the stack
         A       Pop x and y, call Ack(x,y)
          @      Print the entire stack, top to bottom (there's only 1 value) and terminate

Larger still?
`AAAAAAAA@

Push the character sequence A,A,A,A,A,A,A,A,@ onto the stack (9 items) as the instruction pointer begins a character sequence on ` and loops around until it sees ` again. Each A then invokes Ack(x,y) (where x is the top of the stack) until the stack contains 1 entry, printing it. Not sure if this is actually larger or not.
However...
The closest we can get by abiding by the limitations is this:
':pba,*@

(Note the non-printing character 0x8F in position 2)
Try it online!
Which prints 1.79657789596691E+308 (143143 * 1.1). The multiplier of 1.1 is the largest that can be applied without rolling over to infinity due to the limits on a double: even multiplying by a9, (1.11) is sufficient to trigger the infinity bit.

Perl 6, 456,574 digits
[*] 1..ↈ

No TIO because it takes 2 minutes to run.

Keg, 260144641↑260144641
*:*(:|:*

Surprised I was able to get it this high, probably can be improved
Edit: Improved by A__
How it works
   Pushes 127 to the stack twice, I used 127 since it is the highest number that can be pushed in 1 byte (Note there is two characters there, they're just unprintables)
*    Multiplies them
:*   Squares that
(    Begin a for loop
:|   That will run 260144641 times (since that is the top element of the stack)
:*   That squares the top element of the stack
At the end it will automatically get printed

No, z isn't the largest number possible with 1 byte; 0x7F is. I usually use unprintable characters when I golf in Keg, to represent specific constants.

Oh wow, I was struggling to paste that into TIO, thanks for the better solution :)

Now that I think about it, I'm pretty sure this is way higher, but I have no clue how to calculate what that would be

Wait nvm, I forgot the | on the first bracket

If you were using that, you would need to close out the brackets at the end in order to output it, so I don't think it could be higher

I am requesting an exponentation operator in Unofficial Keg.

The PR has been merged. Now you can use the Ẹ operator to represent larger numbers. (at the cost of using more bytes)

><>, ~\$4.24 \times 10^{1177545600} \$
'****l(?;n

Try it online!
Outputs the ordinal value of * (42) around 4088700 times. Every loop it only terminates if the length of the stack is higher than multiplying the ordinal values of l(?;n = 108*40*63*59*110 = 1766318400, but since it only pushes 3 elements to the stack each time, this takes a long while.

Ozone, 9e+90000
(1)n1n1s2

Though it depends on dialect.

Perl, 1.84467422290351e+26 (On a 64-bit machine)
perl -le "print ~0*9999999"

Your code was the inspiration for my answer.

Python 2.7 - 8794643931199480236 15616093818140822
print hash('zz')

Um, that's 12 chars.

Ehh valid point @user80551. Guess I was slightly distracted by the footy match on TV :-)

JavaScript, more than 13 003 624 633 896 (but it reads a clock)
9*new Date

Reading from a clock is effectively taking an input. Feels like cheating. However, the technique seems to be well-received in the answers here.
If clocks are not allowed, then:
JavaScript, 186 025 771 008
99*(7<<28)

Trigonometry takes too many bytes (Math.sin, Math.PI).
Bit-shift goes near the integer maximum, then multiplication yields a floating point.

Bit shift operation are limited to 32 bit integers. 60 == 28 used in a shift operation (try in console: [7<<28, 7<<60])

C++ prints 18446744073709551615
#
ULLONG_MAX is 10 characters.
#include <iostream>
#include <limits.h>
using namespace std;
int main()
{
cout<<ULLONG_MAX<<endl;
return 0;
}

And what value does that print?

@KyleKanos Fixed it, thanks

TXR:
$ txr -p '(mask 999)'
535754303593133660474212524530000905280702405852766803721875194185175525562468061246
599189407847929063797336458776573412593572642846157810728751889829846429852761096554
990320661140395677219337642394922319490470301292036210344653556258987007434741839952
7286296858625998634149561158533358569939198279680

What is this doing?

@g.rocket It makes a bit mask in which bit 999 is set. It takes multiple arguments, e.g (mask 1 2) yields 6.

Bash / shell

You may exclude from the 10-character limit any code necessary to
  print anything.
... you can use up to 16 characters for your program.

(6 chars for code + 7 chars for printing = 26 digits) = 6888888 digits
$ seq -s9 999999

This number is bigger, but people may argue that it's in the wrong format.

The output may be in any format (so you can print 999, 5e+100, etc.).

(8 chars for code + 8 chars for printing = 26 digits) = more than 1183888008 digits
$ seq -s9 99999999

It usually takes around a minute to print the number and it contains the scientific representation of it.

Some funny example:
(10 chars = 26 digits)
echo $$$$$$$$$$
2760127601276012760127601

See: What does $$ mean in the shell?

Your program must calculate a single number and print it. You can not print a string, nor can you print the same digit thousands of times.

Perl: 6.27710173538668e+57 on cygwin with a Perl 32 bit
perl -e 'print ~0*~0*~0, "\n"'

Befunge-93, ~2.49e+40
"**:*:*:*.

This works by pushing the ASCII values of the program onto the stack and doing a bunch of multiplication.
Unfortunately, this doesn't work in TIO, but it does in this interpreter.
Here is a worse version that actually works in TIO:
"$$**:*:*.

And prints 1152921504606846976.
TIO ended up pushing a lot of spaces and 2 zeroes at the end, so I had to get rid of those.
Note that both of these programs print the number forever, because the end command (@) would have taken up a precious byte.

Brain-Flak, 100 (non-competing)
(()@lt99)

Note that this code must be run with the -d flag which adds 3 bytes.
Try it online!
This uses the @lt debug flag in the ruby interpreter. This flag simply adds the following number to the value which is then pushed by the enclosing parentheses.
The enclosing parentheses do not modify the number and are required for it to be printed so they are not counted towards then 10 bytes.
The () adds one to the value and causes the interpreter to recognize the enclosing parentheses as pushing a value (parentheses will only push a value if they enclose non-debug flag Brain-Flak code.

Tcl, number in the Demo Output because it is very extense (has 30104 digits)
namespace path tcl::mathop
puts [<< 9 99999]

The relevant part is
<< 9 99999

, the rest is boilerplate.
Try it online!

Acc!!, 999999
19*3
Write _
Write _
Write _
Write _
Write _
Write _

As any  code necessary to output anything is excluded,  all 'Write ' statements are excluded.
Try it online!

Your program must calculate a single number and print it. You can not print a string, nor can you print the same digit thousands of times.

PHP, 9 bytes, MAX INT (9223372036854775807)
echo ~0^1<<63;

or
echo -1^1<<63;

Set an int of all bits on (-1) then XOR it with an int of only the first bit on to flip the sign bit.

Pyt, (only 6 bytes)
9!ḞɳƖ*

Try it online!
Link to number
I don't really see any point in getting any bigger than this. Anything else exceeds the runtime limit on TIO

9  pushes 9
!  factorial of 9 (362880)
Ḟ  push xth Fibonacci Number (really big)
ɳ  push 0123456789
₫  reverse ("987654321")
Ɩ  cast to int ("987654321")
*  multiplies

Perl 6, 730 quadrillion digits
9+<now*now

This builds the Perl 5 solution (time*time) and the Javascript (bit shifting).  Time is currently around 1.56 billion, so we square it (~2.44 quintillion), and then bitshift 9 (because > 1 ha) a fairly insane number of digits to the right.  Perl 6 uses arbitrary precision integers, and that applies to bitshifting as well.  Bit shifting in and of itself doesn't take hardly any time at all, it's just a question of memory restraint and the largest super computers ought to have sufficient, but I don't on my puny laptop.
Given 210x ≈ 103x, we can surmise that there should be around some 730 quadrillion digits if I did my math right.  Times out on TIO for 9+<$x where $x > 1000000, but handles 100000 in sub 1 secs ao no TIO link.  Answer of course will continue to grow exponentially
(if that's considered out of bounds, though, can just make it 9+<now which should still fetch a fairly high number, or any other technique to generate the largest in-bounds number at in 7 digits)

Wouldn't a bitshift of 1 quadrillion (base 2) be 300 trillion digits (base 10)?

@Draco18s erm yes. Should be 730 quadrillion off of 2.4 quintillion digits (a billion squared nets a quintillion not a quadrillion)

I knew one of the two was wrong. I just didn't validate the billion-squared. ;)

@Draco18s I blame my lack of coffee at the time lol.  In any case, result = "really big", certainly bigger than anything not using a built-in ack() function

Keg, 1.85302E+15
It is definitely the worst answer here...
9:*:*:*:*.

Got it up to 221533456↑221533456 by using a for loop with the fact that alpha-numeric characters get auto-pushed to the stack

BBC BASIC 2
7 bytes
P.2^127

Result
1.70141181E38

As commented the previous answer may violate the exponation rule, so here's something using the EXP (exponent) function instead.
P.EXP(88)

which returns
1.65163622E38

Is this using scientific notation?

It is 2 raised to the power of 127, so if that is consider "exponentiation" I'll retract. The example above was 9e+99.

Okay my misunderstanding then.

Deadfish~, ~~2↑4000
{{{iss}}}o
Crashes TIO, but in theory works.
This means:
Repeat 1000 times: add one, than square twice.
First iteration: 0 => 1 => 1 => 1
Second iteration: 1 => 2 => 4 => 16
Third iteration: 16 => 17 => 289 => 83521
And after this it grows without bound.

CSASM v2.3, 9222471316929301708
func main:
push 1.9
bits
asl
print
ret
end

Explanation
The minimum code needed to print something in CSASM is as follows:
func main:
push <something>
print
ret
end

Thus, I took the liberty of having the 10-byte limit be on the <something> rather than the entire program, as is mentioned in the challenge:

You may exclude from the 10-character limit any code necessary to print anything.

Otherwise, this language wouldn't be able to even have a submission for this challenge.
(The boilerplate for an empty main function is 16 bytes.)
So, that leaves me with figuring out how to best use those 10 bytes.  Hence, I abused one of the instructions in the language:  bits
According to the syntax.txt file:

Pops A (an <f32> or <f64>), then pushes an <i32> or <i64> set to the bit representation of A

... where A stands for "the top value on the stack".
In short, a single- or double-precision floating-point value is popped from the stack.  The value's bit representation (sign, exponent, mantissa) is then stored into a 32- or 64-bit integer value and that integer value is pushed to the stack.
Why use 1.9?
The bit representation of 1.9 is:
$$
00111111 11111110 01100110 01100110 01100110 01100110 01100110 01100110
$$
This value interpreted as an i64 (or long) would be 4611235658464650854.  However, this can be better.
Using the last 3 available bytes, we can perform an Arithmetic Shift Left (asl) instruction, to get the following bit representation instead:
$$
01111111 11111100 11001100 11001100 11001100 11001100 11001100 11001100
$$
... which ends up being 9222471316929301708 instead.
If I were to use any value larger than 1.9 within the limits of the 3 bytes for the number (say, 2.0), the exponent part of the bit representation would be 10000000000 or some larger number.
The MSB in the exponent would get shifted left into the sign bit, resulting in a negative end result.  Not good.
Furthermore, if I were to not use the asl instruction and instead opted to use 1.9999, the value would still be smaller than using 1.9 and the asl instruction.

TI-Basic (TI-83), 9.999999314e99
68!4032.2

very close to the soft limit of the calculator (-1e100<x<1e100). It can be overcome and get closer to the hard limit (1e128) but not in less than 10 characters.
69!58.4376 is a good contender too but not as close
TI-Basic (TI-89), 9.99999681785e999
449!259.61

Again, quite close to the limit (1e1000 gets automatically replaced with ∞)

KonamiCode, 1,000,000
v(^>>>>>>)<<< (Note: This excludes <<< because it is used for output.)

C#: 1.8E+19
Unfortunately we can't bit-shift doubles.
using System;
namespace BigNum10Bytes
{
    class Program
    {
        static void Main()
        {
            // Playing with ulongs
            Console.WriteLine(ulong.MaxValue);
            Console.WriteLine(~(1UL<<64)); // 10 chars, 18446744073709551614
            Console.WriteLine(8191UL<<51); // 10 chars, 18444492273895866368

            Console.ReadLine();
        }
    }
}

CJam - 40.4 million digits
1X27m<m<

Assuming bit shift is ok, this calculates 1<<(1<<27). It takes about 15 minutes on my laptop, using java 8 to run the interpreter.

Hey, aditsu, did you design CJam?

@404NotFound yeah, but a lot of it is like GolfScript

Cool, where did you learn parsing to write an interpreter? I'm really interested in parsing etc., but I'm only 12 (no CS courses ;() I'm currently reading "Parsing Techniques: a Practical Guide" and trying to write my toy compiler in C++

@404NotFound I'm not sure I can answer exactly... my first experience with parsing was probably writing an arithmetic expression evaluator, and I learned that from a book or maybe somebody else's source code. In university I learned something about formal languages - finite automata, formal grammars (of different types) and parsing techniques. Then I read a few things on the net about some other types of parsers, and wrote some code to try things out, but I can't say I learned a lot, and I'm not really good at this. I designed CJam to be easy to parse, something like C++ is MUCH MUCH harder.

Of course I'm not trying to parse C++, I mean I write simple parsers in C++... In retrospect, was the university's class really crucial? Or did it have a more mild effect on your learning?

@404NotFound I'm not sure how crucial, but an understanding of the basic formal language theory is definitely important.

units interactive shell, 3.085369e+68
You read that right, I know it's not much but it's definitely different.
9999Ypc
ym

I'm assuming newline counts as a character and the invocation of units counts as code essential to print.
Ypc is yotta parsec, ym is yocto meter.
You have: 9999Ypc
You want: ym
    * 3.085369e+68
    / 3.2411034e-69

Cjam - alot
alot:
99999999m!

even more:
9999999,m!

Unfortunately i cant calculate the result. But refering to wikipedia 14842907m!
would be 2.788662975×10 ^ 100 000 000

99999,m!si should be much larger.

@jimmy23013 but why the si?

To remove the leading zero... or just use two more 9s if that is allowed.

@jimmy23013 ty for the hint, i think 9999999,m! could have won this challange (:

If my calculation is correct it's only about 10^(8.28*10^65657059). Those numbers from Ackermann functions are much much larger.

Note that m! was added in version 0.6.5, this question is much older. Also see Dennis's CJam answer.

SmileBASIC, 8,589,934,592 274,877,906,944
?#RED*#RED

#RED is a constant for the color red (&HFFF80000)
The expression only takes up 9 characters, so I can print it in 10 characters without decreasing the number.

You're not allowed to use exponential functions, unfortunately.

Oh, I can't believe I didn't see that. fixed.

Printing doesn't count in the count, so you'd be able to print it anyway.

I know, but I had 1 byte left over that I couldn't use for anything else

Wolfram
999999999!

Result:
9.90462657922299373728082110506570432171722139002... × 10^8565705513

Eight and a half billion digits!
This is the biggest I could find without using a named function such as "ack()".

Why not 9!!!!!!!!!?  Based on the accepted answer, I don't think anyone cares about run-time and physical constraints anymore.

Wolfram didn't like it when I put two factorial symbols consecutively, it seemed to be applying a different operation.  Try it with 3!! and wolfram returns 3 as the answer instead of 720.  A bug in wolfram?  Do I win a prize ? :)

Apparently "double factorial" is a thing - but it doesn't do what I'd have expected. https://en.wikipedia.org/wiki/Double_factorial

See here on how to do the factorials.

What about ((999!)!)!? I don't know Wolfram, but I expect brackets are supported

Stacked, 10 bytes ~ 2 × 10273964
17932!:*:*

Try it online! Snippet outputs the length, then the number itself.
This calculates (17932!)4 (without exponentiation) using scientific precision, so only a constant width is perpetuated. The number looks like:
204449781735459736090000000000000000...00000000000000000

This Wolfram|Alpha link shows what the precise calculation would look like.

it's currently broken :(

x86_64 machine language (Linux) ~2.808896e+307
0:       f2 0f 10 05 fa ff ff    movsd  -0x6(%rip),%xmm0        # 2
7:       ff
8:       c3                      retq
9:       7f

This moves the IEEE-754 double precision float 7f c3 ff ff ff fa 05 10 to %xmm0 and returns.
Try it online!

Javascript (ES6), 4E+30103
9n<<99999n

Uses big integers so actually goes way past what normal integers could reach.

33, 7,762,279,691,451,941,920
999999axxao

I'm trying to get the language on TIO
About 7.76227969 x 1018

Forth (gforth),  9 bytes, 7 bytes
-1. ud.

Try it online!
Produces:
340282366920938463463374607431768211455

C (gcc), 9 * 10^4202512
printf("9%.*u",""); or printf("9%0*u","");
Try it online!
The shortest way to print anything in C (afaik) is puts(""); which is 9 bytes
19 - 9 = 10
.* specifies precision which isn't exponentiation

.number
For integer specifiers (d, i, o, u, x, X) − precision specifies the
  minimum number of digits to be written. If the value to be written is
  shorter than this number, the result is padded with leading zeros. The
  value is not truncated even if the result is longer. A precision of 0
  means that no character is written for the value 0. For e, E and f
  specifiers − this is the number of digits to be printed after the
  decimal point. For g and G specifiers − This is the maximum number of
  significant digits to be printed. For s − this is the maximum number
  of characters to be printed. By default all characters are printed
  until the ending null character is encountered. For c type − it has no
  effect. When no precision is specified, the default is 1. If the
  period is specified without an explicit value for precision, 0 is
  assumed.

https://www.tutorialspoint.com/c_standard_library/c_function_printf
So you'll get 9 followed by "" digits,(4202512)
the very last ones read from memory as the number to print is not specified,
adding ,0 would prevent memory reading but push it over the 10 byte limit

MathGolf, \$\approx 1.609 \times 10^{1859933}\$
9!!

Try it online!
With MathGolf being a language written in Python, the main issue will be calculating the number in a timely fashion. This program produces its output in about a minute. It might be possible to to \$(10!)!\$, which would be significantly bigger. However, the approach and the byte-count is still the same.

This isn't valid I'm afraid. # isn't allowed because of the rule "You may use any features of your language, except built-in exponentiation functions." But even if you'd change it to *, I doubt it would be valid due to the rule "If it takes longer than an hour to run on the fastest computer in the world, it's invalid." Creating an array of timestamp!!!! amount of items in under an hour would be quite a feat.

@KevinCruijssen Oh, I should definitely have read the question more thouroughly... I'll think of another approach, and update the answer when I have one.

@KevinCruijssen fixed and verified.

1+, score 256
11+"*"*"*:

Begin with 2, square three times, and we get 256. I believe this is optimal.

C++ (gcc) (x86/x86_64), 1.18973e+4932
Improvement on an answer from an inactive user.
#include <iostream>
#include <cfloat>
int main()
{
    std::cout << LDBL_MAX+0 << std::endl;
}

Try it online!
Equivalent C version using printf which shows all digits.
Depends on the implementation, but x86 chips on Linux use an 80 bit extended double for long double. This results in LDBL_MAX being 1.18973e+4932, much larger than ULLONG_MAX.

Just so you know, the +0 isn't required as you don't need to use all 10 bytes. You don't gain anything from removing it either, though. I'm just saying ;)

05AB1E, \$\Large>1.0111110111×10^{146,337}\$
žmbbbbbbbb

Try it online! This is the only competing one, the alternative breaks rule 5.
žmbbbbbbbb  # full program
         b  # convert...
žm          # 9876543210...
  b         # in binary...
   b        # in binary...
    b       # in binary...
     b      # in binary...
      b     # in binary...
       b    # in binary...
        b   # in binary...
         b  # to binary
            # implicit output

Alternative
This program scores:
$$\large(r_{((x+1)^7-1)}=…(r_2=(r_1=x^x)^{r_1})^{r_2}…)^{r_{((x+1)^7-1)}}\\\Huge x=9{,}876{,}543{,}210$$Note: here, \$\large r_2\$  means the second result. So \$\large r_{((x+1)^7-1)}\$ means the \${\large{((x+1)^7-1)}}^\text{th}\$ result.
žmEEEEEEEm

žmEEEEEEEm  # full program
  E         # for N in [0, 1, ...,
žm          # ..., 9876543210...
  E         # ]...
   E        # for N in [0, 1, ...,
žm          # ..., 9876543210...
   E        # ]...
    E       # for N in [0, 1, ...,
žm          # ..., 9876543210...
    E       # ]...
     E      # for N in [0, 1, ...,
žm          # ..., 9876543210...
     E      # ]...
      E     # for N in [0, 1, ...,
žm          # ..., 9876543210...
      E     # ]...
       E    # for N in [0, 1, ...,
žm          # ..., 9876543210...
       E    # ]...
        E   # for N in [0, 1, ...,
žm          # ..., 9876543210...
        E   # ]...
         m  # push...
žm          # 9876543210...
            # (implicit) or top of stack if not first iteration...
         m  # to the power of...
žm          # 9876543210...
            # (implicit) or top of stack if not first iteration
            # implicit output

I've removed most of the \large elements in the $\LaTeX$ as they're unnecessarily obtrusive


text:
Is this word on the boggle board?
Introduction
After a day of drinking and watching the world cup, you sit down to play friendly game of boggle. Tempers rise as you are accused of wasting everyone's time with nonsense words that aren't even on the board! You may be seeing double, but surely you're thinking straight enough to write a program that will verify that your words are on the board.
Your Task
Write a program, script, or function that takes a boggle board and a word as input, and returns True if the word is on the board and False if the word isn't.
The input will be in the form of six \n delimited lines. The first five lines will comprise the 5x5 boggle board and will each contain five capital letters. The sixth line will contain the word-in-question, also in all capital letters.
Sample input:
AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER

The output can be anything that unambiguously signifies True or False in your programming language of choice and adheres to standard conventions of zero, null, and empty signifying False.
Sample output for above input:
1

I/O Guidelines

The input may be read from stdin, and answer output to stdout.

Or

The input may be a single string argument to a function, and answer be the return value of that function.

Boggle Rules

A word is 'on the board' if you can construct the word via a path of consecutive, adjacent, non-repeating tiles on the board.
A tile is considered adjacent to the eight tiles that surround it (diagonal paths are allowed). Tiles on the edge of the board are adjacent to only five tiles. Tiles in the corner are adjacent to only three.
Consecutive letters in the word must be adjacent, the ith letter in the word must be adjacent to the i-1th and i+1th.
A letter may appear in a word more than once, but you cannot use the same square on the boggle board more than once per word.
The online boggle site wordsplay.net may be useful if you have never played boggle before, but want to get a feel for these rules.

Unlike regular boggle:

You do NOT have to worry about the word being a valid English word.
There will be NO Qu single tile.
The word-in-question may be of any length > 0

Example
On the board of
AJNES
TNFTR
LSAIL
UDNEX
EQGMM

These words should return True: FATE, DATING, STANDS, LIFTS.
These words should return False: SADDEN, SULTANS, EXIST, SUEDE, QUEST
This is a code-golf challenge, so shortest code wins!

Does the board wrap around? I can't remember

No it doesn't wrap, I updated the clarification about adjacency to reflect this.

Can the path cross itself (diagonally)?

@m.buettner Yep

Boggle is normally a 4x4 board.

GolfScript, 74 characters
:^n%5>)]){{^@==}+29,\,{{+}+1$/}%\;}/{:s$..&=[s{.@-\}*;]1567`{7&.~)}%-!&},,

The input must be given on STDIN. Prints the number of valid paths on the board, i.e. 0 for none and a positive number (true) else.
You can test the example online.
Code with some comments:
:^              # assign the input to variable ^
n%              # split at newlines
5>              # truncate array such that [WORD] remains
)])             # prepares [[]] and WORD on the stack

# the following loop generates all possible paths (valid and invalid ones)
# by looking up all index combinations which yield the correct word
{               # loop over all characters
  {^@==}+29,\,  # get all indices of current character in the board
  {{+}+1$/}%\;  # append any index to all lists in the result set
}/              # end loop

# filter the results list for valid paths
{               # {...}, -> apply filter
  :s            # save path to variable s
  $..&=         # check if all numbers in path are unique
  [s{.@-\}*;]   # calculate differences along the path
  1567`{7&.~)}% # generate the array [1 -1 5 -5 6 -6 7 -7] of valid
                # differences
  -!            # check if all differences were valid
  &             # are both conditions fulfilled?
},              # end of filter block

,               # count the number of remaining paths

Javascript (E6) 137 160 175 190
Less than 2*Golfscript. Moral victory ...
F=a=>[...a].some((e,p,b)=>(Q=(p,n)=>p>29||b[p]!=b[n]||(b.r|=!b[++n])||(b[p]=b[n+~[1,5,6,7].map(q=>Q(p+q,n)|Q(p-q,n),b[p]=0)]))(p,30)&b.r)

Edit Golfed code reorganization. Again and again
Ungolfed Last version, a bit tricky to follow
F = a =>
  [...a] // input string to array, 30 chars of board then the target word
  .some ( // use some to scan the board, return true when found
      (e,p,b)=> // params to callback: element, position, complete array
      (         // NB array b has no .r property, so use it for return value (it's undefined at start)
        Q = (p,n) =>         // Scan function, p=position in board, n=nth char of target word
          p > 29 ||          // Chaek if going outside the board to the target word
          b[p] != b[n] ||    // if invalid char at current position, return
          (b.r |= !b[++n]) ||  // if at end of target, set r to 1 and return (also increment n )
          (                  // else... (NB next tree lines are coalesced in golfed code)
            b[p] = 0,        // remove current char (to avoid reusing)
            [1,5,6,7].map( q => Q(p+q,n)|Q(p-q,n)), // recursive call for + - 1,5,6,7
            b[p] = b[n-1]    // put current char into array again
          )
      )(p,30) & b.r // initial position 0 in target word is 30 in the array
  )

Ungolfed First version , should be clearer
F = a => (
  b = a.split('\n'),
  w = b.pop(),
  r = 0,
  Q = (p, n) =>
    (r |= !w[n]) ||
    (
      b[p] = 0,
      [1,5,6,7,-1,-5,-6,-7].map( q => b[q+=p]==w[n] && Q(q,n+1)),
      b[p] = w[n-1]
    ),
  b = [...b+''],
  b.map((e, p) => e==w[0] && Q(p,1)),
  r
)

Usage
F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\nLIFTS\nDAFTER")

Test
['DAFTER', 'STANDS', 'LIFTS', 'FATE', 'DATING' ,
 'SADDEN','SULTANS', 'EXIST', 'SUEDE', 'QUEST']
.map(w => [w, F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\n" +w)])

Output:
[["DAFTER", true], ["STANDS", true], ["LIFTS", true], ["FATE", true], ["DATING", true],
["SADDEN", false], ["SULTANS", false], ["EXIST", false], ["SUEDE", false], ["QUEST", false]]

some minor optimzation: F=a=>(b=a.split('\n'),w=b.pop(Q=(p,n)=>((R|=!w[n])||(b[p]=0)||[1,5,6,7,-1,-5,-6,-7].map(q=>b[q+=p]==w[n]&&Q(q,n+1,b[q]=w[n])))),[Q(~~p,1)for(p in b=[...b.join(R=0)])if(b[p]==w[0])],R)

Is it supposed to be w = a.pop() (golfed) or w = b.pop() (ungolfed, line 2)? (probably the latter, I think)

@androyd I left the older ungolfed code for clarity, after reorganizing. But it's not 100% in sync. I'll try to clarify

My bad, did not see you changed it to a=a.pop() instead of b=a.pop()...

J - 75 char
Eugh, this one looks nasty. And not even tying with Golfscript! This is a function taking a string as its sole argument. You can use any one-character delimiter as long as it's found at the end of each line, including the last.
+/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)

An explanation follows. Note that the function can be cleaved into 5 distinct top-level parts, each separated by @, so we will treat each of those parts separately, from right to left.

(<;._2) - This splits the lines up on the newlines/separator characters. It uses the character at the end of the string as the character on which to split. We put everything into boxes (<) because if we don't we get some padding issues when J gives us the result back.
(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:) - For each letter in the word to check, create a list of indices in the Boggle board where one can find that letter.

{: is the last split piece (the word to check) and }: is everything but the last (the Boggle board).
&:> opens up the boxes we made previously, with the useful byproduct of turning }: into a 2D array of characters. =/ then makes a copy of this Boggle board for each letter in the word, and turns the positions into booleans depending on whether the letter in the board matched that letter in the word.
((<@#:i.)5 5) is a short way of expressing a 5x5 array of indices. x#:y is converts y into an array of the base x representation. (Well, almost. The truth is more complex, but this works for our purposes.)
<@#~&,"2 - For each letter's resulting boolean matrix, collect all the correspondingly true indices together. "2 makes everything work on on the right results, #~&, does the selecting, and <@ collects each result into a box to prepare for the next step.

{ - This verb, used monadically, is called Catalogue, and it takes a list of boxes as argument. It combines the insides of each box in every possible way. So e.g. a catalogue on some boxes containing the strings "AB" and "abc" would give the results "Aa", "Ab", "Ac", "Ba", "Bb", "Bc".
Running this on our boxed list of lists of indices makes every possible combination of indices. This can be a big set if there the word is long and there are many repeated letters, but also empty if any letter is not on the board. We also note that we reuse tiles in some of these paths: we will account for this later.
([:*/"1^:2(2(=*)@-/\>@~.)S:1) - Here we check each path to see if it's valid.

(...)S:1 applies the (...) to each path and collects the results into a flat list. This is crucial because the result of { is a multi-dimensional array, and we don't care about the structure of that array, just its contents at each box.
2(=*)@-/\> gives a 1 if each coordinate of each index is at most one away from the one following it, and 0 otherwise. The 2 and the /\ are responsible for doing this pairwise.
*/"1^:2 logical-ANDs these all together at the end. The [: part is a structural thing in J, don't worry about it.
Adding @~. to the > is actually a clever way to exclude paths with repeated entries. ~. takes the unique items of a list, so the list is shortened if it self-intersects, and shorter lists get automatically padded with 0s when they're put together, like the way that the results are combined as they come out of S:. This is ultimately shorter than explicitly excluding self-intersecting paths.

+/ - Finally, we simply add everything together at the end. The result is the number of valid paths that make the word on the board, with 0 meaning no paths, i.e. this word is not on the board. For the cost of one character, we can write +./ (logical-ORing everything together) instead, which will explicitly give a boolean 1 or 0.

Here are some example runs. You can get the J interpreter at jsoftware.com or try it online at tryj.tk.
   NB. the  0 : 0 ... )  thing is how you do multiline strings in J
   +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2) 0 : 0
AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER
)
1
   b =: +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)
   b 'AJNES TNFTR LSAIL UDNEX EQGMM FATE '    NB. any separator will do
1
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SADDEN '  NB. not on the board
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SANDS '   NB. self-intersecting path
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM MEND '    NB. multiple paths
2

+1 for the details. I'd like to see more answer like this!

Python, 207 204 203
g=raw_input
r=range
b=''.join(g()for _ in r(5))
w=g()
s=lambda b,w,i:0<=i<25and(not w or(b[i]==w[0])*any(s(b[:i]+'_'+b[i+1:],w[1:],i+j+k*5-6)for j in r(3)for k in r(3)))
print any(s(b,w,i)for i in r(25))

Replacing ... (b[i]==w[0])*any ... with ... b[i]==w[0]and any ... gives much better performance at the cost of 2 characters.

You can shave off spaces when they're between numbers and commands; 0<=i<25and

Prolog - 315
r(L):-get_char(C),(C='\n',!,L=[];r(T),L=[C|T]).
b(0,[]):-!.
b(N,[R|T]):-M is N-1,r(R),b(M,T).
d(-1). d(0). d(1).
d([A,B],[C,D]):-d(X),C is A+X,d(Y),D is B+Y.
f([L|W],B,P,U):-P=[X,Y],nth(Y,B,R),nth(X,R,L),\+member(P,U),(W=[];d(P,Q),f(W,B,Q,[P|U])).
m:-b(5,B),r(W),f(W,B,_,[]),write(t);write(f).
:-initialization(m).

I thought Prolog might be a good language for this one, with the built-in backtracking support, but I guess it's more handicapped by needing a variable for almost every computed value.
Tested with GNU Prolog; should be compliant with ISO Prolog.
Ungolfed:
get_line(Line) :-
    get_char(C),
    (   C='\n', !, Line=[]
    ;   get_line(Tail), Line=[C|Tail]
    ).

% The cut prevents recursion to help_get_board(-1, MoreRows)
% (and golfs one character shorter than putting N>0 in the second rule).
help_get_board(0, []) :- !.
help_get_board(N, [Row|Tail]) :-
    M is N-1, get_line(Row), help_get_board(M, Tail).

% The golfed version doesn't define an equivalent to get_board/1.
% help_get_board(5,Board) is used directly instead.
get_board(Board) :- help_get_board(5,Board).

small(-1). small(0). small(1).
step([X1,Y1],[X2,Y2]) :-
    small(DX), X2 is X1+DX,
    small(DY), Y2 is Y1+DY.

% The golfed version doesn't define an equivalent to letter_at/3.
% See find_word/4.
letter_at([X,Y], Letter, Board) :-
    nth(Y, Board, Row),
    nth(X, Row, Letter).

find_word([Letter|Word], Board, Pos1, Used) :-
%    letter_at(Pos1, Letter, Board),  % "inlined" to next three lines:
    ( Pos1 = [X,Y],
      nth(Y, Board, Row),
      nth(X, Row, Letter) ),
    \+member(Pos1, Used),
    (   Word=[]
    ;
        step(Pos1, Pos2),
        find_word(Word, Board, Pos2, [Pos1|Used])
    ).

main :-
    get_board(Board),
    get_line(Word),
    % Begin at any position. Initially no positions are "Used".
    find_word(Word, Board, _, []).

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
The Love Letter Mystery
At Hackerrank.com, the love letter mystery is a simple programming problem, which I already solved.
My solution involved calculating the palindrome and counting the number of operations to do it.  On Hackerrank, they have another approach, which I don't understand completely:

Given a string, you have to convert it into a palindrome using a certain set of operations.
Let's assume that the length of the string is L, and the characters are indexed from 0 to L-1. The string will be palindrome, only if the characters at index i and the characters at index (L-1-i) are same. So, we need to ensure that the characters for all such indices are same.
Let's assume that one such set of indices can be denoted by A' and B'. It is given that it takes one operation in decreasing value of a character by 1. So, the total number of operations will be |A'-B'|.We need to calculate this for all such pairs of indices, which can be done in a single for loop. Take a look at the setter's code.

I understand everything up until they mention that the total number of operations are |A'-B'|, the absolute value between the two indices.  Why is that?  For some reason, my head is being thicker (than usual).
Thanks!
======== EDIT ==========
Hey guys, thanks for your input. I thought that this stackexchange site would had been more appropiate than stackoverflow. Is there any stackexchange site where this question is more appropiate?

This question appears to be off-topic because it is not a programming contest or a question about code golfing.

@ProgramFOX It's a question about a programming puzzle, though, isn't it?

@m.buettner It's a question about a specific approach to solve a programming puzzle, but it has nothing to do with code.

@m.buettner: The help center says that all questions on this site should have an objective primary winning criterion, and that "tips for golfing in some language" is the only exception to this rule.

@Dennis this is currently being discussed in a lot of detail in chat and on meta, and there are a fairly large number of people who would welcome more non-challenge posts on the site, as it is still a site about Programming Puzzles & Code Golf (in addition to being a site for Programming Puzzles & Code Golf). As long as no consensus on this has been reached, I'd say closing or downvoting such questions is up to everyone's own opinion, but my opinion is we should welcome these questions, because they seem very much on topic to me and could well increase our traffic.

@m.buettner I agree that we should welcome non-challenge questions, but this question is more related to algorithms than to programming and code.

Hey guys, thanks for your input.  I thought that this stackexchange site would had been more appropiate than stackoverflow.  Is there any stackexchange site where this question is more appropiate?

@dornad I maintain it's on topic here, but until 4 other people decide to vote to reopen this question that's not of much help to you. In any case, as for your actual question, I suspect that there is a typo in their answer, and that A' and B' refer to the character values at the current pair of indices. What does their code do?

@m.buettner: I think those questions would make a nice addition to our site and I did not downvote this one, but I'll always vote to close according to the rules laid out in the help center.

My best guess is no, you can't ask this question at Stack Exchange. You can't ask it here (because it is closed), and I don't know any other Stack Exchange site about programming puzzles.

HackerRank has its own discussion pages for each problem. Here's the discussion page for the problem you mentioned.

The algorithm might make more sense with a sample implementation to look at (here, in Python):
S = raw_input()
L = len(S)
T = 0
for i in range(L/2):
  A = ord(S[i])
  B = ord(S[L-1-i])
  T += abs(A-B)
print T

Let's review the problem description. Each character decrement (e.g. --'b' == 'a') counts as a single operation. The problem is to determine the number of operations required to transform the input string into a palindrome.
The algorithm iterates over half the string, and compares the ordinal value of the character at the current index with that of the character across from it (in its mirrored position). If they are not the same, the one that is larger needs to be decremented, but it doesn't actually need to be checked which is which. Taking the absolute value of the difference will produce the correct number of operations needed regardless.
I think a source of confusion might be the wording, "Let's assume that one such set of indices can be denoted by A' and B'." I believe that the author intended A' and B' to refer to the characters at each of these indices, and not the indices themselves. If they had actually meant to refer to the indices, the algorithm would return the same value for any given string length, which is obviously incorrect.
A golfed version might look like this:
s=map(ord,raw_input())
print sum(abs(s[i]-s[~i])for i in range(len(s)/2))

I suspect Ruby might be a bit shorter, because indexing a string returns the ordinal value, rather than the individual character.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/