JavaScript (ES6)

Ok, ES6 probably wasn't around in 2016, so I guess I can't win this competition which finished 9 years ago. :)

Challenge 1, 74

``+``*``^`\`\!!!!!#$$%&())))...1449:=@@@AHILOQQQTTZeefmpxy{||||~~~~~~~~~'`

abcn, score 65

The Challenges :

RUN : (73 bytes)

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

How it works :

Every thing other than @ (which is for input) is not present in current version of abcn. Note : abcn treats everything save its commands as simple comments so all of it is one big comment the three @ since we give no output are automatically set to 0.

I can obviously increase the length infinitely by doing nothing but bull but wont do it. (Alternate program down below) (scrapped it since I was 130 bytes in and not even 1/4th of the way done)

I/O : (8 bytes)

@agxbbgx

How it works :

@                                 --> asks for input
a                                 --> adds one
g                                 --> converts to ASCII
x                                 --> prints
bb                                --> b takes back to input second takes back by 1 more so we at input - 1
gx                                --> converts to ASCII and prints

Don't think can do remaining now.

Total score : 73 - 8 => 65

Vyxal, score 74

Run, 74 bytes

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Try it Online!

The rest aren't easily possible.

///, Score: 146

1. Run, Score: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Score: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Yay, when there aren't any forward or back slashes in the code, it just prints itself.

Jelly, score 74

1. Run, 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Not sure how to do any of the others.

Perl 6, total score 74

1. Run, score 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

No comments.
(Just putting the # at the front to make everything a comment also works, but this is more fun.)

Work

This is the subset of the Perl 6 language that only uses the allowed characters:

Constants:   e

Type names:  IO

Functions:   exp

Methods:
    on type IO:   .e  .f  .x
    (...probably more.)

Operators:     |  infix:               |  prefix:
    -----------+-----------------------+---------
    numeric:   |  +  *  +^  +|  +&  %  |  +  +^
    string:    |  ~  x  ~^  ~|  ~&     |  ~
    boolean:   |  ||  ~~               |  !
    junctions: |  |  &  ^              |  
    misc:      |  =  :=  Z  ..  ...    |  

syntax:
    number literals:  1  4  9
    string literals:  Q` `  Q! !   etc.
    shell commands:   Q:x` `  Q:x! !   etc.
    Whatever star:    *
    variables:        my  \  $  @  &
    grouping:         (  )
    comments:         #  #`( )
    unspace:          \

The immediate hurdle preventing the challenges 2-6, is that there doesn't seem to be a way to do I/O:

• If we assume there's a file called f, we could use Q`f`.IO.e to check if it exists or Q`f`.IO.x to check if it is executable. But we can't read it or write from it.

• We could use Q:x` ` to run a shell command (assuming we find the characters for one). But we can't interpolate anything into, so it would only be good for reading, not writing.

• Since there is no closing brace, we can't make a block lambda (e.g. {1 + $_}) that automatically returns the value of its last statement.

• We could use the asterisk to make an expression lambda (e.g. 1+*), but then we can only take one argument, refer to this argument only once, and are even more limited in the syntax/operators we can use.

SmileBASIC, 48 points

challenge 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

explanation:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

others:

No input/output commands are avaliable, so the rest are not possible.

Still, not bad for a real language without using comments.

Brainfuck, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

I just had to.

Explanation:

Any character that is not a valid Brainfuck character is treated as a comment. The only code that actually gets run is this:

.+..

This produces no printable output, since neither 0 nor 1 are printable characters in ASCII. However, it does not cause an error, so we successfully complete the first challenge.

memes, score of (62 65 + 70) 135

1: Run

I removed all backticks (`) and mathematical operators. They conflicted because there weren't enough numbers to satisfy every unary and binary operator. I left some in, resulting in +3 bytes. Resulting program:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

I have no idea why and how this worked. Atleast it doesn't throw any C# runtime exception, and doesn't therefore crash.

6: Quine

1/4I

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Fraction strings (e.g. 1/4) are displayed with an I at the end, to indicate exactly that. The I operator is usually useless, I added it for other means, but hey, it works like this!

Above code is invalid. Stupid me didn't see that the 74 characters don't contain a single division operator, forwardslash (/). I came up with something else though:

True

Explanation:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Outputs True (because of how the way C# handles Boolean.ToString() uppercase and not lowercase). Not sure if this is a proper quine, meanwhile I'm still cracking my head for a valid, really proper, and intuitive one.

Could maybe also solve I/O and Math challenge, but I'm missing specific tokens (characters) which aren't included in the 74 characters.

J, score 71 + (74 - 19) = 126

Task 1, length 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

This defines a verb AHILO to be the inside. Unused:

)))

I don't think there's any way to get longer than this.

Task 3, length 19

+($#~$~4)=1e4|&%:*~

The way to do this task with no restrictions is +16=100|], which reads as follows:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

We have +, = and several copies or | in our disposal, and it's easy to get around ], but the numbers are more problematic. Here's the first part that computes input modulo 100:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

After we're done with that, let's produce the number 16. The easy way is with *~4 (4 multiplied with itself), but we already used * so that's forbidden. Instead, we'll do some array manipulation.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Work

2

This is most definitely impossible. The only ways to manipulate character values are a. and u:, and we have access to neither.

Now, if we could use a instead of, say, A, then this would be a solution:

Q{~(*^.4%9 1)+I.~&Q=:a.

The hardest part to getting this to work was producing the number -1.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

This generates the shape of the husk, but I can't seem to find a way to generate characters. Alas.

5

Admittedly, this seems like the easiest of the tasks to do in J. However, without i., this will be quite hard.

6

This is likely impossible without a fake-out quine like 449 or something like that, because the capsule string doesn't contain quotes or any other way of producing J strings.

bash, score 74

1: Run. We can run all 74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esotericism:

The empty program is a quine in bash.

Without any whitespace characters, nothing else on the list can be accomplished. Ergo, I have the winning bash entry.

Lua, score 31

1. Run (31 of 74 points)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

CJam, 74 + (74 − 14) + (74 − 26) = 182 score

1. Run (74 bytes)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Moving e# to the front comments out the entire line.

2. I/O (14 bytes)

9`)ZH*+~):Q(Q)

Dennis saved 8 bytes.

Explanation:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Branchability (26 bytes)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Explanation:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

I’ll look at the others later. (EDIT: I doubt they’re possible, without block or string literals… maybe the math one?)

Pyth, 131 for now (2 challenges complete)

1. Run, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

This program takes no input and creates no output.

This program uses $$, which allows arbitrary code execution, and so is banned online, so this program online runs offline. Here's its compilation output, so you can see what actually gets run:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

It's fairly tricky to write a program with arbitrary characters that doesn't error in Pyth. I set myself the additional challenge of requiring that the program run without requiring user input, as well.

The first step is to use # to eat all of the errors. Next, we need to avoid errors caused by ~, I and L, which each have their own details. This is achieved by putting them inside the $$, which embeds them inside the output compilation, and thus subjects them to Python's compilation rules, not Pyth's. Finally, to avoid taking user input, the various arity 0 tokens (Variables and similar) are placed at the end, and the Qs are moved inside the $$ block.

2. IO

This will be incredibly difficult, if it's even possible. None of the Pyth functions that create arbitrary strings or characters are present except .f, and that does a really poor job of creating arbitrary characters.

3. Branchability: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Try it online

An equivalent Pyth program would be:

?n%Q100 16Q+1

This code takes the input mod 100, compares it to 16, and then uses a ternary to choose between the input and the input plus one. Due to character restrictions, I made some substitutions:

• Instead of ?, the ternary, I used |&, or then and, which has the same functionality, except that it breaks if the input is zero, but since we're guaranteed positive integer input, it's fine. (This could have been fixed for no additional characters, but it's simpler this way.)

• Instead of directly comparing the two numbers, I take their XOR with x, which is zero if and only if they're equal, as desired.

• Instead of writing 100 directly, I generate it with *TT, since T is initialized to 10.

• Instead of writing 16 directly, I generate it with ye|LZ9. |LZ essentially functions as the range function, so |LZ9 gives [0, 1, 2, 3, 4, 5, 6, 7, 8]. e takes the final element of a list, giving 8. y doubles it, giving 16 as desired. With an extra + or an extra * I could save a character, but they're both more useful elsewhere.

More to come!

Pip, score 74 + (74 - 19) = 129

So many backticks with nary a quote to be seen, single or double!

Task 1, score 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Basically just a series of pattern (regex) literals in backticks, the last of which is printed. Since there are an odd number of backticks, we have to backslash-escape one of them (`\``). Try it online, with the -w flag added to prove that no warnings are generated.

Task 3, score 55 (length 19)

e+!!e%(1.#x.!9)=4*4

Using a rather odd input method--the fifth command-line argument--this is possible. Try it online!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Other tasks

It's possible to get input for task 2, by the same method as task 3 above. The trouble is converting to ASCII code and back to a character. The former can be done with A, but the latter requires C, or possibly indexing into the PA variable. Constructing and evaluating code can't be done without V. I don't think the task is possible.

Task 4 is challenging even without a restricted character set. At a guess, it would require lists (without using the [] delimiters or RL (repeat list) and only having one chance to use AL (append list)--not likely) or possibly something with CG (coordinate grid) or MC (map coords), both disallowed.

Task 5 is on the edge of possibility. Loops would be difficult, since For and Map aren't possible, and ranges can't be constructed with ,. There might be something to be done with Till. Increment could be of the x:x+1 variety (obviously with a variable other than x, though). Divisibility checks can use %. Still, I don't think there are enough characters--especially repeated letters--to do everything that needs to happen.

Task 6 looks completely impossible. All known Pip quines have " in them. They also use R (replace), RP (repr), or V (eval), none of which are available.

Retina, score 74

1. Run, score 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

I moved the extra parens to the config in order for them to balance in the regex. I also moved the ` right after those, and changed +. to .+.

Try it online

The others are likely impossible, since there are no newlines. There's also no - for Transliteration or d for a digits character class.

Labyrinth, score 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

I'm pretty sure any assortment of these characters produces a valid Labyrinth program, but to make it at least slightly more interesting, this prints out 2016 digit by digit. (In summary: push 2 2's on the stack, pop/print one, move the other to the aux stack, print 0, push 2 1's on the stack, pop/print 1, increment, bitwise not, negate (that last 1 is a 3 at this point), sum with the 2 from the aux stack, 5*10+4 = 54, print as ascii value, terminate)

Most of the long line is simply ignored, as the @ terminates the program.

Challenges 2, 3, and 4 are impossible since neither of Labyrinth's input commands are available (, or ?), and I didn't come up with anything for 5 or 6.

JavaScript (ES6), score = 74

1. Run, 74 bytes

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esotericism (invalid)

For the record, my suggested quine was:

1.4e+49

which turned out to be invalid, as discussed in the comments below.

MATL, total score 74

1. Run, score 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Everything up to % is actual code. % is a comment symbol, so the characters to its right are ignored.

The program outputs 1 without errors.

Try it online!

*><>, total score = 74

1. Run, score 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Try it here!

This was extremely hard to do without the ; character. I actually thought it was going to be impossible for a couple moments, until I saw the %, I had basically given up.

This is also a valid ><> program.

Explained (irrelevant parts omitted)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Challenges faced

I might try the other challenges ... they'd be extremely hard and may involve bending the rules in weird ways but liberal use of the | mirrors and the ! trampolines should make at least one more challenge possible.

These challenges are particularly hard because we're not allowed any outputs with *><> (o and n), or even function calls (C), function returns (R), or program terminators (;). Even though we're also missing i for input, we can still have input placed on the stack which is a plus. Another plus is that we get a single p instruction, which allows us to replace an instruction in the codebox. This might be able to be used multiple times (haven't figured out a practical way yet), which would start to make the other programs seem more possible (as we'd be able to generate two or more instructions).

Mathematica, score 68

`A:= .1%*.44y#+.9^`H@`$I@`L@(`$O~`Q~`Q~`Q~`T~T~Z~e~e|f|m|p|x)!!!!!&\

Notice the trailing newline. I do not believe that any of the other challenges can be achieved with Mathematica.

(abused) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

The PHP interpreter simply dumps the source code until it finds a <? since we lack < every permutation of those chars is a running quine. I guess this is not that worse than using a builtin quine command :P

Haskell, score 63

1. Run:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Not used are )))```````{. Comments in Haskell are -- or {- ... -}, so there is no easy all-comment version.

This code defines an infix operator !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~ which takes two arguments:

1. fmpxyAHILOQQQTTZ which is ignored and can therefore be of an arbitrary type
2. e, which must be a function taking two numbers

In the function body e is then applied to 14 and 49, using the `-infix notation.

Usage example:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

The operator is applied to (), the empty tuple, and (*), the multiplication operator, so 14*49 = 686 is computed.

Try it online!

Other challenges

I doubt that any of the other challenges are possible, most notably because of the lack of possible variable names that can appear twice, which is only e (or something like eQT), because variable names can't start with an uppercase letter. Of course, having only one = doesn't help either.

Octave, score 74

1. Run

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 of these characters are part of the function, while the remaining 24 are not.

What it does:

x =@(AHILOQQQTTZeefmpy) creates a function x that can take a variable AHILOQQQTTZeefmpy as input.

To understand the rest:

a||b calls the function all() on both a and b. If one or both of those return true, the || operator will return true.

!a and ~a means the same thing here, they are both not(a).

a.^b is an element-wise power (a(1)^b(1), a(2)^b(2) ...)

Continued explanation

I'll shorten each of the steps as I go along:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

And:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

There is an even number of not, so this is equivalent to not(not(4)) which is true or 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

The rest is commented out.

05AB1E - Total score: 74

1. Run, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Everything that causes an error is skipped by 05AB1E. This whole line of code is a NOP.

Try it online!

Glypho, 74 + (74 - 36) = 112

1. Run (74 bytes)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 bytes)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Explanation

Glypho seemed like a fairly good choice for this challenge, because it doesn't care about the actual characters being used. Instead, it looks at groups of four characters and chooses the command based on the pattern of repetition in those four characters. Since there are a lot of duplicates among the time capsule string, we're fairly flexible in the programs we can write, except that we're limited to programs of 18 commands (which isn't a whole lot in Glypho). While this allowed me to solve the first two problems quite easily, I doubt that Glypho can run the others with so few characters.

I've tested these using the Java interpreter retrieved from 2006-06-23 on the wayback machine, which uses a slightly different mapping of the commands:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

The Run program translates to:

1d-+[...]

Where ... is some junk that I didn't bother translating.

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

The IO program translates to:

id1-+o1+o

Here is what this does:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

Actually, score (74 + 0 + 0 + 0 + 0 + 0) = 74

Yes, the capsule string will work with Actually as it is for Run, as Actually dismisses any errors and every error becomes a NOP.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{% (Try it online!)

It will output a mess of things, though (but also its source once :3).

I'll be working on other challenges, however.

PowerShell - Total Score: 74

1. Run - Score: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Since this is extremely difficult in PowerShell (every possible method of obtaining input is impossible with the characters given, as far as I can tell), I've at least decided to randomize the first challenge so we're not all copying the example directly from the post.

So here's a random challenge 1 answer generator (for languages where # is a comment):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Try it online!

Ruby - Score: 74

1. Run

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Grabbed from the challenge.

Mathematica, score of 62

I'd be surprised if anyone can make challenges 2-6 work in Mathematica. Here's the best I did with challenge 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Defines a pretty stupid function A with a constant value. The 12 unused characters are:

)))\\`````{~