答:
><>, 41 bytes

```<code>\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?
</code>```

Try it online: N+N, N*N, N^N. Assumes that the STDIN input is exactly one char.

 ><> is a 2D language, so we can make use of the fact that code semantics are mostly unchanged if we execute instructions downwards — the extra empty lines that ensue are just no-ops. The exception to this is the conditional trampoline ? which pops a value and skips the next instruction if the value was nonzero — the extra newlines would mess up ? due to the inserted no-ops, but we can get around this by putting the ? at the end of a column and taking advantage of wrapping.

To decide which operation to execute, the key is 40., which teleports the IP to position (4, 0). Due to the expansion of the code, the x = 4 column corresponds to + for the base program, * for the doubled program and ^ for the tripled program. Unfortunately ><> doesn't have exponentiation built in, making that the bulk of the program.

```<code>[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out
</code>```

Title: Hyperprogramming: N+N, N×N, N^N all in one

Body:
Write a program that takes in a number N from 1 to 9 inclusive. In its native form your program should output N+N. E.g. output 2 if N is 1, 4 if N is 2, 6 if N is 3, and so on.

When every character in your program is duplicated in place, then it should be a program that takes in N (still from 1 to 9) and outputs N×N. E.g. output 1 if N is 1, 4 if N is 2, 9 if N is 3, and so on.

When every character in your program is triplicated in place, then it should be a program that takes in N (still from 1 to 9) and outputs N^N. E.g. output 1 if N is 1, 4 if N is 2, 27 if N is 3, 387420489 if N is 9, etc.

Numbers above 9 aren't required because 10^10 is outside of many language's usual integer range.

Example

If your initial program was

```<code>My_Program!
Exit();
</code>```

Then it should be capable of taking in N and outputting N+N.

Additionally, the program

```<code>MMyy__PPrrooggrraamm!!

EExxiitt(());;
</code>```

should take in N and output N×N.

Finally, the program

```<code>MMMyyy___PPPrrrooogggrrraaammm!!!

EEExxxiiittt((()));;;
</code>```

should take in N and output N^N.

Quadrupled-character programs and beyond are not required.

Rules

Input and output should be plain, normally formatted decimal numbers. You may answer using a different base to show off your code but then your answer is non-competitive.

Windows users may treat \r\n as one character since things like \r\r\n\n wouldn't make sense or perhaps even work.

The shortest native program (the N+N one) in bytes wins.

Body:
><>, 41 bytes

\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?

Try it online: N+N, N*N, N^N. Assumes that the STDIN input is exactly one char.

 ><> is a 2D language, so we can make use of the fact that code semantics are mostly unchanged if we execute instructions downwards — the extra empty lines that ensue are just no-ops. The exception to this is the conditional trampoline ? which pops a value and skips the next instruction if the value was nonzero — the extra newlines would mess up ? due to the inserted no-ops, but we can get around this by putting the ? at the end of a column and taking advantage of wrapping.

To decide which operation to execute, the key is 40., which teleports the IP to position (4, 0). Due to the expansion of the code, the x = 4 column corresponds to + for the base program, * for the doubled program and ^ for the tripled program. Unfortunately ><> doesn't have exponentiation built in, making that the bulk of the program.

[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out


问:
There can be only 1!
Your task is, given a positive integer n, to generate an expression that equals the number n.

The catch is: you're only allowed the number 1 in the output.

The operators at your disposal are:

+, -, * and /

/ is floating-point division (so 5/2 = 2.5).

sqrt (as s)

ceil and floor (as c and f respectively)

! (factorial)

The factorial, in this case, only works for positive integers.

You are also allowed to stack 1's together, so something like 11 is acceptable in the output. However, they count as the same number of 1's that's in the number (so 11 counts as 2 1's).

You must also include brackets in the output, so that the expression in the output, when executed through the order of operations, will result in the input.
They do not count as operations, though.

Examples:

Input = 24, one possible output = (1+1+1+1)!

Input = 11, one possible output = 11

Input = 5, one possible output = c(s((1+1+1+1)!))

The ceiling of the square root of 24 is 5.

Rules:

You are guaranteed that the input is a positive integer from 1 to 2^31-1.

Your program must work for any positive integer up to 2^31-1, even if they are not tested.

Your program must finish processing all outputs for all numbers in the set in 1 hour.

The results for every run of the program must be exactly the same - also, no seeds.

You are only allowed to hardcode the expressions for a maximum of 10 numerical values.

You are not allowed to have imaginary numbers anywhere in the output (so no s(some negative number)).

You are also not allowed to have numbers larger than 2^31-1 or smaller than -2^31+1 anywhere in the output, even when they are sqrted or /ed (so no (((1+1+1)!)!)! or ((1+1+1+1)!)!).

Set of Numbers:

```<code>945536, 16878234, 32608778, 42017515, 48950830, 51483452, 52970263, 54278649, 63636656, 78817406, 89918907, 90757642, 95364861, 102706605, 113965374, 122448605, 126594161, 148064959, 150735075, 154382918, 172057472, 192280850, 194713795, 207721209, 220946392, 225230299, 227043979, 241011012, 248906099, 249796314, 250546528, 258452706, 276862988, 277140688, 280158490, 286074562, 308946627, 310972897, 322612091, 324445400, 336060042, 346729632, 349428326, 352769482, 363039453, 363851029, 392168304, 401975104, 407890409, 407971913, 425780757, 459441559, 465592122, 475898732, 482826596, 484263150, 506235403, 548951531, 554295842, 580536366, 587051904, 588265985, 588298051, 590968352, 601194306, 607771869, 618578932, 626776380, 667919873, 681786366, 689854904, 692055400, 697665495, 711608194, 734027104, 750869335, 757710567, 759967747, 777616154, 830071127, 833809927, 835873060, 836438554, 836945593, 863728236, 864158514, 871273503, 881615667, 891619600, 897181691, 918159061, 920521050, 924502226, 929983535, 943162304, 950210939, 950214176, 962610357, 974842859, 988572832
</code>```

(These are 100 random numbers from 1 to 1 billion.)

Scoring System:

Your score is determined like so:

Your program will be tested against the random numbers in the set.

You must provide the output generated using the random numbers in the set (either inside your answer or as a pastebin link).

Your then have two "scores": A primary score and a secondary score.

Your primary score is (no. of 1's in output)*(no. of operators in output). If your primary score is the lowest, you win.

Your secondary score is the time of your upload, in GMT, and in 24-hour time. So, if you upload your program on September 12th, 00:00 GMT, then your score is 12/09/2016, 00:00 (use DD/MM/YYYY HH:MM for your formatting).

Display your score like so:

```<code>(language name)
Primary Score = (primary score)
Secondary Score = (secondary score)
(no. of 1's) `1`'s, (no. of operators) operators
</code>```

Replace all the things in the brackets with your language name, primary score and secondary score respectively.

Current Winner:

The current winner is @ChrisJefferson, who has a primary score of 3,810,660.

答:
Python

Primary Score = 2214138604871819402525

Secondary Score = 12/09/2016, 07:53

Here is the code:

def print_1s(n):
    return ("1+" * n)[:-1]
```

Just to get the ball rollin'.

Basically outputs 1+1+1...+1, where the number of 1's in the outputted expression is equal to n.

In total, there are 47054634305 1's for the set of numbers, and 47054634205 operators (which are all +'s).

Not going to post a pastebin here, because you get the idea.

ContentLicense: CC BY-SA 3.0

Title: There can be only 1!

Body:
Python

Primary Score = 2214138604871819402525

Secondary Score = 12/09/2016, 07:53

Here is the code:

def print_1s(n):
    return ("1+" * n)[:-1]

Just to get the ball rollin'.

Basically outputs 1+1+1...+1, where the number of 1's in the outputted expression is equal to n.

In total, there are 47054634305 1's for the set of numbers, and 47054634205 operators (which are all +'s).

Not going to post a pastebin here, because you get the idea.


问:
Goldenness of an integer
A positive integer n can be represented as a rectangle with integer sides a, b such that n = a * b. That is, the area represents the number. In general, a and b are not unique for a given n.

As is well known, a rectangle is specially pleasing to the eye (or is it the brain?) when its sides are in the golden ratio, φ = (sqrt(5)+1)/2 ≈ 1.6180339887...

Combining these two facts, the purpose of this challenge is to decompose an integer n into the product of two integers a, b whose ratio is as close as possible to φ (with the usual metric on ℝ). The fact that φ is irrational implies that there is a unique solution pair (a, b).

The challenge

Given a positive integer n, output positive integers a, b such that  a * b = n and the absolute difference between a/b and φ is minimized.

As an example, consider n = 12. The pairs (a, b) that satisfy a * b = n are: (1, 12), (2,6), (3,4), (4,3), (6,2), (12,1). The pair whose ratio is closest to φ is (4,3), which gives 4/3 = 1.333.

Rules

Functions or programs are acceptable.

The numerator (a) should appear first in the output, and the denominator (b) second. Other than that, input and output formats are flexible as usual. For example, the two numbers can be output as strings with any reasonable separator, or as an array.

The code should work in theory for arbitrarily large numbers. In practice, it may be limited by memory or data-type restrictions.

It's sufficient to consider an approximate version of φ, as long as it is accurate up to the third decimal or better. That is, the absolute difference between the true φ and the approximate value should not exceed 0.0005. For example, 1.618 is acceptable.

When using an approximate, rational version of φ there's a small chance that the solution is not unique. In that case you can output any pair a, b that satisfies the minimization criterion.

Shortest code wins.

Test cases

```<code>1        ->  1    1
2        ->  2    1
4        ->  2    2
12       ->  4    3
42       ->  7    6
576      ->  32   18
1234     ->  2    617
10000    ->  125  80
199999   ->  1    199999
9699690  ->  3990 2431
</code>```

答:
Haskell (Lambdabot), 86 bytes

```<code>f(x,y)=abs$(x/y)-1.618
q n=minimumBy((.f).compare.f)[(x,y)|x<-[1..n],y<-[1..n],x*y==n]
</code>```

Title: Goldenness of an integer

Body:
Haskell (Lambdabot), 86 bytes

f(x,y)=abs$(x/y)-1.618
q n=minimumBy((.f).compare.f)[(x,y)|x<-[1..n],y<-[1..n],x*y==n]


答:
Emacs Lisp

Primary score: 81638725

Secondary score: 12/09/2016 09:35

```<code>(defun 1s (n)
  (let((x 1)r)
    (while (> (/ n x) 11)
      (setq x (1+ (* x 10))))
    (while (> n 0)
      (while (>= n x)
        (push x r)
        (push '+ r)
        (setq n (- n x)))
      (setq x (/ x 10)))
    r))
</code>```

Basically builds a sum over the domain (1, 11, 111, ...) which is equivalent to n.

Title: There can be only 1!

Body:
Your task is, given a positive integer n, to generate an expression that equals the number n.

The catch is: you're only allowed the number 1 in the output.

The operators at your disposal are:

+, -, * and /

/ is floating-point division (so 5/2 = 2.5).

sqrt (as s)

ceil and floor (as c and f respectively)

! (factorial)

The factorial, in this case, only works for positive integers.

You are also allowed to stack 1's together, so something like 11 is acceptable in the output. However, they count as the same number of 1's that's in the number (so 11 counts as 2 1's).

You must also include brackets in the output, so that the expression in the output, when executed through the order of operations, will result in the input.
They do not count as operations, though.

Examples:

Input = 24, one possible output = (1+1+1+1)!

Input = 11, one possible output = 11

Input = 5, one possible output = c(s((1+1+1+1)!))

The ceiling of the square root of 24 is 5.

Rules:

You are guaranteed that the input is a positive integer from 1 to 2^31-1.

Your program must work for any positive integer up to 2^31-1, even if they are not tested.

Your program must finish processing all outputs for all numbers in the set in 1 hour.

The results for every run of the program must be exactly the same - also, no seeds.

You are only allowed to hardcode the expressions for a maximum of 10 numerical values.

You are not allowed to have imaginary numbers anywhere in the output (so no s(some negative number)).

You are also not allowed to have numbers larger than 2^31-1 or smaller than -2^31+1 anywhere in the output, even when they are sqrted or /ed (so no (((1+1+1)!)!)! or ((1+1+1+1)!)!).

Set of Numbers:

```<code>945536, 16878234, 32608778, 42017515, 48950830, 51483452, 52970263, 54278649, 63636656, 78817406, 89918907, 90757642, 95364861, 102706605, 113965374, 122448605, 126594161, 148064959, 150735075, 154382918, 172057472, 192280850, 194713795, 207721209, 220946392, 225230299, 227043979, 241011012, 248906099, 249796314, 250546528, 258452706, 276862988, 277140688, 280158490, 286074562, 308946627, 310972897, 322612091, 324445400, 336060042, 346729632, 349428326, 352769482, 363039453, 363851029, 392168304, 401975104, 407890409, 407971913, 425780757, 459441559, 465592122, 475898732, 482826596, 484263150, 506235403, 548951531, 554295842, 580536366, 587051904, 588265985, 588298051, 590968352, 601194306, 607771869, 618578932, 626776380, 667919873, 681786366, 689854904, 692055400, 697665495, 711608194, 734027104, 750869335, 757710567, 759967747, 777616154, 830071127, 833809927, 835873060, 836438554, 836945593, 863728236, 864158514, 871273503, 881615667, 891619600, 897181691, 918159061, 920521050, 924502226, 929983535, 943162304, 950210939, 950214176, 962610357, 974842859, 988572832
</code>```

(These are 100 random numbers from 1 to 1 billion.)

Scoring System:

Your score is determined like so:

Your program will be tested against the random numbers in the set.

You must provide the output generated using the random numbers in the set (either inside your answer or as a pastebin link).

Your then have two "scores": A primary score and a secondary score.

Your primary score is (no. of 1's in output)*(no. of operators in output). If your primary score is the lowest, you win.

Your secondary score is the time of your upload, in GMT, and in 24-hour time. So, if you upload your program on September 12th, 00:00 GMT, then your score is 12/09/2016, 00:00 (use DD/MM/YYYY HH:MM for your formatting).

Display your score like so:

```<code>(language name)
Primary Score = (primary score)
Secondary Score = (secondary score)
(no. of 1's) `1`'s, (no. of operators) operators
</code>```

Replace all the things in the brackets with your language name, primary score and secondary score respectively.

Current Winner:

The current winner is @ChrisJefferson, who has a primary score of 3,810,660.

Body:
Emacs Lisp

Primary score: 81638725

Secondary score: 12/09/2016 09:35

(defun 1s (n)
  (let((x 1)r)
    (while (> (/ n x) 11)
      (setq x (1+ (* x 10))))
    (while (> n 0)
      (while (>= n x)
        (push x r)
        (push '+ r)
        (setq n (- n x)))
      (setq x (/ x 10)))
    r))

Basically builds a sum over the domain (1, 11, 111, ...) which is equivalent to n.


Title: There can be only 1!

Body:
Haskell

Primary score: 27242281

Secondary score: 12/09/2016 09:01

11891 1's, 2291 operators

import Data.List

nums = iterate (\x -> x*10+1) 1

g n | n > a = show a ++ "+(" ++ g (n-a) ++ ")"
    | n < a = show a ++ "-(" ++ g (a-n) ++ ")"
    | otherwise = show a
 where a = minimumBy (\x y -> compare (abs$x-n) (abs$y-n))
         . take 2 . reverse
         $ takeWhile (<=n*10) nums

It basically finds the shortest way to make it using only + and -

Output:

945536: 1111111-(111111+(11111+(11111+(11111+(11111+(11111-(1111-(11+(11-(1+(1)))))))))))
16878234: 11111111+(1111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111-(11111-(111+(111+(111+(111+(11+(1+(1)))))))))))))))
32608778: 11111111+(11111111+(11111111-(1111111-(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111+(111-(1)))))))))))))))
42017515: 11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(111111+(111111-(11111+(11111-(1111+(1111+(1111+(1111+(111+(111+(11+(11+(11+(11-(1+(1+(1))))))))))))))))))))))
48950830: 11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(111+(111+(11+(11+(11+(11+(11+(1+(1+(1+(1)))))))))))))))))))))))))))
51483452: 11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(1111+(111+(11-(1+(1)))))))))))))))))))))))
52970263: 11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(111111+(111111+(111111+(11111+(11111+(11111-(1111+(1111+(1111+(111+(111+(11+(11+(11+(11-(1+(1+(1))))))))))))))))))))))))
54278649: 11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111-(111+(111+(11+(11-(1+(1+(1+(1))))))))))))))))))))
63636656: 111111111-(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(111111+(111111-(11111+(11111+(11111-(1111+(1111+(1111-(11)))))))))))))))))
78817406: 111111111-(11111111+(11111111+(11111111-(1111111-(111111-(11111+(11111+(11111+(11111-(1111+(1111+(1111+(1111+(111+(111+(111+(11+(11+(11+(11-(1+(1+(1+(1+(1)))))))))))))))))))))))))
89918907: 111111111-(11111111+(11111111-(1111111-(111111-(11111+(11111+(11111-(1111+(1111+(1111-(11+(11-(1+(1+(1+(1))))))))))))))))
90757642: 111111111-(11111111+(11111111-(1111111+(1111111-(111111+(111111+(111111+(11111+(11111-(1111+(1111-(111+(11+(11+(1+(1+(1)))))))))))))))))
95364861: 111111111-(11111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111-(11111+(11111+(11111-(1111+(1111-(111+(111+(111+(111-(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))))))
102706605: 111111111-(11111111-(1111111+(1111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111-(1111+(1111+(1111+(1111+(111-(11+(11+(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))))))))
113965374: 111111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(111111+(11111+(11111+(11111+(1111+(111+(111-(11+(11+(11+(11-(1+(1+(1+(1)))))))))))))))))))))
122448605: 111111111+(11111111+(111111+(111111+(1111+(1111+(1111+(1111-(111+(111+(111-(11+(11+(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))
126594161: 111111111+(11111111+(1111111+(1111111+(1111111+(1111111-(111111-(11111+(11111+(11111+(1111+(1111+(1111+(1111+(1111-(111+(111+(11+(11+(11+(11+(11+(1+(1+(1+(1+(1))))))))))))))))))))))))))
148064959: 111111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111+(1111+(111+(111+(111+(111+(111+(11+(11+(11+(11-(1+(1+(1))))))))))))))))))))))))))
150735075: 111111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111-(1111+(1111-(111+(111+(111+(111+(11+(11+(11+(1+(1+(1+(1))))))))))))))))))))))))))))
154382918: 111111111+(11111111+(11111111+(11111111+(11111111-(1111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(1111-(111+(111+(111+(111-(11+(11+(11-(1+(1+(1)))))))))))))))))))))))))
172057472: 111111111+(11111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111-(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111-(111+(111+(111-(11+(11+(11-(1+(1+(1+(1+(1)))))))))))))))))))))))))))))
192280850: 111111111+(111111111-(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(11111+(11111+(11111+(11111+(11111+(1111+(1111+(1111-(111+(111+(11+(11+(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))
194713795: 111111111+(111111111-(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111+(11111+(11111+(11111+(11111+(1111+(1111+(111+(111+(111+(111+(11+(11-(1+(1+(1+(1))))))))))))))))))))))))))
207721209: 111111111+(111111111-(11111111+(1111111+(1111111+(1111111+(11111+(11111+(11111+(11111+(11111+(1111-(111-(11+(1+(1+(1))))))))))))))))
220946392: 111111111+(111111111-(1111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111-(111+(111+(11+(11+(11+(11+(11-(1+(1)))))))))))))))))))
225230299: 111111111+(111111111+(1111111+(1111111+(1111111-(111111+(111111+(111111-(11111-(1111+(1111+(1111-(111+(111+(111-(11+(11+(11+(1))))))))))))))))))
227043979: 111111111+(111111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111-(111+(111+(111+(111+(11+(11-(1+(1))))))))))))))))))))
241011012: 111111111+(111111111+(11111111+(11111111-(1111111+(1111111+(1111111+(111111-(11111-(111-(11+(1)))))))))))
248906099: 111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(11111+(1111+(1111+(1111+(1111+(1111+(111+(111+(111+(111+(111-(11-(1))))))))))))))))))))
249796314: 111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111-(11111+(11111-(1111+(1111+(1111+(111+(111+(111+(11+(11-(1+(1+(1)))))))))))))))))))))))
250546528: 111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111-(11111-(1111+(1111-(111+(11+(11+(1+(1+(1+(1)))))))))))))))))))))))
258452706: 111111111+(111111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(111111-(11111-(1111+(1111+(1111-(111+(111+(111+(111+(11+(11+(11+(11-(1+(1+(1+(1)))))))))))))))))))))))))))
276862988: 111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111-(111111+(111111-(11111+(11111+(1111+(1111+(1111+(111+(111+(111+(11+(1)))))))))))))))))))
277140688: 111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111-(111111+(111111+(111111+(111111+(11111+(11111+(11111-(1111+(1111+(1111+(111+(111+(111+(111-(11+(11)))))))))))))))))))))))
280158490: 111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(111111+(11111+(11111+(11111+(11111+(1111+(1111+(1111-(111+(111+(111+(111-(11+(11+(11+(11+(1+(1+(1)))))))))))))))))))))))))))
286074562: 111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(1111+(1111+(1111-(111+(1+(1+(1+(1+(1)))))))))))))))))))))))))
308946627: 111111111+(111111111+(111111111-(11111111+(11111111+(1111111+(1111111-(11111+(11111+(11111+(11111+(11111+(1111+(1111-(11+(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))))
310972897: 111111111+(111111111+(111111111-(11111111+(11111111+(111111+(11111+(11111+(1111+(1111+(1111+(1111+(111+(111+(111+(111-(11-(1+(1+(1+(1))))))))))))))))))))
322612091: 111111111+(111111111+(111111111-(11111111-(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111+(1111-(111+(11+(11-(1+(1+(1))))))))))))))))))
324445400: 111111111+(111111111+(111111111-(11111111-(1111111+(1111111+(1111-(111+(11+(11+(11+(11)))))))))))
336060042: 111111111+(111111111+(111111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(11+(11+(11+(11)))))))))))))))))))))
346729632: 111111111+(111111111+(111111111+(11111111+(1111111+(1111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111+(111+(111+(111+(11+(11+(11+(1+(1)))))))))))))))))))))
349428326: 111111111+(111111111+(111111111+(11111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111-(11111+(1111+(1111+(1111+(1111+(111+(111+(111+(111+(111+(11-(1+(1+(1+(1)))))))))))))))))))))))))))
352769482: 111111111+(111111111+(111111111+(11111111+(11111111-(1111111+(1111111+(111111+(111111+(111111+(111111+(111111+(11111-(1111+(1111+(111+(111+(111+(111+(111+(11+(11+(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))))
363039453: 111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111-(1111+(1111+(1111+(1111+(111+(111+(111+(111+(111-(11-(1+(1+(1))))))))))))))))))))))))))))
363851029: 111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(1111111+(1111111+(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(111-(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))))))))))
392168304: 111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(11111+(11111+(11111+(11111+(11111-(1111+(111+(111+(111+(111+(111-(11+(11+(11-(1+(1+(1+(1+(1)))))))))))))))))))))))))))))
401975104: 111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(11111111-(1111111+(1111111-(111111+(111111+(11111+(11111+(1111+(1111+(111+(111+(111+(111+(11-(1+(1+(1)))))))))))))))))))))))
407890409: 111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(1111+(111+(111+(111+(111-(11+(11+(11+(1+(1))))))))))))))))))))
407971913: 111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(111111-(11111+(11111+(1111+(1111+(1111+(1111+(1111+(111+(111+(111-(11+(11+(1))))))))))))))))))))))))
425780757: 111111111+(111111111+(111111111+(111111111-(11111111+(11111111-(1111111+(1111111+(1111111+(111111+(111111+(1111+(1111+(1111-(111+(111+(111+(11+(11-(1+(1))))))))))))))))))))
459441559: 111111111+(111111111+(111111111+(111111111+(11111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111-(1111+(1111+(1111-(111+(111+(111+(111+(1+(1+(1+(1+(1))))))))))))))))))))))))
465592122: 111111111+(111111111+(111111111+(111111111+(11111111+(11111111-(1111111-(11111+(11111+(11111+(1111+(1111+(1111-(111-(11+(1)))))))))))))))
475898732: 111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(1111111+(1111111-(111111+(111111+(111111+(11111-(1111+(111+(11+(11+(11+(11+(1)))))))))))))))))))
482826596: 111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111-(111-(11+(11+(11+(11-(1)))))))))))))))))))))))))))))
484263150: 111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111+(111111+(111111-(11111+(11111+(11111+(11111-(1111+(1111+(1111+(111+(111-(11+(11+(11+(11-(1+(1+(1+(1+(1)))))))))))))))))))))))))))))))
506235403: 111111111+(111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111-(11111+(1111+(1111-(111+(11+(11+(11+(11-(1+(1))))))))))))))))))))))))))
548951531: 111111111+(111111111+(111111111+(111111111+(111111111-(11111111-(1111111+(1111111+(1111111+(1111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111-(111+(111+(111+(111-(11+(11+(1+(1))))))))))))))))))))))))))
554295842: 111111111+(111111111+(111111111+(111111111+(111111111-(1111111+(111111+(11111+(11111+(11111+(1111+(1111+(1111+(1111-(111+(111+(111-(11+(11+(11+(11+(1+(1+(1)))))))))))))))))))))))
580536366: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(111111-(11111+(11111-(1111+(1111+(1111-(111+(111+(111-(11+(11+(11+(1)))))))))))))))))))))))))
587051904: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(1111111+(1111111-(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111+(1111+(111+(111+(111-(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))))))
588265985: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(1111111-(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111-(1111-(111+(111+(111+(111-(11+(1+(1))))))))))))))))))))))))
588298051: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111-(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(1111+(1111-(111+(111+(11+(11+(11+(11+(11-(1+(1+(1+(1))))))))))))))))))))))))))))
590968352: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(1111111+(1111111-(111111+(11111+(11111+(11111-(1111+(111+(111+(111+(111+(111+(11+(11-(1+(1)))))))))))))))))))))))
601194306: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(1111111+(111111-(11111+(11111+(1111+(1111+(1111+(1111+(1111+(111+(11+(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))
607771869: 111111111+(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111+(1111+(1111+(1111+(1111+(111+(111+(111+(11+(11-(1+(1))))))))))))))))))))))))
618578932: 1111111111-(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(111111+(111111+(111111-(11111+(11111+(1111+(11+(11+(11+(11-(1+(1)))))))))))))))))))))))
626776380: 1111111111-(111111111+(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111+(111111-(1111+(111+(111+(111-(11+(11+(11+(11+(1+(1)))))))))))))))))))))))
667919873: 1111111111-(111111111+(111111111+(111111111+(111111111-(1111111+(111111+(11111+(11111+(11111-(1111+(1111+(111+(11+(1+(1+(1+(1+(1))))))))))))))))))
681786366: 1111111111-(111111111+(111111111+(111111111+(111111111-(11111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(111111-(11111-(1111+(1111+(111+(111+(111-(11+(11+(11-(1)))))))))))))))))))))))
689854904: 1111111111-(111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(1111111-(111111+(11111+(11111+(11111+(1111-(111+(111+(111+(111+(11+(1+(1+(1+(1)))))))))))))))))))))
692055400: 1111111111-(111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(11111+(11111+(11111+(11111+(11111+(111+(11+(11+(11+(11+(1)))))))))))))))))))))
697665495: 1111111111-(111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111-(1111111+(1111111+(111111+(1111+(111-(11+(11+(11+(11+(11-(1+(1+(1+(1+(1))))))))))))))))))))))
711608194: 1111111111-(111111111+(111111111+(111111111+(111111111-(11111111+(11111111+(11111111+(11111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111+(1111-(111+(111+(111+(111-(11+(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))))))))
734027104: 1111111111-(111111111+(111111111+(111111111+(11111111+(11111111+(11111111+(11111111-(1111111-(111111+(111111+(111111+(111111-(11111+(11111+(1111+(1111+(1111+(1111+(111+(111+(111+(111-(11-(1+(1+(1+(1)))))))))))))))))))))))))))
750869335: 1111111111-(111111111+(111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(111111+(111111+(11111+(11111-(1111+(1111+(111+(111+(111+(111+(1))))))))))))))))))))
757710567: 1111111111-(111111111+(111111111+(111111111+(11111111+(11111111-(1111111+(1111111-(111111-(11111+(11111+(11111+(11111-(111+(111+(111+(111+(111-(11))))))))))))))))))
759967747: 1111111111-(111111111+(111111111+(111111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111-(11111+(11111+(11111-(1111-(11+(11+(11-(1+(1))))))))))))))))))
777616154: 1111111111-(111111111+(111111111+(111111111+(111111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(1111+(111+(111+(111+(111+(111-(11+(11+(11+(11-(1+(1+(1)))))))))))))))))))))))))
830071127: 1111111111-(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111-(11111+(11111+(11111+(11111-(1111+(1111+(1111+(1111+(11+(1+(1+(1+(1))))))))))))))))))))))))
833809927: 1111111111-(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(111111+(111111+(111111+(111111+(11111+(11111+(11111-(1111+(111-(11+(11+(11+(1+(1+(1+(1+(1))))))))))))))))))))))))
835873060: 1111111111-(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(111111+(111111+(111111-(11111+(1111+(1111+(1111+(1111+(111+(111+(11+(11+(11+(11+(11-(1+(1+(1)))))))))))))))))))))))))))
836438554: 1111111111-(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111-(111111+(111111+(1111+(1111+(1111+(1111+(1111+(111+(111+(111+(1+(1+(1)))))))))))))))))))))))
836945593: 1111111111-(111111111+(111111111+(11111111+(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111+(1111+(11+(11+(11+(1+(1+(1+(1+(1))))))))))))))))))))))))))
863728236: 1111111111-(111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(1111-(111+(111+(111+(111+(11+(1+(1)))))))))))))))))))))))))))
864158514: 1111111111-(111111111+(111111111+(11111111+(11111111+(1111111+(1111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(1111-(111+(111+(111+(11+(11+(11+(11-(1+(1)))))))))))))))))))))))))
871273503: 1111111111-(111111111+(111111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111+(1111+(1111+(1111-(111+(11+(11+(11+(11+(11+(1+(1+(1+(1))))))))))))))))))))))))))))
881615667: 1111111111-(111111111+(111111111+(11111111-(1111111+(1111111+(1111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111+(111+(1+(1))))))))))))))))))))))
891619600: 1111111111-(111111111+(111111111-(1111111+(1111111+(111111+(111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111+(1111+(1111+(111+(111+(111+(111-(11+(11+(11+(11)))))))))))))))))))))))
897181691: 1111111111-(111111111+(111111111-(11111111-(1111111+(1111111+(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(11111-(1111+(1111+(1111+(111+(111+(111+(111+(111+(11+(11+(1+(1))))))))))))))))))))))))))
918159061: 1111111111-(111111111+(111111111-(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(111+(111-(11+(11+(11+(11+(1+(1+(1+(1+(1))))))))))))))))))))))))))))))
920521050: 1111111111-(111111111+(111111111-(11111111+(11111111+(11111111-(1111111+(111111+(111111+(111111+(111111+(111111+(11111+(11111+(11111+(1111+(111-(11+(11+(11+(11+(1+(1+(1+(1+(1)))))))))))))))))))))))))
924502226: 1111111111-(111111111+(111111111-(11111111+(11111111+(11111111+(1111111+(1111111+(11111+(11111+(11111+(11111+(11111+(1111+(1111+(1+(1+(1+(1+(1)))))))))))))))))))
929983535: 1111111111-(111111111+(111111111-(11111111+(11111111+(11111111+(11111111-(1111111+(1111111+(1111111+(11111+(1111+(1111+(1111+(1111+(1111-(111+(111-(11+(11-(1))))))))))))))))))))
943162304: 1111111111-(111111111+(11111111+(11111111+(11111111+(11111111+(11111111+(1111111+(111111+(11111+(11111+(11111+(11111+(11111+(1111+(1111+(1111+(1111-(111-(11+(11+(11-(1+(1)))))))))))))))))))))))
950210939: 1111111111-(111111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111-(11111+(111+(111-(11+(11+(11+(11+(1+(1+(1+(1+(1))))))))))))))))))))))))
950214176: 1111111111-(111111111+(11111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111-(11111-(1111+(1111+(1111-(111+(111+(11+(11+(11+(11+(1+(1+(1)))))))))))))))))))))))))
962610357: 1111111111-(111111111+(11111111+(11111111+(11111111+(1111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(11111+(11111+(11111+(11111+(11111-(1111-(111+(111+(111+(11+(11+(1+(1))))))))))))))))))))))))
974842859: 1111111111-(111111111+(11111111+(11111111+(1111111+(1111111+(1111111-(111111+(111111+(111111+(111111-(11111+(11111+(11111+(11111+(1111+(111+(111+(111+(111+(11+(11+(11-(1+(1))))))))))))))))))))))))
988572832: 1111111111-(111111111+(11111111+(111111+(111111+(111111-(11111+(11111-(1111+(1111+(1111+(1111+(111+(111+(111+(111+(11+(11+(11+(11+(11+(1+(1+(1)))))))))))))))))))))))


Title: There can be only 1!

Body:
Python, score 17136288

secondary score: 12/09/2016 08:53

(4784 ones and 3582 operations)

Work in progress but OP asked for my current code...

# get number in factorial base, ignoring the place of 0! (always 0)
r=lambda n,q=[],i=2:n and r(n//i,q+[n%i],i+1)or q

# rewrite a number in a form using only 1s by converting its factorial base, the range only requires using up to 12 places, again ignoring the 0! place so we only hard code 1 and [5-12] (9 numbers)
def g(n):
    k=['','1']+['1'+'+1'*i for i in range(1,4)]+['(11-1)/(1+1)','t(1+1+1)','1+t(1+1+1)','11-1-1-1','11-1-1','11-1','11','1+11']
    q=r(n)
    return n<13and k[n]or(q[0]and'1+'or'')+'+'.join((v>1and'('+k[v]+')*'or'')+(i>2and't'or'')+'('+k[i]+')'for i,v in enumerate(q[1:],2)if v)

#get g(n) representations after differencing from 0, 11, 111, 1111, ... then return the one with the minimal stand-alone score
def h(n):
    o=[g(n)]+[str(v)+(v<n and'+('or'-(')+g(abs(v-n))+')'for v in[int('1'*l)for l in range(2,11)]]
    s=[sum(map(v.count,'+-*/t'))*v.count('1')for v in o]
    return o[s.index(min(s))]

# A Factorial function for analysis with eval
def t(n):
    r = 1
    while n:
        r *= n
        n -= 1
    return r

Output - note that t is the factorial function, so as not to be confused with f for floor if it gets used - I evaluated each using the function t (above) to double check that they are all correct:

945536 11111111-(1+(1+1)+(1+1)*t(1+1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(11-1-1-1)*t(11-1-1)+(1+1)*t(11-1))
16878234 11111111+(1+(1+1+1)*t(1+1+1)+t(1+1+1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+t(t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+t(11-1))
32608778 111111111-(1+(1+1)*t(1+1+1)+(t(1+1+1))*t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+(t(1+1+1))*t(11-1-1)+(11-1)*t(11-1)+t(11))
42017515 111+((1+1)*(1+1)+(1+1+1)*t((11-1)/(1+1))+((11-1)/(1+1))*t(t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+t(11))
48950830 111+(1+t(1+1+1)+(1+1+1)*t(1+1+1+1)+(1+1+1)*t(t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(1+1)*t(11-1)+t(11))
51483452 11111111+(1+(1+1)+(1+1+1)*t(1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+t(11-1-1)+t(11))
52970263 111111111-((1+1)+t(1+1+1)+t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+t(11-1-1-1)+((11-1)/(1+1))*t(11-1)+t(11))
54278649 1+(1+1)+t(1+1+1)+(1+1+1+1)*t(t(1+1+1))+t(1+t(1+1+1))+((11-1)/(1+1))*t(11-1-1-1)+(11-1-1)*t(11-1-1)+(1+1+1)*t(11-1)+t(11)
63636656 1111111+(1+t(1+1+1+1)+(t(1+1+1))*t(t(1+1+1))+((11-1)/(1+1))*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+(1+1)*t(11-1-1)+(t(1+1+1))*t(11-1)+t(11))
78817406 1111+(1+t(1+1+1)+(1+1)*t(1+1+1+1)+t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(11-1)*t(11-1)+t(11))
89918907 1+(1+1)+t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(1+1)*t(11-1)+(1+1)*t(11)
90757642 1111111+(1+(1+1)+(1+1)*t(1+1+1+1)+(1+1+1)*t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1)+(1+1)*t(11-1)+(1+1)*t(11))
95364861 11111111+((1+1)*(1+1)+(1+1+1)*t(1+1+1)+(1+1)*t(1+1+1+1)+((11-1)/(1+1))*t(1+t(1+1+1))+t(11-1-1-1)+(1+1)*t(11-1-1)+t(11-1)+(1+1)*t(11))
102706605 1111+((1+1)+(1+1)*t(1+1+1)+(1+1+1)*t((11-1)/(1+1))+(1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1)+(t(1+1+1))*t(11-1)+(1+1)*t(11))
113965374 t(1+1+1)+(1+1)*t(1+1+1+1)+t((11-1)/(1+1))+t(t(1+1+1))+(1+1+1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1)+(11-1-1)*t(11-1)+(1+1)*t(11)
122448605 111111+((1+1)+(1+1)*t(1+1+1)+t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+t(1+t(1+1+1))+t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(1+1+1)*t(11))
126594161 111111111+((1+1)+(1+1)*t(1+1+1+1)+t((11-1)/(1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+(1+1+1+1)*t(11-1))
148064959 1111111111-((1+1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+(1+1+1)*t(11-1-1)+t(11-1)+(1+1)*t(1+11))
150735075 11111111+((1+1)*(1+1)+t((11-1)/(1+1))+t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(1+1+1)*t(11))
154382918 1111111+(1+t(1+1+1)+(1+1+1)*t((11-1)/(1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1)*t(11-1)+(1+1+1)*t(11))
172057472 1111+(1+t((11-1)/(1+1))+t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(1+1+1)*t(11-1)+(1+1+1+1)*t(11))
192280850 1111111111-(1+(1+1)*(1+1)+(1+1+1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1)+(11)*t(11)+t(1+11))
194713795 111111111+((1+1)*(1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+((11-1)/(1+1))*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1-1)+t(11-1)+(1+1)*t(11))
207721209 111111+((1+1+1)*t(1+1+1)+(1+1)*t((11-1)/(1+1))+(1+1+1)*t(t(1+1+1))+t(11-1-1-1)+(1+1)*t(11-1-1)+(1+1)*t(11-1)+((11-1)/(1+1))*t(11))
220946392 111111111+(1+((11-1)/(1+1))*t(t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1-1)*t(11-1)+(1+1)*t(11))
225230299 1111111111-((1+1)*t(1+1+1)+(1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+t(11-1-1)+(1+1)*t(11-1)+(11-1)*t(11)+t(1+11))
227043979 1111111111-((1+1)*t(1+1+1)+t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+(t(1+1+1))*t(11-1-1)+t(11-1)+(11-1)*t(11)+t(1+11))
241011012 11+(1+(1+1+1)*t((11-1)/(1+1))+(1+1+1+1)*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(t(1+1+1))*t(11))
248906099 11+((1+1)*t(1+1+1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+(1+1)*t(1+t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+(1+1)*t(11-1)+(t(1+1+1))*t(11))
249796314 111111+(1+(1+1)+((11-1)/(1+1))*t(t(1+1+1))+(1+1+1+1)*t(1+t(1+1+1))+(11-1-1-1)*t(11-1-1)+(1+1)*t(11-1)+(t(1+1+1))*t(11))
250546528 111+(1+(1+1+1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(1+1+1)*t(11-1-1-1)+(1+1+1)*t(11-1)+(t(1+1+1))*t(11))
258452706 11+(1+t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1)*t(t(1+1+1))+(1+1)*t(11-1-1-1)+(1+1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(t(1+1+1))*t(11))
276862988 111+(1+(1+1)*(1+1)+(1+1+1)*t(1+1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+((11-1)/(1+1))*t(1+t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1)*t(11-1)+(t(1+1+1))*t(11))
277140688 1111+(1+(1+1)+t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1+1+1)*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1+1)*t(11-1-1)+(11-1)*t(11-1)+(t(1+1+1))*t(11))
280158490 (1+1)*(1+1)+t(1+1+1)+(1+1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1)+(1+t(1+1+1))*t(11)
286074562 1111+(1+(1+1)+(1+1)*t(1+1+1+1)+t((11-1)/(1+1))+(1+1+1+1)*t(t(1+1+1))+(1+1+1)*t(11-1-1-1)+(11-1-1-1)*t(11-1-1)+t(11-1)+(1+t(1+1+1))*t(11))
308946627 11111+((1+1)*(1+1)+(1+1+1)*t(1+1+1+1)+((11-1)/(1+1))*t(t(1+1+1))+(1+1+1)*t(11-1-1-1)+t(11-1-1)+(11-1-1-1)*t(11-1)+(1+t(1+1+1))*t(11))
310972897 111111111+((1+1)*(1+1)+t(1+1+1)+(1+1+1+1)*t(1+1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+((11-1)/(1+1))*t(11))
322612091 11+((1+1)*t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+(11-1-1)*t(11-1-1)+(11-1-1-1)*t(11))
324445400 1111+(1+(1+1)*t(1+1+1+1)+(t(1+1+1))*t(t(1+1+1))+((11-1)/(1+1))*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1)+t(11-1)+(11-1-1-1)*t(11))
336060042 11+(1+t(1+1+1)+t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1)+(1+1+1+1)*t(11-1)+(11-1-1-1)*t(11))
346729632 11111+(1+(1+1+1)*t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+(1+t(1+1+1))*t(11-1)+(11-1-1-1)*t(11))
349428326 11+(1+(1+1)+(1+1+1)*t(1+1+1+1)+(1+1+1)*t(1+t(1+1+1))+(11-1-1-1)*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1-1)*t(11-1)+(11-1-1-1)*t(11))
352769482 1111+(1+(1+1)+(1+1)*t(1+1+1+1)+((11-1)/(1+1))*t(t(1+1+1))+t(1+t(1+1+1))+t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1)*t(11-1)+(11-1-1-1)*t(11))
363039453 111111+(t(1+1+1)+(1+1+1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+t(1+t(1+1+1))+t(11-1-1-1)+t(11-1)+(11-1-1)*t(11))
363851029 1111+(t(1+1+1)+(1+1+1)*t(1+1+1+1)+(1+1+1)*t(t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+t(11-1)+(11-1-1)*t(11))
392168304 11111111+(1+(1+1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1)+(11-1-1)*t(11))
401975104 1111111+(1+(1+1)+t(1+1+1)+t(1+1+1+1)+(1+1+1)*t((11-1)/(1+1))+(1+1+1)*t(t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(11-1)*t(11))
407890409 11111+((1+1+1)*t(1+1+1)+(1+1+1)*t(t(1+1+1))+(1+1+1+1)*t(11-1-1)+(1+1)*t(11-1)+(11-1)*t(11))
407971913 11111+((1+1+1)*t(1+1+1)+t(1+1+1+1)+t((11-1)/(1+1))+(1+1+1+1)*t(t(1+1+1))+(1+1)*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(1+1)*t(11-1)+(11-1)*t(11))
425780757 111+(t(1+1+1)+(1+1)*t(t(1+1+1))+(1+1+1)*t(11-1-1-1)+(1+1+1)*t(11-1-1)+(1+t(1+1+1))*t(11-1)+(11-1)*t(11))
459441559 1111111+((1+1)*t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(11)*t(11))
465592122 1111+(1+(1+1)*(1+1)+t(1+1+1)+t((11-1)/(1+1))+t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1)+(1+t(1+1+1))*t(11-1)+(11)*t(11))
475898732 11111+(1+(1+1)+(1+1+1)*t(1+1+1)+t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(1+1+1)*t(11-1-1-1)+t(11-1-1)+(11-1)*t(11-1)+(11)*t(11))
482826596 111111+(1+(1+1)*(1+1)+t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(1+1)*t(11-1-1-1)+t(11-1)+t(1+11))
484263150 t(1+1+1)+t(1+1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+t(11-1)+t(1+11)
506235403 1111+((1+1)*t(1+1+1)+t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+((11-1)/(1+1))*t(11-1-1)+(1+t(1+1+1))*t(11-1)+t(1+11))
548951531 11+((1+1+1+1)*t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1-1)*t(11-1)+t(11)+t(1+11))
554295842 (1+1)+(1+1)*t((11-1)/(1+1))+(1+1)*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(11-1-1)*t(11-1)+t(11)+t(1+11)
580536366 1111111111-(1+t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+((11-1)/(1+1))*t(t(1+1+1))+t(11-1-1-1)+(1+1)*t(11-1-1)+(1+1+1)*t(11-1)+t(11)+t(1+11))
587051904 1111111111-(1+t(1+1+1)+(1+1+1+1)*t(1+t(1+1+1))+t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+t(11-1)+t(11)+t(1+11))
588265985 11+(t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1+1)*t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+t(11-1-1)+(11-1-1-1)*t(11-1)+(1+1)*t(11)+t(1+11))
588298051 11111111+((1+1)+(1+1+1)*t(1+1+1)+(1+1+1)*t((11-1)/(1+1))+t(t(1+1+1))+t(1+t(1+1+1))+((11-1)/(1+1))*t(11-1-1-1)+((11-1)/(1+1))*t(11-1)+(1+1)*t(11)+t(1+11))
590968352 1111111+(1+t((11-1)/(1+1))+t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+(11-1-1-1)*t(11-1)+(1+1)*t(11)+t(1+11))
601194306 1111111+(1+(1+1)*(1+1)+t(1+1+1)+t(1+1+1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1+1)*t(11-1-1)+(1+1+1)*t(11)+t(1+11))
607771869 1111111+((1+1)+(1+1)*t(1+1+1)+t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+t(t(1+1+1))+t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+t(11-1-1)+(1+1)*t(11-1)+(1+1+1)*t(11)+t(1+11))
618578932 111111111+(1+(1+1)*t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+(1+1+1+1)*t(11-1-1-1)+(11-1-1-1)*t(11-1-1)+(1+t(1+1+1))*t(11-1)+t(1+11))
626776380 1111+(1+(1+1)*(1+1)+t(1+1+1+1)+t((11-1)/(1+1))+t(t(1+1+1))+(1+1)*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(1+t(1+1+1))*t(11-1)+(1+1+1)*t(11)+t(1+11))
667919873 111111+((1+1)+t((11-1)/(1+1))+((11-1)/(1+1))*t(t(1+1+1))+((11-1)/(1+1))*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+(11-1-1-1)*t(11-1)+(1+1+1+1)*t(11)+t(1+11))
681786366 t(1+1+1)+(1+1+1)*t((11-1)/(1+1))+(1+1+1)*t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+(11-1-1-1)*t(11-1-1)+((11-1)/(1+1))*t(11)+t(1+11)
689854904 1111+(1+(1+1+1)*t(1+1+1+1)+t((11-1)/(1+1))+((11-1)/(1+1))*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+t(11-1-1)+(1+1+1)*t(11-1)+((11-1)/(1+1))*t(11)+t(1+11))
692055400 11+(1+(1+1)*(1+1)+t(1+1+1+1)+(1+1+1+1)*t(t(1+1+1))+t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(1+1+1)*t(11-1)+((11-1)/(1+1))*t(11)+t(1+11))
697665495 1111111111-((1+1)*(1+1)+(1+1)*t(1+1+1)+(t(1+1+1))*t(t(1+1+1))+(1+1+1)*t(11-1-1-1)+(11-1-1)*t(11-1-1)+(1+1+1)*t(11-1)+(11-1)*t(11))
711608194 (1+1)*(1+1)+t(1+1+1)+t(1+1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+t(11-1-1)+(11-1-1)*t(11-1)+((11-1)/(1+1))*t(11)+t(1+11)
734027104 11+(1+(1+1)*(1+1)+(1+1)*t(1+1+1+1)+(1+1)*t(t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+(1+1+1+1)*t(11-1)+(t(1+1+1))*t(11)+t(1+11))
750869335 111111111+((1+1)*(1+1)+(1+1)*t(1+1+1)+(1+1)*t(1+1+1+1)+t(t(1+1+1))+(1+1+1)*t(11-1-1)+(1+1+1+1)*t(11)+t(1+11))
757710567 11111+((1+1)*(1+1)+(1+1)*t(1+1+1)+(1+1)*t((11-1)/(1+1))+t(t(1+1+1))+t(1+t(1+1+1))+(11-1-1-1)*t(11-1-1)+(11-1)*t(11-1)+(t(1+1+1))*t(11)+t(1+11))
759967747 1111+((1+1)*t(1+1+1)+t(1+1+1+1)+t((11-1)/(1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1)*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(1+t(1+1+1))*t(11)+t(1+11))
777616154 11111+(1+(1+1)+((11-1)/(1+1))*t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(1+t(1+1+1))*t(11)+t(1+11))
830071127 1111+((1+1)*(1+1)+(1+1)*t(1+1+1)+(1+1+1)*t(t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(11-1-1-1)*t(11-1)+(11-1-1-1)*t(11)+t(1+11))
833809927 1111111111-(t(1+1+1+1)+(1+1+1)*t((11-1)/(1+1))+(1+1+1+1)*t(1+t(1+1+1))+t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(11-1)*t(11-1)+(t(1+1+1))*t(11))
835873060 1111111111-(1+(1+1)+(1+1)*t(1+1+1+1)+((11-1)/(1+1))*t(t(1+1+1))+(1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+(11-1-1-1)*t(11-1-1)+(11-1-1)*t(11-1)+(t(1+1+1))*t(11))
836438554 111+(1+(1+1+1)*t(1+1+1)+t(1+1+1+1)+((11-1)/(1+1))*t(11-1-1)+(11-1)*t(11-1)+(11-1-1-1)*t(11)+t(1+11))
836945593 11111111+((1+1)+(1+1)*t((11-1)/(1+1))+(1+t(1+1+1))*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+(1+t(1+1+1))*t(11-1)+(11-1-1-1)*t(11)+t(1+11))
863728236 1111+(1+(1+1)*(1+1)+(1+1+1)*t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+t(11-1-1-1)+(1+t(1+1+1))*t(11-1)+(11-1-1)*t(11)+t(1+11))
864158514 111+(1+(1+1)+(1+1+1+1)*t(1+t(1+1+1))+(1+1+1)*t(11-1-1-1)+t(11-1-1)+(1+t(1+1+1))*t(11-1)+(11-1-1)*t(11)+t(1+11))
871273503 111111111+((1+1+1)*t(1+1+1+1)+(t(1+1+1))*t(t(1+1+1))+t(1+t(1+1+1))+(1+t(1+1+1))*t(11-1-1-1)+(1+1+1+1)*t(11-1-1)+(1+t(1+1+1))*t(11)+t(1+11))
881615667 111+((1+1)*t(1+1+1)+t(1+1+1+1)+((11-1)/(1+1))*t(t(1+1+1))+(1+1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+(11-1-1)*t(11-1-1)+(11-1)*t(11)+t(1+11))
891619600 1111111+(1+(1+1)+t(1+1+1)+(1+1)*t((11-1)/(1+1))+t(t(1+1+1))+(1+1+1+1)*t(11-1-1)+(1+1+1)*t(11-1)+(11-1)*t(11)+t(1+11))
897181691 111111+((1+1)+(1+1+1)*t(1+1+1)+(1+1)*t((11-1)/(1+1))+t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+(1+1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(11-1)*t(11)+t(1+11))
918159061 1111+(t(1+1+1)+t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+t(t(1+1+1))+(t(1+1+1))*t(1+t(1+1+1))+t(11-1-1-1)+(11)*t(11)+t(1+11))
920521050 11111+(1+(1+1+1)*t(1+1+1)+(t(1+1+1))*t(t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(t(1+1+1))*t(11-1-1)+(11)*t(11)+t(1+11))
924502226 (1+1)+t(1+1+1+1)+((11-1)/(1+1))*t((11-1)/(1+1))+(t(1+1+1))*t(t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+t(11-1)+(11)*t(11)+t(1+11)
929983535 1111111111-((1+1)+t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1)*t(1+t(1+1+1))+t(11-1-1-1)+(11-1-1)*t(11-1-1)+((11-1)/(1+1))*t(11-1)+(1+1+1+1)*t(11))
943162304 1111+(1+(1+1+1)*t(1+1+1+1)+t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(11-1-1)*t(11-1-1)+(t(1+1+1))*t(11-1)+(11)*t(11)+t(1+11))
950210939 111111111+((1+1)+(1+1+1)*t(1+1+1)+(1+1)*t(1+1+1+1)+(1+1)*t((11-1)/(1+1))+(1+1+1)*t(11-1-1-1)+(1+1)*t(11-1-1)+(11-1-1)*t(11)+t(1+11))
950214176 1111111+(1+t(1+1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+(1+1)*t(1+t(1+1+1))+(1+1+1+1)*t(11-1-1-1)+((11-1)/(1+1))*t(11-1-1)+(11-1-1-1)*t(11-1)+(11)*t(11)+t(1+11))
962610357 111+(t(1+1+1)+(1+1+1+1)*t((11-1)/(1+1))+(1+1)*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+1)*t(11-1-1)+t(11-1)+(1+1)*t(1+11))
974842859 111111+((1+1)+(1+1+1)*t(1+1+1)+(1+1)*t(1+1+1+1)+t(t(1+1+1))+(1+t(1+1+1))*t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1)+(1+1+1+1)*t(11-1)+(1+1)*t(1+11))
988572832 1111111111-(1+(1+1)+(1+1)*t(1+1+1)+t(1+1+1+1)+t(t(1+1+1))+t(1+t(1+1+1))+(t(1+1+1))*t(11-1-1-1)+(1+t(1+1+1))*t(11-1-1)+(1+1+1)*t(11))


问:
Find the minimum and maximum integers in an array, without using builtins

Challenge

Given an array of integers, received from stdin, function arguments, program arguments, or some other method:

Output only the minimum and maximum numbers in the array, through a return value, stdout, or other fitting methods.

Example session

```<code>> minmax( {0, 15, 2, 3, 7, 18, -2, 9, 6, -5, 3, 8, 9, -14} )
-14 18
</code>```

Reference implementation

```<code>// C++14

void minmax(std::vector<int> v) {
    int min = v[0]; int max = v[0];
    for(auto it : v) {
        if (*it < min)
            min = *it;
        if (*it > max)
            max = *it;
    }
    std::cout << min << ' ' << max << std::endl;
}
</code>```

Rules

You may not use a built-in function to calculate the values.

Standard loopholes disallowed.

Creative implementations encouraged.

This is code-golf, shortest answer wins but will not be selected.

Clarifications

If the array contains 1 element you need to output it twice.

If the minimum and maximum values are the same, you need to output them both.

答:
Bash + coreutils, 30 bytes

tr \  \\n|sort -n|sed '$p;1!d'
```

The sed script prints, after the input is sorted, the first and last integers.

Body:
Bash + coreutils, 30 bytes

tr \  \\n|sort -n|sed '$p;1!d'

The sed script prints, after the input is sorted, the first and last integers.


问:
Esolang-Comment-Template-Generator
Lots of people on this site use esoteric languages, and since these languages are unusual and hard to understand, they will frequently write an explanation in a certain format. For example, if the code was

```<code>abcdefghijklmnop
</code>```

And this languages uses # for comments, they would write an explanation like this:

```<code>a                #Explanation of what 'a' does
 bc              #Bc
   d             #d
    e            #Explanation of e
     fgh         #foobar
        ij       #hello world
          k      #etc.
           l     #so on
            mn   #and
              op #so forth
</code>```

I frequently do this too, but every time I do this, I feel like creating the layout of text is really obnoxious and time-consuming. So I want you to create a "Esolang-Comment-Template-Generator" for me. For example, if we ignore the comments, the previous code has this template:

```<code>a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #
</code>```

The Challenge:

You must write a program or function that takes two strings as input, and outputs this "Esolang-Comment-Template". The first input will be the code, but with bars (|) inserted where the newlines go. The second input is what we will use for comments. So our last example would have this for input:

```<code>"a|bc|d|e|fgh|ij|k|l|mn|op", "#"
</code>```

Unfortunately this excludes bars from being part of the code input, but that's OK. You can assume that the comment input will be a single character. For simplicity's sake, the comment char will not be a bar. The code input will only contain printable ASCII, and it will not contain any newlines.

Hopefully you can infer what to do from the testcases, but I'll try to clarify some things.

You must split the code input up into "code-sections" on every bar. Then, each section of code is output on its own line and left-padded with the length of all the previous code (not including the bars). Then, each line is right-padded with enough spaces so that the last two characters on every line are "One additional space" + "The comment character".

One trailing newline is allowed.

Here is another example. For the input

```<code>"Hello|World", "/"
</code>```

The first section of code is "Hello" and the second is "World". So it should give the output:

```<code>Hello      /
     World /
</code>```

Here are some more samples:

```<code>Input:
"a|b|c|d|e|f|g", ","

Output:
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

Input:
"abcdefg", ":"

Output:
abcdefg :

Input:
"4|8|15|16|23|42", "%"

Output:
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

Input:
"E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!", "!"

Output:
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

Input:
"This|Code|has||empty||sections", "@"

Output:
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @
</code>```

Rules:

You may take these inputs and outputs in any reasonable format. For example, reading/writing a file, STDIN/STOUT, function arguments/return value, etc. As usual, this is code-golf, so try to make your code as short as possible and you win if you can get the shortest solution in your language! I will also select the shortest solution as the overall winner. Standard loopholes are banned.

答:
Perl, 63 bytes

Includes +5 for -Xpi

Run with input on STDIN and comment character after -i:

```<code>perl -Xpi% esolang.pl <<< "Ab|Cd||ef"
</code>```

esolang.pl:

```<code>s/
/|/;s%(.*?)\|%$"x$`=~y/|//c.$1.$"x$'=~y/|//c." $^I
"%eg
</code>```

Totally boring straightforward solution

ContentLicense: CC BY-SA 4.0

Title: Esolang-Comment-Template-Generator

Body:
Perl, 63 bytes

Includes +5 for -Xpi

Run with input on STDIN and comment character after -i:

perl -Xpi% esolang.pl <<< "Ab|Cd||ef"

esolang.pl:

s/
/|/;s%(.*?)\|%$"x$`=~y/|//c.$1.$"x$'=~y/|//c." $^I
"%eg

Totally boring straightforward solution


答:
php, 103 bytes

```<code><?php for($s=$a=$argv[1];++$i<$a;)if($a%$i==0&&$s>$t=abs($i*$i/$a-1.618)){$n=$i;$s=$t;}echo"$n ".$a/$n;
</code>```

Produces a notice (this doesn't interrupt execution) about unassigned $i so should be run in an environment that silences notices.

Title: Goldenness of an integer

Body:
A positive integer n can be represented as a rectangle with integer sides a, b such that n = a * b. That is, the area represents the number. In general, a and b are not unique for a given n.

As is well known, a rectangle is specially pleasing to the eye (or is it the brain?) when its sides are in the golden ratio, φ = (sqrt(5)+1)/2 ≈ 1.6180339887...

Combining these two facts, the purpose of this challenge is to decompose an integer n into the product of two integers a, b whose ratio is as close as possible to φ (with the usual metric on ℝ). The fact that φ is irrational implies that there is a unique solution pair (a, b).

The challenge

Given a positive integer n, output positive integers a, b such that  a * b = n and the absolute difference between a/b and φ is minimized.

As an example, consider n = 12. The pairs (a, b) that satisfy a * b = n are: (1, 12), (2,6), (3,4), (4,3), (6,2), (12,1). The pair whose ratio is closest to φ is (4,3), which gives 4/3 = 1.333.

Rules

Functions or programs are acceptable.

The numerator (a) should appear first in the output, and the denominator (b) second. Other than that, input and output formats are flexible as usual. For example, the two numbers can be output as strings with any reasonable separator, or as an array.

The code should work in theory for arbitrarily large numbers. In practice, it may be limited by memory or data-type restrictions.

It's sufficient to consider an approximate version of φ, as long as it is accurate up to the third decimal or better. That is, the absolute difference between the true φ and the approximate value should not exceed 0.0005. For example, 1.618 is acceptable.

When using an approximate, rational version of φ there's a small chance that the solution is not unique. In that case you can output any pair a, b that satisfies the minimization criterion.

Shortest code wins.

Test cases

```<code>1        ->  1    1
2        ->  2    1
4        ->  2    2
12       ->  4    3
42       ->  7    6
576      ->  32   18
1234     ->  2    617
10000    ->  125  80
199999   ->  1    199999
9699690  ->  3990 2431
</code>```

Body:
php, 103 bytes

<?php for($s=$a=$argv[1];++$i<$a;)if($a%$i==0&&$s>$t=abs($i*$i/$a-1.618)){$n=$i;$s=$t;}echo"$n ".$a/$n;

Produces a notice (this doesn't interrupt execution) about unassigned $i so should be run in an environment that silences notices.


问:
Implementing bool() without any conditionals
Title says it all. Given some input, turn it into a boolean value (0 or 1), without using conditional statements (e.x. == > < <= >= != ~=), or any function which uses conditional statements within its implementation, such as if, while and for. Your program must work with floating points, although you get more if it works with other items.

A general rule for determining whether bool(item) is False is if the item is empty ('' is an empty string, [] is an empty list.), or if the function used to turn an item of one type into another is given no input (in Python, str() returns '', list() returns [].)

Here are (some of) the different valid types. Your program is considered to work with one type if it works with one item in the following lists:

Integers, floating points, doubles, longs

Strings

Lists, tuples, arrays (bytearrays)

Dictionaries

Functions

Objects/Classes

Program score will be calculated like this: [# of characters]-(50*[# of types]). The program with the smallest score wins the challenge.

答:
JavaScript, -278

```<code>function bool(_,$){try{$=_.length;$._;_=$}catch(_){}return 1-isNaN(_/_)}
</code>```

Doesn’t use any boolean operators! If global leaking and input is okay, then it’s even shorter, at 65 characters:

```<code>bool=eval.bind(0,'try{$=_.length;$._;_=$}catch(_){}1-isNaN(_/_)')
</code>```

Works for anything with a length and all primitive types and their object wrappers.

Now you've added a list of things that count as types, but what kind of function or class should evaluate to false? This one treats functions that take no arguments as false - does that count? What about classes? What does that mean?

Body:
JavaScript, -278

function bool(_,$){try{$=_.length;$._;_=$}catch(_){}return 1-isNaN(_/_)}

Doesn’t use any boolean operators! If global leaking and input is okay, then it’s even shorter, at 65 characters:

bool=eval.bind(0,'try{$=_.length;$._;_=$}catch(_){}1-isNaN(_/_)')

Works for anything with a length and all primitive types and their object wrappers.

Now you've added a list of things that count as types, but what kind of function or class should evaluate to false? This one treats functions that take no arguments as false - does that count? What about classes? What does that mean?


Title: There can be only 1!

Body:
JavaScript (ES6), 27212498, 2016-09-12 09:46:34Z

f=(n,a='+',s='-',m=n*9+'',r=m.replace(/./g,1))=>r-n?m<'55'?--r/10+a+f(n-r/10,a,s):r+s+f(r-n,s,a):r;
s = '';
[945536, 16878234, 32608778, 42017515, 48950830, 51483452, 52970263, 54278649, 63636656, 78817406, 89918907, 90757642, 95364861, 102706605, 113965374, 122448605, 126594161, 148064959, 150735075, 154382918, 172057472, 192280850, 194713795, 207721209, 220946392, 225230299, 227043979, 241011012, 248906099, 249796314, 250546528, 258452706, 276862988, 277140688, 280158490, 286074562, 308946627, 310972897, 322612091, 324445400, 336060042, 346729632, 349428326, 352769482, 363039453, 363851029, 392168304, 401975104, 407890409, 407971913, 425780757, 459441559, 465592122, 475898732, 482826596, 484263150, 506235403, 548951531, 554295842, 580536366, 587051904, 588265985, 588298051, 590968352, 601194306, 607771869, 618578932, 626776380, 667919873, 681786366, 689854904, 692055400, 697665495, 711608194, 734027104, 750869335, 757710567, 759967747, 777616154, 830071127, 833809927, 835873060, 836438554, 836945593, 863728236, 864158514, 871273503, 881615667, 891619600, 897181691, 918159061, 920521050, 924502226, 929983535, 943162304, 950210939, 950214176, 962610357, 974842859, 988572832].forEach(n => { s += f(n); console.log(n, f(n)); });
l = s.match(/1/g).length;
console.log((s.length - l) * l);

Only uses + and -. Based on my answer to Minimize Those Ones


问:
Can the number reach 1 by repeatedly subtracting the largest prime less than it?

Challenge:

Given a number, take the largest prime strictly less than it, subtract it from this number, do this again to this new number with the biggest prime less than it, and continue doing this until it's less than 3. If it reaches 1, your program should output a truthy value, else, the program should output a falsey value.

Examples:

All of these should give a truthy value:

```<code>3
4
6
8
10
11
12
14
16
17
18
20
22
23
24
26
27
29
30
32
34
35
37
38
40
41
42
44
46
47
48
50
</code>```

All of these should give falsey values:

```<code>5
7
9
13
15
19
21
25
28
31
33
36
39
43
45
49
</code>```

Rules:

You can either write a program or function.

You can assume that the input is bigger than 2.

Standard loopholes apply

This is code-golf so the shortest answer wins!

答:
Haskell, 79 bytes

Not really short but pointfree :)

```<code>(<2).until(<3)(until(flip(`until`(+1))2.(.)(<1).mod>>=(==))pred.pred>>=flip(-))
</code>```

Body:
Haskell, 79 bytes

Not really short but pointfree :)

(<2).until(<3)(until(flip(`until`(+1))2.(.)(<1).mod>>=(==))pred.pred>>=flip(-))


问:
Counting Goats to Sleep
Some people count sheep to get to sleep. Others count goats.

Write a program or function that takes in a positive integer N and outputs N-1 awake goats followed by one sleeping goat, as if someone was counting N goats and at the very last one they fell asleep.

Awake goats look like this:

```<code>      \
  ___/o>
-(___)"
 '' ''
</code>```

Sleeping goats look like this:

```<code>      \
  ___/->
,(___)"
 `` ``
</code>```

They are chained together with a single space between beard and tail of adjacent goats:

```<code>      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``
</code>```

The output is allowed to have trailing spaces and a single trailing newline.

The shortest code in bytes wins.

Examples

N = 1:

```<code>      \
  ___/->
,(___)"
 `` ``
</code>```

N = 2:

```<code>      \       \
  ___/o>  ___/->
-(___)" ,(___)"
 '' ''   `` ``
</code>```

N = 3:

```<code>      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``
</code>```

N = 4:

```<code>      \       \       \       \
  ___/o>  ___/o>  ___/o>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``
</code>```

Larger N should work just as well.

答:
IBM/Lotus Notes Formula, <s>187</s> <s>174</s> 188 bytes <s>(not competing)</s>

EDIT Found a space that shouldn't have been there and removed an unneeded @Implode

188 as I had missed the fact that the tail of the sleeping goat is different :-(

```<code>B:=@Repeat("      \\  ";a);C:=@Repeat("     /o> ";a-1)+"     /->";D:=@Repeat("  ---    ";a);E:=@Repeat(",(___)\"  ";a);F:=@Repeat(" `` ``   ";a);@Implode(B:C:D:E:F;@NewLine)
</code>```

Ungolfed:

```<code>B:=@Repeat("      \\  ";a);
C:=@Repeat("     /o> ";a-1)+"     /->";
D:=@Repeat("  ---    ";a);
E:=@Repeat("`(___)\"  ";a-1)+",(___)\"  ";
F:=@Repeat(" `` ``   ";a);
@Implode(B:C:D:E:F;@NewLine)
</code>```

Usage:

Create a Notes form with two fields named a and g.

a=editable, number, g=computed, text.

Paste the above formula into g and give a a default value of 0.

Set the form font to Terminal.

Create a new document with the form, enter a number in a and press F9 to update the goats.

Samples:

<s>Not competing as the format messes up when the number of goats reaches the width of the page. </s>

Given an infinitely wide screen it <s>should</s> will work for any number of goats<s> though</s>. This is what it looks like when the page is not wide enough.

Title: Counting Goats to Sleep

Body:
IBM/Lotus Notes Formula, <s>187</s> <s>174</s> 188 bytes <s>(not competing)</s>

EDIT Found a space that shouldn't have been there and removed an unneeded @Implode

188 as I had missed the fact that the tail of the sleeping goat is different :-(

B:=@Repeat("      \\  ";a);C:=@Repeat("     /o> ";a-1)+"     /->";D:=@Repeat("  ---    ";a);E:=@Repeat(",(___)\"  ";a);F:=@Repeat(" `` ``   ";a);@Implode(B:C:D:E:F;@NewLine)

Ungolfed:

B:=@Repeat("      \\  ";a);
C:=@Repeat("     /o> ";a-1)+"     /->";
D:=@Repeat("  ---    ";a);
E:=@Repeat("`(___)\"  ";a-1)+",(___)\"  ";
F:=@Repeat(" `` ``   ";a);
@Implode(B:C:D:E:F;@NewLine)

Usage:

Create a Notes form with two fields named a and g.

a=editable, number, g=computed, text.

Paste the above formula into g and give a a default value of 0.

Set the form font to Terminal.

Create a new document with the form, enter a number in a and press F9 to update the goats.

Samples:

<s>Not competing as the format messes up when the number of goats reaches the width of the page. </s>

Given an infinitely wide screen it <s>should</s> will work for any number of goats<s> though</s>. This is what it looks like when the page is not wide enough.


答:
Java 8, <s>236</s> <s>222</s> <s>218</s> 173 bytes

n->{String x="\n",a="",b=a,c=a,d=a;for(;n-->0;a+="      \\ ",b+="  ___/"+(n<1?"-":"o")+">",c+=(n<1?",":"-")+"(   )\" ")d+=(n<1?" `` ``":" '' ''")+"  ";return a+x+b+x+c+x+d;}
```
<p><strong>Explanation:</strong></p>
<p>Try it online.</p>
<pre class="lang-java prettyprint-override"><code>n->{                                // Method with integer parameter and String return-type
  String x="\n",                    //  New-line String to reduce bytes
         a="",                      //  Row 1 String, starting empty
         b=a,                       //  Row 2 String, starting empty
         c=a,                       //  Row 3 String, starting empty
         d=a;                       //  Row 4 String, starting empty
  for(;n-->0;                       //  Loop `n` times:
    a+="      \\ ",                 //   Append the horns to row 1
    b+="  ___/"+(n<1?"-":"o")+">",  //   Append the back and head to row 2
    c+=(n<1?",":"-")+"(   )\" ")    //   Append the tail, body, and beard to row 3
    d+=(n<1?" `` ``":" '' ''")+"  ";//   Append the legs to row 4
  return a+x+b+x+c+x+d;}            //  Return the four rows, separated by new-lines
</code>```

Title: Counting Goats to Sleep

Body:
Some people count sheep to get to sleep. Others count goats.

Write a program or function that takes in a positive integer N and outputs N-1 awake goats followed by one sleeping goat, as if someone was counting N goats and at the very last one they fell asleep.

Awake goats look like this:

```<code>      \
  ___/o>
-(___)"
 '' ''
</code>```

Sleeping goats look like this:

```<code>      \
  ___/->
,(___)"
 `` ``
</code>```

They are chained together with a single space between beard and tail of adjacent goats:

```<code>      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``
</code>```

The output is allowed to have trailing spaces and a single trailing newline.

The shortest code in bytes wins.

Examples

N = 1:

```<code>      \
  ___/->
,(___)"
 `` ``
</code>```

N = 2:

```<code>      \       \
  ___/o>  ___/->
-(___)" ,(___)"
 '' ''   `` ``
</code>```

N = 3:

```<code>      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``
</code>```

N = 4:

```<code>      \       \       \       \
  ___/o>  ___/o>  ___/o>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``
</code>```

Larger N should work just as well.

Body:
Java 8, <s>236</s> <s>222</s> <s>218</s> 173 bytes

n->{String x="\n",a="",b=a,c=a,d=a;for(;n-->0;a+="      \\ ",b+="  ___/"+(n<1?"-":"o")+">",c+=(n<1?",":"-")+"(   )\" ")d+=(n<1?" `` ``":" '' ''")+"  ";return a+x+b+x+c+x+d;}

Explanation:

Try it online.

n->{                                // Method with integer parameter and String return-type
  String x="\n",                    //  New-line String to reduce bytes
         a="",                      //  Row 1 String, starting empty
         b=a,                       //  Row 2 String, starting empty
         c=a,                       //  Row 3 String, starting empty
         d=a;                       //  Row 4 String, starting empty
  for(;n-->0;                       //  Loop `n` times:
    a+="      \\ ",                 //   Append the horns to row 1
    b+="  ___/"+(n<1?"-":"o")+">",  //   Append the back and head to row 2
    c+=(n<1?",":"-")+"(   )\" ")    //   Append the tail, body, and beard to row 3
    d+=(n<1?" `` ``":" '' ''")+"  ";//   Append the legs to row 4
  return a+x+b+x+c+x+d;}            //  Return the four rows, separated by new-lines


问:
Evaluate the primorial of a number
The primorial of a number is the product of all the primes until that number, itself included.

Take a number from STDIN as the input and evaluate its primorial, also known as the prime factorial.

Don't use libraries. Shortest code wins.

Test cases:

```<code>1 1
2 2
3 6
4 6
5 30
6 30
7 210
8 210
9 210
10 210
11 2310
12 2310
13 30030
14 30030
15 30030
16 30030
17 510510
18 510510
19 9699690
</code>```

答:
Haskell, 76 bytes

```<code>main=interact$ \n->show$product[x|x<-[2..read n],and[x`mod`y>0|y<-[2..x-1]]]
</code>```

Example:

```<code>$ echo 12 | ./primorial
2310
</code>```

Title: Evaluate the primorial of a number

Body:
Haskell, 76 bytes

main=interact$ \n->show$product[x|x<-[2..read n],and[x`mod`y>0|y<-[2..x-1]]]

Example:

$ echo 12 | ./primorial
2310


问:
Make me a bad fade animation... please
Your task is to, as the title discreetly suggests, make a bad fade animation of one word turning into a second word for yours truly.

What exactly is this "fade animation" you may ask?

To make a spectacular(ly bad) fade animation, you take two strings which will contain only printable ASCII characters. You start by printing your starting string (the first of the two). Then, you randomly pick a character in the original word and change it to the corresponding character in the word you want to animate to. When the words are of unequal length, you must pad them with spaces.

You keep on doing this until all of the characters have been changed, but you will not change the character at a certain index more than once. Here is an example i/o:

```<code>Hey -> Peeps
Hey    # original string
Hey s  # replace char at index 4
Hey s  # replace char at index 1
Pey s  # replace char at index 0
Pee s  # replace char at index 2
Peeps  # replace char at index 3
</code>```

You must write a function or full program that changes a letter and then prints the new string at increments of one second. The input format is loose, but the output format is strict.

This is code-golf, so shortest code in bytes wins.

Some test cases (Form: init -> final):

```<code>Stringy -> Blingy
Banana -> Republic
United -> States
Make America -> Tissue box
I like walls -> I have small hands
Hello, -> world!
</code>```

Reference implementation in Python 2:

```<code>import random
import time
def F(c,f):
    print c                                      # before we do stuff
    if len(c)>len(f):f+=" "*(len(c)-len(f))      # add padding part 1
    if len(f)>len(c):c+=" "*(len(f)-len(c))      # add padding part 2
    c, f = list(c), list(f)
    ai = [i for i in range(len(c))]              # a list for keeping track
    while len(ai) > 0:                           #  of available indices
        time.sleep(1)                            # 1 second pause...
        i = ai.pop(random.randint(0,len(ai)-1))  # get a random index and remove
        c[i] = f[i]                              #   it from the list
        print ''.join(c)                         # print the new string
</code>```

答:
PHP, <s>123</s> 121 bytes

```<code><?=$a=$argv[1];for($b=str_split(str_pad($argv[2],strlen($a)));$b;print"
$a"){$a[$i=array_rand($b)]=$b[$i];unset($b[$i]);}
</code>```

save as file, execute with php <filename> <string1> <string2> (or php-cgi)

breakdown

```<code><?=$a=$argv[1];                         // 0. print original
for(
    $b=str_split(                       // 2. split to array of single characers
        str_pad($argv[2],strlen($a))    // 1. pad 2nd argument to length of 1st argument
    );
    $b;                                 // 3. while $b has characters left
    print"\n$a"                         // 6. print altered string
){
    $a[$i=array_rand($b)]=$b[$i];       // 4. pick random index from $b, copy character to $a
    unset($b[$i]);                      // 5. remove character from $b
}
</code>```

Title: Make me a bad fade animation... please

Body:
PHP, <s>123</s> 121 bytes

<?=$a=$argv[1];for($b=str_split(str_pad($argv[2],strlen($a)));$b;print"
$a"){$a[$i=array_rand($b)]=$b[$i];unset($b[$i]);}

save as file, execute with php <filename> <string1> <string2> (or php-cgi)

breakdown

<?=$a=$argv[1];                         // 0. print original
for(
    $b=str_split(                       // 2. split to array of single characers
        str_pad($argv[2],strlen($a))    // 1. pad 2nd argument to length of 1st argument
    );
    $b;                                 // 3. while $b has characters left
    print"\n$a"                         // 6. print altered string
){
    $a[$i=array_rand($b)]=$b[$i];       // 4. pick random index from $b, copy character to $a
    unset($b[$i]);                      // 5. remove character from $b
}


问:
Sum of primes between given range
Write the shortest code for finding the sum of primes between \$a\$ and \$b\$ (inclusive).

Input

\$a\$ and \$b\$ can be taken from command line or stdin (space seperated)

Assume \$1 \le a \le b \le 10^8\$

Output
Just print the sum with a newline character.

Bonus Points

If the program accepts multiple ranges (print one sum on each line), you get extra points. :)

答:
Java 8, <s>239</s> <s>237</s> <s>74</s> 73 bytes

a->b->{long r=0,t;for(;a<=b;r-=b--==t?~b:0)for(t=1;b%++t%b>0;);return r;}
```
<p>-1 byte thanks to <em>@ceilingcat</em></p>
<p>Try it online.</p>
<p><strong>Explanation:</strong></p>
<pre class="lang-java prettyprint-override"><code>a->b->{              // Method with two Long parameters & Long return-type
  long r=0,          //  Result-sum, starting at 0
       t;            //  Temp-long
  for(;a<=b          //  Loop as long as `a` is still smaller than or equal to `b`:
      ;              //    After every iteration:
       r-=           //     Decrease the result-sum by:
          b--==t?    //      If `b` is equal to `t` (which means `b` is a prime):
                     //      (and decrease `b` by 1 afterwards with `b--`)
           ~b        //       Decrease the result-sum by `-b-1`
                     //       (aka Increase the result-sum by `b+1`,
                     //        where `+1` is to account for the earlier `b--`)
          :          //      Else:
           0)        //       Leave `r` the same by decreasing with 0
    for(t=1;         //   (Re)set `t` to 1
        b%++t%b>0;); //   Increase `t` by 1 first with `++t` every iteration,
                     //   and loop as long as `b` is NOT divisible by `t`,
                     //   and `b` is NOT 1 (with the second `%b`)
  return r;}         //  After the nested loop, return the result-sum
</code>```

Title: Sum of primes between given range

Body:
Java 8, <s>239</s> <s>237</s> <s>74</s> 73 bytes

a->b->{long r=0,t;for(;a<=b;r-=b--==t?~b:0)for(t=1;b%++t%b>0;);return r;}

-1 byte thanks to @ceilingcat

Try it online.

Explanation:

a->b->{              // Method with two Long parameters & Long return-type
  long r=0,          //  Result-sum, starting at 0
       t;            //  Temp-long
  for(;a<=b          //  Loop as long as `a` is still smaller than or equal to `b`:
      ;              //    After every iteration:
       r-=           //     Decrease the result-sum by:
          b--==t?    //      If `b` is equal to `t` (which means `b` is a prime):
                     //      (and decrease `b` by 1 afterwards with `b--`)
           ~b        //       Decrease the result-sum by `-b-1`
                     //       (aka Increase the result-sum by `b+1`,
                     //        where `+1` is to account for the earlier `b--`)
          :          //      Else:
           0)        //       Leave `r` the same by decreasing with 0
    for(t=1;         //   (Re)set `t` to 1
        b%++t%b>0;); //   Increase `t` by 1 first with `++t` every iteration,
                     //   and loop as long as `b` is NOT divisible by `t`,
                     //   and `b` is NOT 1 (with the second `%b`)
  return r;}         //  After the nested loop, return the result-sum


答:
Java 7, 213 bytes

```<code>class M{public static void main(String[]a){c(new Long(a[0]));}static void c(long n){long r=1,i=0;for(;++i<=n;r*=p(i)?i:1);System.out.print(r);}static boolean p(long n){int i=2;while(i<n)n=n%i++<1?0:n;return n>1;}}
</code>```

Ungolfed:

```<code>class M{
  static void c(long n){
    long r = 1,
         i = 0;
    for (; ++i <= n; r *= p(i) ? i : 1);
    System.out.print(r);
  }

  public static void main(String[] a){
    c(new Long(a[0]));
  }

  static boolean p(long n){
    int i = 2;
    while(i < n){
      n = n % i++ < 1 ? 0 : n;
    }
    return n > 1;
  }
}
</code>```

Usage: java -jar M.jar 17

Output: 510510

Title: Evaluate the primorial of a number

Body:
The primorial of a number is the product of all the primes until that number, itself included.

Take a number from STDIN as the input and evaluate its primorial, also known as the prime factorial.

Don't use libraries. Shortest code wins.

Test cases:

```<code>1 1
2 2
3 6
4 6
5 30
6 30
7 210
8 210
9 210
10 210
11 2310
12 2310
13 30030
14 30030
15 30030
16 30030
17 510510
18 510510
19 9699690
</code>```

Body:
Java 7, 213 bytes

class M{public static void main(String[]a){c(new Long(a[0]));}static void c(long n){long r=1,i=0;for(;++i<=n;r*=p(i)?i:1);System.out.print(r);}static boolean p(long n){int i=2;while(i<n)n=n%i++<1?0:n;return n>1;}}

Ungolfed:

class M{
  static void c(long n){
    long r = 1,
         i = 0;
    for (; ++i <= n; r *= p(i) ? i : 1);
    System.out.print(r);
  }

  public static void main(String[] a){
    c(new Long(a[0]));
  }

  static boolean p(long n){
    int i = 2;
    while(i < n){
      n = n % i++ < 1 ? 0 : n;
    }
    return n > 1;
  }
}

Usage: java -jar M.jar 17

Output: 510510


问:
Fibonacci function or sequence
The Fibonacci sequence is a sequence of numbers, where every number in the sequence is the sum of the two numbers preceding it.  The first two numbers in the sequence are both 1. Here are the first few terms:

```<code>1 1 2 3 5 8 13 21 34 55 89 ...
</code>```

Write the shortest code that either:

Generates the Fibonacci sequence without end.

Given n calculates the nth term of the sequence. (Either 1 or zero indexed)

You may use standard forms of input and output.

(I gave both options in case one is easier to do in your chosen language than the other.)

For the function that takes an n, a reasonably large return value (the largest Fibonacci number that fits your computer's normal word size, at a minimum) has to be supported.

Leaderboard

/* Configuration */

var QUESTION_ID = 85; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 3; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery(''+lang+'').text();

    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}```
<pre class="snippet-code-css lang-css prettyprint-override"><code>body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}</code>```

<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

```

答:
Brainfuck, 22 bytes

```<code>+>++[-<<[->+>+<<]>>>+]
</code>```

Generates the Fibonacci sequence gradually moving across the memory tape.

Title: Fibonacci function or sequence

Body:
Brainfuck, 22 bytes

+>++[-<<[->+>+<<]>>>+]

Generates the Fibonacci sequence gradually moving across the memory tape.


问:
Carmichael Numbers
Write a program to print Carmichael numbers. The challenge is to print the maximum number of them in less than 5 secs. The numbers should be in increasing order. Please do not use built in functions. Also please don't store the carmichael numbers in any form. To keep a common time measurement use Ideone. The program to print the maximum number of Carmichael number wins.

```<code>Sample Output
561
1105
1729
2465
2821
6601
8911
.
.
.
</code>```

OEIS A002997

答:
unGolf3D dear Java :) maxCount=1193221 (at my local) and 552721 (at ideone) in 4.8s

```<code>    public class Main{
    public static void main(String[] args){
          long start=System.currentTimeMillis();
          int N=1200000;
          int list[]=new int[N];
            for (int i=0;i<N;i++) {
                list[i]=(i+1);
            }
            for (int i=1;i<N;i++) {
                if (Math.sqrt(list[i])-Math.floor(Math.sqrt(list[i]))==0) {
                    for (int j=i;j<N;j+=(i+1)){
                        list[j]=-1;
                    }
                }
            }
        boolean Carmichael=false;
        int chemCount=0;
        int product=1;
          for(int i=561  ;(System.currentTimeMillis()-start)/1000.0<=5;i++){
              if(!isPrime(i)&&list[i-1]==i){
                  for(int div=2;div<Math.sqrt(i);div++){
                      if(i%div==0 && isPrime(div)){
                          if((i-1)%(div-1)==0){
                              Carmichael= true;
                              product*=div;
                              chemCount++;
                              if (product==i) break;
                              }
                          else{
                              Carmichael=false;
                              break;
                              }
                      }
                  }
                  if (Carmichael && chemCount>=3 && product==i)
                      System.out.println(i);
                  Carmichael=false;
                   chemCount=0;
                   product=1;
              }
          }
  }

        static boolean isPrime(long number){
            if (number==2)
                return true;
            if (number==1)
                return false;
            for (long i=2;i<=Math.sqrt(number);i++) {
                if (number%i==0)
                    return false;
            }
            return true;
        }
    }
</code>```

My JVM gets this to 1193221 number in 5 sec... I am sure this is slower than any other scripting languages and algo!! :( ...
OTOH, http://www.ideone.com/clone/oNJin fails to create this big process.. calculates upto 552721 in 4.8 sec and breaks after that throwing http://en.wikipedia.org/wiki/SIGXCPU :)

Title: Carmichael Numbers

Body:
unGolf3D dear Java :) maxCount=1193221 (at my local) and 552721 (at ideone) in 4.8s

    public class Main{
    public static void main(String[] args){
          long start=System.currentTimeMillis();
          int N=1200000;
          int list[]=new int[N];
            for (int i=0;i<N;i++) {
                list[i]=(i+1);
            }
            for (int i=1;i<N;i++) {
                if (Math.sqrt(list[i])-Math.floor(Math.sqrt(list[i]))==0) {
                    for (int j=i;j<N;j+=(i+1)){
                        list[j]=-1;
                    }
                }
            }
        boolean Carmichael=false;
        int chemCount=0;
        int product=1;
          for(int i=561  ;(System.currentTimeMillis()-start)/1000.0<=5;i++){
              if(!isPrime(i)&&list[i-1]==i){
                  for(int div=2;div<Math.sqrt(i);div++){
                      if(i%div==0 && isPrime(div)){
                          if((i-1)%(div-1)==0){
                              Carmichael= true;
                              product*=div;
                              chemCount++;
                              if (product==i) break;
                              }
                          else{
                              Carmichael=false;
                              break;
                              }
                      }
                  }
                  if (Carmichael && chemCount>=3 && product==i)
                      System.out.println(i);
                  Carmichael=false;
                   chemCount=0;
                   product=1;
              }
          }
  }

        static boolean isPrime(long number){
            if (number==2)
                return true;
            if (number==1)
                return false;
            for (long i=2;i<=Math.sqrt(number);i++) {
                if (number%i==0)
                    return false;
            }
            return true;
        }
    }

My JVM gets this to 1193221 number in 5 sec... I am sure this is slower than any other scripting languages and algo!! :( ...
OTOH, http://www.ideone.com/clone/oNJin fails to create this big process.. calculates upto 552721 in 4.8 sec and breaks after that throwing http://en.wikipedia.org/wiki/SIGXCPU :)

ContentLicense: CC BY-SA 2.5


问:
Emulate a 7-segment display

Task

The task is to display any of the 128 possible states of a
7-segment display.

Your program should accept a string of 7 characters ("bits") that are either 0 or 1.
First bit of input corresponds to segment A of the following illustration, the
second to B, etc (ignore dp):

How you represent the display is up to you -- a single Unicode or ASCII symbol,
ASCII art, grafically, or whatever you can come up with. However, each
input must have it's own distinct output. If you come up with something fancy I'm sure you can harvest upvotes by showing off some examples.

All 128 possible states of the display are:

Rules

Codegolf

As I said, any kind of output is allowed, but it would be nice if you specified it.

Input can be stdin or command line argument.

Examples

Input

```<code>1101101
</code>```

Output

As ASCII/Unicode:

```<code>2
</code>```

Different kinds of ASCII art (I'm not too good at this)

```<code> _   ╺┓  ╒╗   ---
 _|  ┏┛  ╔╝     |
|_   ┗╸  ╚╛   ---
              |
              ---
</code>```

答:
PostScript: 53 binary, 87 ASCII 52 binary, 86 ASCII

Hexdump of the program using binary tokens:

```<code>$ hexdump -C lcd_binary.ps
00000000  28 34 34 30 34 30 38 30  34 30 34 30 30 30 30 34  |(440408040400004|
00000010  30 34 30 34 34 34 34 34  38 34 38 30 38 29 7b 7d  |0404444484808){}|
00000020  92 49 6e 7b 92 70 31 92  04 92 96 92 6b 92 63 92  |.In{.p1.....k.c.|
00000030  a7 7d 92 49                                       |.}.I|
00000034
</code>```

Download this file to try it out.

Using ASCII tokens:

```<code>(4404080404000040404444484808){}forall
n{not 1 and setgray moveto lineto stroke}forall
</code>```

First forall loop puts all required coordinates on the stack. The coordinates are stored in a string to minimize required space. The coordinates are in reverse order, i.e. the last 4 chars are for segment A. We draw a line from (0,8) to (4,8) for this segment (actually, we have to add 48 to all coordinates, because forall puts all ASCII codes on the stack).

The second forall loops through all the 0s and 1s in the input string and turns them into a gray value. 0s are drawn white (gray value 1) and 1s are drawn black (gray value 0). Then we use the coordinates that the first forall loop left on the stack to draw the lines.

Invoke the program using Ghostscript, just like Geoff Reedy's:

```<code>gs -sn=1101101 lcd.ps
</code>```

This displays:

Title: Emulate a 7-segment display

Body:
PostScript: 53 binary, 87 ASCII 52 binary, 86 ASCII

Hexdump of the program using binary tokens:

$ hexdump -C lcd_binary.ps
00000000  28 34 34 30 34 30 38 30  34 30 34 30 30 30 30 34  |(440408040400004|
00000010  30 34 30 34 34 34 34 34  38 34 38 30 38 29 7b 7d  |0404444484808){}|
00000020  92 49 6e 7b 92 70 31 92  04 92 96 92 6b 92 63 92  |.In{.p1.....k.c.|
00000030  a7 7d 92 49                                       |.}.I|
00000034

Download this file to try it out.

Using ASCII tokens:

(4404080404000040404444484808){}forall
n{not 1 and setgray moveto lineto stroke}forall

First forall loop puts all required coordinates on the stack. The coordinates are stored in a string to minimize required space. The coordinates are in reverse order, i.e. the last 4 chars are for segment A. We draw a line from (0,8) to (4,8) for this segment (actually, we have to add 48 to all coordinates, because forall puts all ASCII codes on the stack).

The second forall loops through all the 0s and 1s in the input string and turns them into a gray value. 0s are drawn white (gray value 1) and 1s are drawn black (gray value 0). Then we use the coordinates that the first forall loop left on the stack to draw the lines.

Invoke the program using Ghostscript, just like Geoff Reedy's:

gs -sn=1101101 lcd.ps

This displays:


答:
Haskell, <s>47</s> 44 bytes

```<code>a!b=sum[x|x<-[a..b],all((<)0.mod x)[2..x-1]]
</code>```

SEJPM helped me save 3 bytes!

Title: Sum of primes between given range

Body:
Write the shortest code for finding the sum of primes between \$a\$ and \$b\$ (inclusive).

Input

\$a\$ and \$b\$ can be taken from command line or stdin (space seperated)

Assume \$1 \le a \le b \le 10^8\$

Output
Just print the sum with a newline character.

Bonus Points

If the program accepts multiple ranges (print one sum on each line), you get extra points. :)

Body:
Haskell, <s>47</s> 44 bytes

a!b=sum[x|x<-[a..b],all((<)0.mod x)[2..x-1]]

SEJPM helped me save 3 bytes!