Output 16777215.
Test case: -> 16777215
Scrack example: 88^D

Write a program that does nothing, and runs indefinitely.
Scrack example: 1@

Input a string, then output it. Repeat this ten times total.
Test case: "test" -> "test" -> "testing" -> "testing" -> "Test" -> "Test" -> "test!" -> "test!" -> "test." -> "test." -> "1234" -> "1234" -> "lol test" -> "lol test" -> "test?!?" -> "test?!?" -> "tset" -> "tset" -> "test" -> "test"
Scrack example: ar|

Input a number. Assume it is positive. Output that number raised to its own power.
Test case: 4 -> 256
Test case: 0.5 -> 0.7071068
Test case: 4.555535705 -> 1000
Scrack example: .^

Input four numbers. Assuming they are a, b, c, and d, in order, output (b-d)/(a-c) or (d-b)/(c-a).
Test case: 0 0 1 1 -> 1
Test case: 3 2 1 6 -> -2
Test case: 7.75 1.7 7.8 -60 -> -1234
Scrack example: ~?-?;_\

Output "guess the password", then take input from the user. If the user returns "the password", end
the program. Otherwise, start from the beginning, and continue outputting "guess the password" until
the user gives "the password". Case sensitivity is optional.
Test case: "guess the password" -> "the password"
Test case: "guess the password" -> "foo" -> "guess the password" -> "the password"
Test case: "guess the password" -> "password" -> "guess the password" -> "1234" -> "guess the password" -> "the password"
Scrack example: "guess ""the password":+|.$=!(f@)Z

Input a number; assume it is between 1 and 51, inclusive. Output the number of possible hands of
playing cards given that many cards.
Test case: 2 -> 1326
Test case: 5 -> 2598960
Test case: 7 -> 133784560
Scrack example: y52i.i_!,!*i!\

Input a string. Then output the lyrics to the song "99 Bottles of Beer", but replace every instance
of "beer" with the inputted string. Lyrics can be found here:
http://www.99-bottles-of-beer.net/lyrics.html
Scrack example: " bottles of "i" on the wall"j"Take one down and pass it around, "k"1 bottle of "nuo moreoly99mmDDfERmiljy, milz.AmDMkmiljz.Amiljy, milz.Aknljz.Anljy, nlz.Akznoiljz.AzNoiljx, noilz.A"Go to the store and buy some more, 99"iljz.A

Write a program that outputs its own source code. You may not exclusively use tokens that return
themselves, and you may not use any commands that return the program's source code. Your program
must have a nonzero length. You may output the source code in any form that can be executed by
your interpreter.
This program is called a quine. If your language is Turing complete, then you are guaranteed to be
able to write a quine. Before complaining that this is too difficult/impossible, do a little research
and you may find that it isn't so hard after all. (unless, of course, you have a compressed
language... It is still technically possible, but could be very difficult, depending on how you
handle string literals. I've allowed compressed languages to output their source in any form
to try to make the process less painful.)
Scrack example: "Q,:A"Q,:A

Input a string. Assume that it is either "Bulbasaur", "Ivysaur", "Venusaur", "Charmander",
"Charmeleon", "Charizard", "Squirtle", "Wartortle", "Blastoise", or "Ditto". Output that
Pokemon's Pokedex number (1-9 in order). If the input was "Ditto", you can output any
number from 1 to 721.
Test case: "Squirtle" -> 7
Test case: "Ditto" -> [up to program creator's discretion] 1
Test case: "Venusaur" -> 3

Input two strings. Output the total number of instances that they occur in each other. Case sensitivity
is optional.
Test case: "aba" "ababa" -> 2
Test case: "hi" "hello" -> 0
Test case: "www" "wwwww" -> 3
Test case: "!@#$" "!@#$" -> 2

Input a number, p. Assume it is an integer larger than 2. Then input 2*p numbers. These numbers form
(x,y) coordinate pairs, and they are the vertices of a p-sided polygon (no intersecting line segments).
Output the area of the polygon.
Test case (parentheses added for readability): 4 (0 0) (1 0) (1 1) (0 1) -> 1
Test case: 3 (-2 -2) (10 0) (-1 7.7) -> 57.2
Scrack example: ppD4R??ss??.,~.,~p7RI*~i*-,pDr+2/U

Input a number, p. Assume it is an integer larger than 1. Then input 2*p numbers. These numbers form
(x,y) coordinate pairs, representing points which all lie on the graph of a (p-1)-degree polynomial
function. Output the coefficients of the polynomial.
Test case: (parentheses added for readability): 2 (1 1) (2 3) -> 2 -1
Test case: 3 (1 1) (2 3) (3 -5) -> -5 17 -11
Test case: 4 (1 1) (2 3) (3 -5) (-8 5.3) -> -.47707 -2.13758 11.75222 -8.13758

Input a string. Then input two numbers. Assume they are between 2 and 10, inclusive. Assume the given
string is a number in base (1st inputted number). Output the same value in base (2nd inputted number).
Test case: "1010" 2 10 -> "10"
Test case: "1010" 10 2 -> "1111110010"
Test case: "247" 8 9 -> "205"

Input a string. Assume that it is composed exclusively of these characters: "1234568790-+*/". Assume
that any operator (-+/*) is preceded and followed by a number. Simplify the expression following
standard mathematics and output the numerical result. Rather than list all of the rules of standard
mathematics, I'll say that the result should be identical to using eval() in Javascript or typing the
string into a Google search.
Test case: "1+1" -> 2
Test case: "2*3+4/5-6" -> 0.8
Test case: "105*4*0+3/9*10" -> 3.3333333

88^D
8    push 8                      (8)
 8   push 8                      (8,8)
  ^  pop twice, push result      (16777216)
   D pop, decrement, push result (16777215)
implicit output (16777215)



1@
1  push 1 (1)
 @ pop and goto 1



ar|
a   push 10 (10)
 r  pop and repeat the next character that many (10) times
  | implicit input, output



.^
.  implicit input, pop and push double (a,a)
 ^ pop twice, push push result         (a^a)
implicit output (a^a)



~?-?;_\
~       implicit input twice, flip last two on stack            (b,a)
 ?      input                                                   (b,a,c)
  -     pop twice, push result                                  (b,a-c)
   ?    input                                                   (b,a-c,d)
    ;   take from the bottom of the stack and put it on the top (a-c,d,b)
     _  pop twice, push result (_ is identical to ~-)           (a-c,b-d)
      \ pop twice, push result (\ is identical to ~/)           ((a-c)/(b-d))
implicit output ((a-c)/(b-d))



"guess ""the password":+|.$=!(f@)Z
"guess "                           push "guess "                                 ("guess ")
        "the password"             push "the password"                           ("guess ","the password")
                      :            double duplicate (ab->abab)                   ("guess ","the password","guess ","the password")
                       +           pop twice, push result (concatenates strings) ("guess ","the password","guess the password")
                        |          pop and output "guess the password"           ("guess ","the password")
                         .         pop and duplicate                             ("guess ","the password","the password")
                          $        input a string                                ("guess ","the password","the password",a)
                           =       pop twice, push result                        ("guess ","the password",(true or false))
                            !      pop and push result (logical not)             ("guess ","the password",(false or true))
                             (f@)  run if true
                              f    push 23
                               @   pop and goto 23 (":")
                                 Z empty the stack to prevent implicit output



y52i.i_!,!*i!\
y52            push 52                      (52)
   i           pop and set i                ()(i=52)
    .          implicit input and duplicate (a,a)(i=52)
     i         push i                       (a,a,52)(i=52)
      _        pop twice and push result    (a,52-a)
       !       pop and push result          (a,(52-a)!)
        ,      pop and send to top of stack ((52-a)!,a)
         !     pop and push result          ((52-a)!,a!)
          *    pop twice and push result    ((52-a)!*a!)
           i   push i                       ((52-a)!*a!,52)
            !  pop and push result          ((52-a)!*a!,52!)
             \ pop twice and push result    ((52!)/((52-a)!*a!))
implicit output ((52!)/((52-a)!*a!))



" bottles of "i" on the wall"j"Take one down and pass it around, "k"1 bottle of "nuo moreoly99m
" bottles of "i                                                                                 i=" bottles of "
               " on the wall"j                                                                  j=" on the wall"
                              "Take one down and pass it around, "k                             k="Take one down and pass it around, "
                                                                   "1 bottle of "n              n="1 bottle of"
                                                                                  uo moreo      o="o more" (u delimits 6-char literal)
                                                                                          l     l=implicit input
                                                                                           y99m m=99 (y delimits 2-char literal)

mDDfERmiljy, milz.AmDMkmiljz.A
mDD                            put 97 on the stack
   fE                          put 24 on the stack (f=23,E=increment)
     Rmiljy, milz.AmDMkmiljz.A repeat this 24-length string 97 times
      milj                     put vars m, i, l, and j on the stack
          y,                   put ", " on the stack
             mil               put vars m, i, and l on the stack
                z.             put "." on the stack
                  A            concatenate the stack and output
                   mDM         m=m-1
                      kmilj    put vars k, m, i, l, and j on the stack
                           z.  put "." on the stack
                             A concatenate all and output

miljy, milz.Aknljz.Anljy, nlz.Akznoiljz.A
miljy, milz.A                             explained before
             knljz.                       put k, n, l, j, and "." on the stack
                   A                      concatenate all and output
                    nljy, nlz.            put n, l, j, ", ", n, l, and "." on the stack
                              A           concatenate all and output
                               kznoiljz.  put k, "n", o, i, l, j, and "." on the stack
                                        A concatenate all and output

zNoiljx, noilz.A"Go to the store and buy some more, 99"iljz.A
zNoiljx, noilz.                                               put "N", o, i, l, j, "x, ", n, o, i, l, and "." on the stack
               A                                              concatenate all and output
                "Go to the store and buy some more, 99"       put this string on the stack
                                                       iljz.  put i, l, j, and "." on the stack
                                                            A concatenate all and output



"Q,:A"Q,:A
"Q,:A"     push "Q,:A"                  ('Q,:A')
      Q    push the quote character     ('Q,:A','"')
       ,   send to the end of the stack ('"','Q,:A')
        :  double duplicate             ('"','Q,:A','"','Q,:A')
         A concatenate all and output     "   Q,:A   "   Q,:A



ppD3R??:??.,~.,~p7RI*~i*-,pDr+2/U
p                                 p=input
 pD                               push p-1
   3R??:                          repeat "??ss" p-1 times
     ??                           push input twice
       :                          double duplicate
        ??                        push input twice
          .,                      insert a copy of the last stack item to the beginning of the stack
            ~.,~                  insert a copy of the 2nd to last stack item to the beginning of the stack
                p7RI*~i*-,        repeat "I*~i*-," p times
                   I              i=pop
                    *             pop twice and multiply
                     ~            switch last two stack items
                      i           push i
                       *          pop twice and multiply
                        -         pop twice and subtract
                         ,        send result to top of stack (to be summed next)
                          pDr+    repeat "+" p-1 times (there should be p items in the stack, so this will sum up the stack)
                              2/  divide result by two
                                U absolute value

 =