text:
Mutual exclusive equinox

Your sourcecode must not contain any of the characters it outputs (case sensitive).
Your program must not output more than 500 characters/bytes. 1 byte = 1 char. Newline counts as 1 character.
Your program should not take any input. (from user, filename, network or anything).
Your program must output words/phrases worth a total of minimum 700 points according to the following score table (case sensitive):

Score table:
me                        - 2   points
ore                       - 3   points
freq                      - 5   points
pager                     - 7   points
mentor                    - 11  points
triumph                   - 13  points
equipage                  - 17  points
equipment                 - 19  points
equivalent                - 23  points
equilibrium               - 29  points
unubiquitous              - 31  points
questionnaire             - 37  points
Mutüal 3xcLUs1ve_Equino>< - 400 points

4.1 Each word can be repeated but lose 1 point for each repetition (with exception for the last phrase worth 400 points, you must not repeat that in the output). For example:

four of equilibrium (in any place) in the output = 29+28+27+26 points.

4.2 Letters in the output can be used in more than one word, for example:

equipager = equipage and pager = 17+7 points.
This is code-golf, shortest sourcecode in bytes wins! Good luck, have fun!

Can my program contain the command "print" for example? because the letter 'i' appears in the source code and therefore most of the letters cannot be printed.

If your program contain the command print you cannot output any p, r, i, n or t and only get points for the word: me and I doubt you can reach 700 points using only that word ;). I foresee sourcecodes with most code in upper-case ;)

Is the fourth repetition of "me" worth zero points, or -1 point?

The fourth is worth zero points. No penalties (except for the 400 points phrase.)

Who wins? The shortest sourcecode or the best score?

It is code-golf, shortest code wins. The score is only part of the rules

Golfscript, 24 characters
"QUESTIONNAIRE"{32+}%36*

Way too easy.
36 repetitions of "questionnaire" = 36*13 characters = 468 characters.
36 repetitions of "questionnaire" = 37+36+...1 point = (37+1)(37)/2 points = 703 points.

Oh, darn! Thought I did the math correct, invalidating an option like this.. should have set it to 800 points instead ;) good work! +1

Then I would output some two words multiple times instead :-) Unfortunately, "equipager" is the only good overlap, and its repetition is worth way too few points.

Yes, you are correct. I tried to weight the challenge so that the 400 points phrase actually should have been an option, but did the math regarding output-limit and score points wrong :(

JavaScript, 391 chars
Could be golfed further.  Port of Jan Dvorak's answer; alerts "questionnaire" 36 times (although, hardcoded instead of via a loop).  T contains the string "true", F the string "false" and O the string "[object Object]".  From these (and (1/0)+[] = "Infinity"), R = "return" and C = "constructor" are constructed.  From this, we create a function $ that does alert("QUESTIONNAIRE"["toLowerCase"]()) and invoke it 36 times.
T=!![]+[]
F=![]+[]
O={}+[]
R=T[1]+T[3]+T[0]+T[2]+T[1]+(0[[]]+[])[1]
C=O[5]+O[1]+(0[[]]+[])[1]+F[3]+T[0]+T[1]+T[2]+O[5]+T[0]+O[1]+T[1]
$=0[C][C](_[F[1]+F[2]+T[3]+T[1]+T[0]]+'("QUESTIONNAIRE"[T[0]+O[1]+"L"+O[1]+"w"+T[3]+T[1]+"C"+F[1]+F[3]+F[4]]())')
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()

Neat! good job.

Perl 6 (33 chars)
EVAL "SAY 'QUESTIONNAIRE'x 35".lc

13 chars * 35 repetitions = 455 chars total output
+ == 700 points; (3..37).elems = 35 repetitions.

How come EVAL works? Is it defined both in uppercase and lowercase (if so, why?!) or are function names case-insensitive in Perl 6?

@FireFly eval has been deprecated for EVAL not so long ago, to make it stand out you're doing special stuff I guess. Sorta like BEGIN, TOP, ... The change just happens to suit me here :)

I guess that makes sense, it just seemed kinda weird. I guess you got lucky. :P

JavaScript (88342)
http://pastebin.com/6UNTNXeT
alerts Mutüal 3xcLUs1ve_Equino>< once + unubiquitous 12 times
Score: 706

You didn't even make an attempt at golfing. None of $_=; are present in your output, so why not use them in the code?

Because JSfuck outputs only those 6 characters. Also, I don't think we can do better with JavaScript, because to output we can use alert(), console.log(), document.write() or element.innerHTML, and these functions contain letters that are too present in the required words.

alert == this["alert"] == Function("return this")["alert"] == ""["constructor"]["constructor"]("return this")["alert"], and the strings could be encoded similarly to how JSfuck works.  I'll post a submission to prove you wrong. :-)

C64 BASIC, 64 PETSCII chars

Should output 13 times the string "questionnaireunubiquitousequilibrium", with a score of:
equilibrium = 29+28+27+26+25+24+23+22+21+20+19+18+17=299
unubiquitous = 31+30+29+28+27+26+25+24+23+22+21+20+19=325
questionnaire = 37+36+35+34+33+32+31+30+29+28+27+26+25=403
1027.
(output is 481 chars long)


text:
Fibonacci is so QUINE!

Your program must output atleast half of its sourcecode in reverse. Any single part of the sourcecode as long as it is one single block of neighbouring characters.
Your program should not take any input (from user, filename, network or anything).
The output has some additional constraints. The character position (first character is #1) on the output is either a fibonacci-sequence number (1, 1, 2, 3, 5, 8, 13, 21, ...) or not (4, 6, 7, 9, 10, 11, 12, ...), and this is the constraints:

3.1 Every third fibonacci-sequence number output position must be a letter (a-z|A-Z). Starting at fibonacci-sequence number #2 (output char|byte pos: 1, 5, 21, ...).
3.2 Every third fibonacci-sequence number output position must be a number (0-9). Starting at fibonacci-sequence number #3 (output char|byte pos: 2, 8, 34, ...).
3.3 Every third fibonacci-sequence number output position must be a symbol !(0-9|a-z|A-Z). Starting at fibonacci-sequence number #4 (output char|byte pos: 3, 13, 55, ...).

The output must contain exactly all of these three phrases in any place as long as the other rules is not broken (case sensitive): Fibonacci is so QUINE!, 3 is more than {4}, {'{"\}

This is code-golf, shortest sourcecode in bytes wins! Good luck, have fun!

Befunge '98, 91 characters
Was formerly 104, then 101. Saved another 10 chars by moving the "Fi...E!" sentence to output position 89 using 'E' (instead of ' ' at 55), and moving the actual code into the space this opened up, with a slightly improved print loop.
"!ENIUQ os si iccanobiF"f6*>:;#-1,g0;#:_ "}\"f:4++"{'{",,0$,,,,@"}4{ naht erom si 30" b >0a

produces the following output (fibonacci positions marked):
a0> b "03 is more than {4}"@,,,,$0,,"{'{"++4:f"\}" _:#;0g,1-#;:>*6f"Fibonacci is so QUINE!{'{"\}
--- -  -    -       -            -                    -                                 -
|   |               |                                                                   |
 |     |                         |
  |         |                                         |

This snippet outputs all of itself, except for the first character, in reverse order. Then it appends {'{"\} to the output, yielding a total of 96 chars including 98.9% of the code.

Positions 1, 5, 21 and 89 are each occupied by 'a', 'b' or 'E'.
Positions 2, 8 and 34 each have a '0'.
In positions 3, 13 and 55, we find '>', ' ' and ';', all symbols according to the definition given by Plarsen.

There are 3 completely unused cells, and all of b >0a is utterly useless code, only there for the aesthetics of a0> b  0. There may (still) be room for optimization.
Since String mode means pushing a reverse string to the stack and then pop/print-ing it forward, writing them in reverse order is totally natural in Befunge.
Breakdown

f6* calculates 90, the index of the last character in the source. It's 15 * 6.
>: means 'head east and duplicate the top of stack value'. Stack [ ... 90 90 ].
;...; skips over the code in between.
#:_ skips the :, then pops TOS and heads back west if not 0. Stack [ ... 'F' 90].
Now RTL: ,g0;#: duplicates TOS, skips entry to the ; portal, gets the character at (TOS, 0) and prints it.
Still RTL: :;#-1 decrements TOS, skips ; and duplicates TOS. Execution continues at step 2.) Stack [ ... 89 89 ]
Once the TOS counter is down to 0, _ lets us through.
We push the third required string , whereby we have to calculate the '"' because there is no escaping in Befunge. f:4++ is 15 + 15 + 4. The commas write it back out from the stack. I had to insert 0$ there (push 0 then pop/discard) to meet the requirement.
@ terminates.

source: Stack Exchange

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

sort: votes


text:
Alphanumeric recursive meeting
This challenge is about finding the perfect match between your program sourcecode and the output from your program.
Scoring table for the output:
   Each letters (a-z|A-Z) :
        `a` or `A`   1 points
        `b` or `B`   2 points
                  ...
        `z` or `Z`  26 points

Scoring for the sourcecode:
   Each non-alphanumeric !(a-z|A-Z|0-9) :
         3 points

Total score:
     Sourcecode-score * Output-score

Rules:

Your program should take no input (from user, filename, network or anything).
Sourcecode can be maximum 256 bytes|chars, Output can be maximum 384 bytes|chars
Your programs output should include its own total score encapsulated within [], for example: [1024].
No two neighbouring characters in output or sourcecode can be equal. That also impact the total score variation as it should be part of the output.
Constraint, for each output character (=current char):
    The calculated sum of the char-distance to neighbour output char is called: char-dist. Non-alpha neighbours always adds 2 to char-dist.
    The output characters at char-dist pos before the current char cannot be equal to the current char.
    Calculating char-dist is not case sensitive, so the char-dist between A and F is: 5, and the char-dist between A and f is also: 5.

Clarification for rule 5 by example:
If this 3 characters is part of the output: yZX then the char-dist for Z is (1+2)=3. That means 3 character pos before that Z there cannot be another Z or z in the output. Positions does not wrap around edges of the output.
Example non-valid output-part:
XYZYXW - here the calculated char-dist for the second Y from left is: (1+1)=2, and therefor the first Y from left cannot be two char pos before.
Example valid output-part:
XYZYWX - here the calculated char-dist for the second Y from left is: (1+2)=3 => the first Y from left is 2 positions away = valid.
Example valid answers:
I think I should sum this challenge up by giving some simple example valid answers:
Javascript (code: 34, output: 18) - Total score: (24*246)=5904
Sourcecode:    console.log("OPQRSTUVWXYZ[5904]");
Output:        OPQRSTUVWXYZ[5904]

Golfscript (code: 32, output: 32) - Total score: (39*491)=19149
Sourcecode:    '[19149]' 2{'NPQRSTUVWXYZ'}* 'A'
Output:        [19149]NPQRSTUVWXYZNPQRSTUVWXYZA

This is code-challenge, best total score wins! Good luck, have fun!

Do whitespaces count 3 towards my sourcecode scoring?

Yes, whitespace counts as non-alphanumeric => 3 points each

Rule 4 was meant to be case insensitive, for example: Zz or Aa is not allowed in sourecode or output

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


text:
Lifetime of a Worm
Terms
A worm is any list of nonnegative integers, and its rightmost (i.e., last) element is called the head. If the head is not 0, the worm has an active segment consisting of the longest contiguous block of elements that includes the head and has all of its elements at least as large as the head. The reduced active segment is the active segment with the head decremented by 1.  For example, the worm 3 1 2 3 2 has active segment 2 3 2, and the reduced active segment is 2 3 1.
Rules of evolution
A worm evolves step-by-step as follows:

In step t (= 1, 2, 3, ...),     if
  the head is 0: delete the head
      else: replace the active segment by t+1
  concatenated copies of the reduced active segment.

Fact: Any worm eventually evolves into the empty list, and the number of steps to do so is the worm's lifetime.
(Details can be found in The Worm Principle, a paper by L. D. Beklemishev. The usage of "list" to mean a finite sequence, and "head" to mean its last element, is taken from this paper -- it should not be confused with the common usage for lists as an abstract data type, where head usually means the first element.)
Examples (active segment in parentheses)
Worm: 0,1
step    worm
         0(1)
1        0 0 0
2        0 0
3        0
4           <- lifetime = 4

Worm: 1,0
step    worm
         1 0
1       (1)
2        0 0 0
3        0 0
4        0
5           <- lifetime = 5

Worm: 1,1
step    worm
        (1 1)
1        1 0 1 0
2        1 0(1)
3        1 0 0 0 0 0
4        1 0 0 0 0
5        1 0 0 0
...
8       (1)
9        0 0 0 0 0 0 0 0 0 0
10       0 0 0 0 0 0 0 0 0
...
18       0
19           <- lifetime = 19

Worm: 2
step    worm
        (2)
1       (1 1)
2        1 0 1 0 1 0
3        1 0 1 0(1)
4        1 0 1 0 0 0 0 0 0
5        1 0 1 0 0 0 0 0
6        1 0 1 0 0 0 0
...
10       1 0(1)
11       1 0 0 0 0 0 0 0 0 0 0 0 0 0
12       1 0 0 0 0 0 0 0 0 0 0 0 0
...
24      (1)
25       0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
...
50       0
51          <- lifetime = 51

Worm: 2,1
        (2 1)
1        2 0 2 0
2        2 0(2)
3        2 0(1 1 1 1)
4        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0
5        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0(1 1 1)
6        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0
7        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0(1 1)
8        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0{1 0}^9
...
??          <- lifetime = ??

Worm: 3
step    worm
        (3)
1       (2 2)
2       (2 1 2 1 2 1)
3        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0
4        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1(2)
5        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0(2 1 2 1 1 1 1 1 1 1)
6        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^7
7        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^6 (2 1 2 1 1 1 1 1 1)
...      ...
??          <- lifetime = ??

Aside
Worm lifetimes are typically enormous, as shown by the following lower bounds in terms of the standard fast-growing hierarchy of functions fα:
worm                lower bound on lifetime
----------------    ------------------------------------------
11..10 (k 1s)       f_k(2)
2                   f_ω(2)
211..1 (k 1s)       f_(ω+k)(2)
2121..212 (k 2s)    f_(ωk)(2)
22..2 (k 2s)        f_(ω^k)(2)
3                   f_(ω^ω)(2)
...
n                   f_(ω^ω^..^ω)(2) (n-1 ωs)  >  f_(ε_0) (n-1)

Remarkably, worm [3] already has a lifetime that far surpasses Graham's number, G:
fωω(2) = fω2(2) = fω2(2) = fω+2(2) = fω+1(fω+1(2)) >> fω+1(64) > G.

Code Golf Challenge

Write the shortest possible function subprogram with the following
  behavior:
Input: Any worm.
Output: The lifetime of the worm.
Code size is measured in bytes.

Here's an example (Python, golfs to about 167 bytes):
from itertools import *
def T(w):
    w=w[::-1]
    t=0
    while w:
        t+=1
        if w[0]:a=list(takewhile(lambda e:e>=w[0],w));a[0]-=1;w=a*(t+1)+w[len(a):]
        else:w=w[1:]
    return t

NB:
If t(n) is the lifetime of the worm [n], then the rate of growth of t(n) is roughly that of the Goodstein function. So if this can be golfed to below 100 bytes, it could well give a winning answer to the Largest Number Printable question. (For that answer, the growth-rate could be vastly accelerated by always starting the step-counter at n -- the same value as the worm [n] -- instead of starting it at 0.)

I am confused by your code. You said the head is the rightmost element, but in your Python example, you treat the head as a w[0] which is the *leftmost element of that list?

@LegoStormtroopr If you can consider a list as having a left and right. If you just consider a first and last, you could map the rightmost to first or last when reading the initial string - which isn't part of the question. But the function inputs weren't strictly defined either.

@LegoStormtroopr - Good catch; I corrected the code by adding a line to reverse the input worm, whose head is indeed supposed to be on the right (i.e. the last element in the list w). It's for efficiency that the program operates on the reversed worm.

Getting the correct answer for 2 1 might be too much to ask in a reasonable time, but a useful test is that the sequence should start (2 1), 2 0 2 0, 2 0 (2), 2 0 (1 1 1 1), ...

@PeterTaylor - Yes, worm [2,1] (like [3]) is a good example to illustrate some "nontrivial" active segments in the first few steps. I'll add it to the question.

Update: getting the correct answer for 2 1 is definitely too much to ask for a program optimised for size rather than running time. After 7532...(1999 digits skipped)...1468 steps (approx 2^6666) it reduces to 2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 and there's still a long way to go.

@PeterTaylor - I can show that an "intermediate" worm [2 0] at step-number t will die sometime after step-number 2↑↑...↑(t+3), where there are t+2 Knuth uparrows. Since [2 0 2 0] appears at step-number 1, the lifetime of worm [2 1] will be greater than 2↑↑...↑(s+3), where there are s+2 uparrows, and s = 2↑↑↑(1+3)=2↑↑65536 (an exponential tower of 65536 2s).

We overlapped: I get ~ A(A(5,4), A(5,4)), which in Knuth's notation would be ~ 2↑^(2↑↑↑7) (2↑↑↑7).

I'm sorry, this whole 'head' thing is somewhat confusing. In programming, the first element of a list is called the head, but it appears you are switching this around, and calling the last element (traditionally termed the 'tail') the head. It is also not clear what exactly you mean by "the head together with all contiguous elements that are at least as large as the head". Do you mean worm[0:first_position_lt_head], or worm[first_position_ge_head:first_position_lt_head_after_ge_head], or something else?

@AJMansfield - If the worm is x_0,...,x_n, then the head is here defined to be x_n. When the head is not 0, the active segment is defined to be longest contiguous block of elements that includes the head and has all of its elements at least as large as the head. (I.e., the active segment is the longest possible "suffix" with all elements at least as large as x_n.) These definitions are tailored to fit those in the linked technical paper pp.2-3 (see the example on p.3.)

"So if this can be golfed to below 100 bytes, it could well give a winning answer to the Largest Number Printable question." Well, I took up the challenge of beating your lifetime of a worm in Ruby, and I recently managed to do just that! :-)

How big is worm([3]) compared to say, TREE(3)? If it isn't larger, would an input to worm() be feasible to make it larger?

Additionally, are we allowed to take the worms in reverse?

Pls add examples for 0,1 and 1,0

@ThePlasmaRailgun no.

@ThePlasmaRailgun - To paraphrase Harvey Friedman, numbers derived from functions at level ε_0 in the fast-growing hierarchy (such as worm-lifetimes) are completely UNNOTICEABLE in comparison to TREE(3).

Ah, thank you! This is because of the massive difference in the amount of recursion, correct?

GolfScript (56 54 chars)
{-1%0\{\)\.0={.0+.({<}+??\((\+.@<2$*\+}{(;}if.}do;}:L;

Online demo
I think that the key trick here is probably keeping the worm in reverse order. That means that it's pretty compact to find the length of the active segment: .0+.({<}+?? (where the 0 is added as a guard to ensure that we find an element smaller than the head).

As an aside, some analysis of the worm lifespan. I'll denote the worm as age, head tail (i.e. in reverse order from the question's notation) using exponents to indicate repetition in the head and tail: e.g. 2^3 is 2 2 2.
Lemma: for any active segment xs, there is a function f_xs such that age, xs 0 tail transforms into f_xs(age), tail.
Proof: no active segment can ever contain a 0, so the age by the time we delete everything before the tail is independent of the tail and is hence a function only of xs.
Lemma: for any active segment xs, the worm age, xs dies at age f_xs(age) - 1.
Proof: by the previous lemma, age, xs 0 transforms into f_xs(age), []. The final step is deletion of that 0, which is not touched previously because it can never form part of an active segment.
With those two lemmata, we can study some simple active segments.
For n > 0,
age, 1^n 0 xs -> age+1, (0 1^{n-1})^{age+1} 0 xs
              == age+1, 0 (1^{n-1} 0)^{age+1} xs
              -> age+2, (1^{n-1} 0)^{age+1} xs
              -> f_{1^{n-1}}^{age+1}(age+2), xs

so f_{1^n} = x -> f_{1^{n-1}}^{x+1}(x+2) (with base case f_{[]} = x -> x+1, or if you prefer f_{1} = x -> 2x+3). We see that f_{1^n}(x) ~ A(n+1, x) where A is the Ackermann–Péter function.
age, 2 0 xs -> age+1, 1^{age+1} 0 xs
            -> f_{1^{age+1}}(age+1)

That's enough to get a handle on 1 2 (2 1 in the notation of the question):
1, 1 2 -> 2, 0 2 0 2
       -> 3, 2 0 2
       -> f_{1^4}(4), 2
       -> f_{1^{f_{1^4}(4)+1}}(f_{1^4}(4)+1) - 1, []

So given input 2 1 we expect output ~ A(A(5,4), A(5,4)).
1, 3 -> 2, 2 2
     -> 3, 1 2 1 2 1 2
     -> 4, 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> 5, 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> f_{21212}^4(5) - 1

age, 2 1 2 1 2 -> age+1, (1 1 2 1 2)^{age+1}
               -> age+2, 0 1 2 1 2 (1 1 2 1 2)^age
               -> age+3, 1 2 1 2 (1 1 2 1 2)^age

and I can really start to comprehend why this function grows so insanely.

Very cool. I think this program will also give a winning answer to the Shortest terminating program whose output size exceeds Graham's number. (The current winner there is 63 bytes of Haskell code.) E.g., at 55 bytes, something like (since I'm prone to syntax errors) 9{-1%0\{\)\.0={.0+.({<}+??\((\+.@<2$*\+}{(;}if.}do;}:L~ computes the lifetime of worm [9], which far exceeds Graham's number -- and can be golfed further.

GolfScript, 69 62 characters
{0:?~%{(.{[(]{:^0=2$0+0=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:C;

The function C expects the worm on the stack and replaces it by the result.
Examples:
> [1 1]
19

> [2]
51

> [1 1 0]
51

Fantastic! Surely you can modify this a bit to also give a definite winner for the "Largest Number Printable" question.

I didn't see you post anything over there, so I went ahead and posted a modification of this code as what I believe to be the winning answer there so far -- assuming that the * and ^ are not being used as the arithmetic operators of multiply and exponentiate. Certainly, if you want to submit your own (doubtlessly superior) answer there, I will happily remove mine.

Ruby — 131 characters
I know this can't compete with the GolfScript solutions above and I'm fairly sure that this can be reduced a score or more characters, but honestly I'm happy to have been able to solve the problem ungolfed. Great puzzle!
f=->w{t=0;w.reverse!;until w==[];t+=1;if w[0]<1;w.shift;else;h=w.take_while{|x|x>=w[0]};h[0]-=1;w.shift h.size;w=h*t+h+w;end;end;t}

My pre-golfed solution from which the above is derived:
def life_time(worm)
  step = 0
  worm.reverse!
  until worm.empty?
    step += 1
    if worm.first == 0
      worm.shift
    else
      head = worm.take_while{ |x| x >= worm.first }
      head[0] -= 1
      worm.shift(head.size)
      worm = head * (step + 1) + worm
    end
  end
  step
end

Generic tip: many golf problems work on non-negative integers, in which case if foo==0 can be trimmed to if foo<1. That can save you one char here.

Incidentally, I find it fascinating that this works without a second reverse.

Ah, it doesn't. It just works on the test cases because they only have palindromic active segments.

Thanks for the golf tip, @PeterTaylor. Also, good catch on the missing second reverse. I've added it in. I'll try to rewrite this another way without using reverse later. I'm pretty sure I can get the else clause down to one line and then swap the if..else..end for a ternary statement. I could also use a lambda to save a few characters, I think.

Sclipting (43 characters)
글坼가⑴감套擘終長①加⒈丟倘⓶增⓶가采⓶擘❷小終⓷丟❶長貶❷가掊貶插①增復合감不가終終

This expects the input as a space-separated list. This outputs the correct answer for 1 1 and 2, but for 2 1 or 3 it takes too long so I gave up waiting for it to finish.
With commentary:
글坼 | split at spaces
가⑴ | iteration count = 0

감套 | while:
  擘終長①加⒈丟 | remove zeros from end and add to iteration count
  倘 | if the list is not empty:
    ⓶增⓶ | increment iteration count
    가采⓶擘❷小終⓷丟 | separate out active segment
    ❶長貶❷가掊貶插 | compute reduced active segment
    ①增復合 | repeat reduced active segment and concat
    감 | continue while loop
  不 | else
    가 | stop while loop
  終 | end if
終 | end while

A link to an interpreter would be handy... Also, 86 bytes, using UTF-16?

@PeterTaylor: Thanks, added the link to the interpreter to the article. And yes, 43 BMP characters do translate to 86 bytes in UTF-16.

k (83)
worm:{-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;|,/x)}
this can probably be golfed further, as it just implements the recurrence fairly straightforwardly.
the basic evolution function, {x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}, is 65 chars, and uses some tricks to stop incrementing the age when the worm dies. the wrapper coerces an input of a single integer to a list, reverses the input (it's shorter to write the recurrence in terms of a worm reversed from your notation), asks for the fixpoint, selects the age as the output, and adjusts the result to account for the overshoot in the last generation.
if i do the coercion and reversal manually, it drops to 80 ({-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;x)}).
some examples:
  worm 1 1 0
51
  worm 2
51
  worm 1 1
19

unfortunately, it's probably not much use for Largest Number Printable, except in a very theoretical sense, as it's quite slow, limited to 64-bit integers, and probably not particularly memory-efficient.
in particular, worm 2 1 and worm 3 just churn (and would probably throw 'wsfull (out of memory) if i let them keep going).

I've tried to run your program with this online interpreter, but it doesn't show any output. (Submitting a text file with extension .k is supposed to invoke the K interpreter.) Do you know what might be done to send the output to stdout?

It looks like that's running kona, an open-source clone of k3. My code is written in k4, and is unlikely to be compatible with k3. You can get a time-limited free copy of q/k4 at http://kx.com/software-download.php; once you have that, start the REPL, type \ to switch from q to k, and paste my code in. Alternatively, you can save my code in a file with a .k extension and load it into the interpreter.

APL (Dyalog Unicode), 52 bytesSBCS
Saved 7 bytes thanks to @ngn and @Adám.
0{⍬≡⍵:⍺⋄n←⍺+1⋄0=⊃⍵:n∇1↓⍵⋄n∇∊(⊂1n/-∘1@1¨)@1⊆∘⍵⍳⍨⌊\⍵}⌽

Try it online!
Explanation:
0{...}⌽    ⍝ A monadic function train. We define a recursive function with two
           ⍝ arguments: zero (our counter), and the reverse of our input
⍬≡⍵:⍺      ⍝ Our base case - if our input is an empty list, return our counter
n←⍺+1      ⍝ Define 'n' as our counter plus 1
0=⊃⍵:n∇1↓⍵ ⍝ If the first element of the input is zero, recurse with the tail
           ⍝ of our input and n
⌊\⍵        ⍝ Minimum-expand: creates a new list from our input where each element
           ⍝ is the incremental minimum
⍳⍨         ⍝ Applies above to both sides of the index-of function. Index-of returns
           ⍝ the index of the first occurence of each element in the left-side list.
           ⍝ At this point, a (reversed) input list of [3 4 5 2 3 4] would result
           ⍝ in [1 1 1 4 4 4]
⊆∘⍵        ⍝ Partition, composed with our input. Partition creates sublists of the
           ⍝ right input whenever the integer list in the left input increases.
           ⍝ This means we now have a list of sub-lists, with the first element
           ⍝ being the worm's active segment.
(...)@1    ⍝ Take the active segment and apply the following function train...
-∘1@1¨     ⍝ Subtract 1 from the first element of the active segment
1n/        ⍝ Replicate the resultant list above n+1 times
⊂          ⍝ Enclose the above, so as to keep the original shape of our sub-array
∊          ⍝ Enlist everything above together - this recursively concatenates our
           ⍝ new active segment with the remainder of the list
n∇         ⍝ Recurse with the above and n

I figured APL would have a really clean solution for this, isn't it an array-based language?

Scala, 198
type A=List[Int]
def T(w:A)={def s(i:Int,l:A):Stream[A]=l match{case f::r=>l#::s(i+1,if(f<1)r
else{val(h,t)=l.span(_>=l(0));List.fill(i)(h(0)-1::h.tail).flatten++t})
case _=>Stream()};s(2,w).length}

Usage:
scala> T(List(2))
res0: Int = 51

K, 95
{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}

.
k)worm:{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}
k)worm 2
51
k)worm 1 1
19
q)worm 1 1 0 0 0 0
635

C (gcc), 396 bytes
#define K malloc(8)
typedef*n;E(n e,n o){n s=K,t=s;for(*s=*o;o=o[1];*t=*o)t=t[1]=K;t[1]=e;e=s;}main(c,f,l,j,a)n*f;{n w=K,x=w;for(;l=--c;x=x[1]=K)*x=atoi(f[c]);for(;w&&++l;)if(*w){n v=K,z=v,u=w,t=K;for(a=*v=*w;(u=u[1])&&*u>=*w;*z=*u)z=z[1]=K;for(x=v[1],v=K,*v=a-1,1[u=v]=x;u;u=u[1])w=w[1];for(j=~l;j++;)u=t=E(t,v);for(;(u=u[1])&&(x=u[1])&&x[1];);u[1]=0;w=w?E(w,t):t;}else w=w[1];printf("%d",--l);}

Try it online!
I know I'm EXTREMELY late to the party, but I thought I'd try my hand at this in C, which required a linked-list implementation. It's not really golfed at all besides changing all the identifiers to single characters, but it functions!
All in all, I'm pretty happy considering this is the 3rd C/C++ program I've ever wrote.

Do you really need a linked list? Why not just allocate arrays? Since this is code golf, you don't even need to bother freeing them when you're done. You might even be able to find a way to store them on the call stack (not sure).

Also, you don't need a main function. Just write a function that takes the worm as an argument and returns its lifespan. The worm can be an array and its length, or maybe an array ending in a negative number.

Haskell, 84 bytes
(0!).reverse
n!(x:y)|x<1=(n+1)!y|(a,b)<-span(>=x)y=(n+1)!(([-1..n]*>x-1:a)++b)
n!_=n

Try it online!
Thanks to @xnor for two bytes.
I feel like there should be a good way to factor out the common increment, but I haven't found a short one yet.

Two small golfs: check the empty list case second, and shift n down by 1.

I also think there should be a way to not write (n+1)! twice, but my attempt only tied.

Pyt, 206 bytes
ĐƩ?ŕ:ŕ0;áƑ0`⇹ĐŁ⁻?ŕ:ŕÁ⇹⁺Đ↔⁻⇹⁺⑴*;⇹⁺⁺⇹Đ1~⦋¬?ŕ⁺ĐŁĐř≠*ž⁻:ŕĐ1~⦋⇹Đ⁺ĐŁĐř≠*ž⁻Đ04Ș06Ș+<ĐŁř*↑Đ¬?ŕŕŕĐŁĐř=-0↔Đ3Ș+↔+⇹⑴⇹ɐ*Ƒ:ŕ⑴*ĐŁ3Ș⁺⇹ĐŁ⇹04ȘĐŁř⇹04Ș>*ž⁻ĐŁĐř=-+0↔+⇹ŕ+Đ4Ș⇹04Ș⑴⇹ɐ*Ƒ0↔++↔+áƑĐ0⦋⇹⁺ĐŁř1≠*ž⁻;ĐƩ¬?ŕŁ+0:ŕ⇹⁻;łŕ⁻⁻⁻?⁺⁺:⁺;

Try it online!
Takes input as an array.

Code
Pseudocode

ĐƩ?ŕ:ŕ0;áƑ
If sum of w (worm parts) is 0, add another zero to avoid breaking the function (kludge)

ĐƩ?ŕ:ŕ1~;
if all zeroes, ctr=-1, otherwise ctr=0 (kludge)

`
do...

⇹ĐŁ⁻?ŕ
if len(w)!=1, do nothing

:ŕÁ⇹⁺Đ↔⁻⇹⁺⑴*
otherwise, decrement w[0] and push 2 copies

;⇹⁺⁺⇹
ctr+=2

Đ1~⦋¬?
if w[-1]=0:

ŕ⁺ĐŁĐř≠*ž⁻
     remove the head

:ŕ
otherwise:

Đ1~⦋⇹
     q=w[-1]-1

Đ⁺ĐŁĐř≠*ž⁻
     x=w[:-1]

Đ04Ș06Ș+<ĐŁř*
     h=[x_i*(x_i>q) for i in range(len(x))]

↑
     k=max(h)

Đ¬?ŕŕŕ
     if k=0

ĐŁĐř=-
          decrement the head

0↔Đ3Ș+↔+⇹⑴⇹ɐ*Ƒ
          concatenate the head ctr times

:ŕ
     otherwise

⑴*ĐŁ3Ș⁺⇹ĐŁ⇹04ȘĐŁř⇹04Ș>*ž⁻ĐŁĐř=-+
          g=w[:k]; b=[w_i-(i=len(w)-1) for i in [k...len(w)-1]]

0↔+⇹ŕ+Đ4Ș⇹04Ș⑴⇹ɐ*Ƒ
          concatenate the reduced head (b) ctr times

0↔++↔+
          clean up the stack

áƑĐ0⦋⇹⁺ĐŁř1≠*ž⁻
          assemble the new worm

;ĐƩ¬?ŕŁ+0:ŕ⇹⁻;
     if worm is not dead, decrement the counter

ł
... while the worm is not dead

ŕ⁻
decrement ctr and implicitly print

Perl 5 -pa, 92 bytes
while(@F){++$\;my@a;if($b=pop@F){unshift@a,pop@F while$F[-1]>=$b;push@F,(@a,--$b)x($\+1)}}}{

Try it online!

Stax, 31 bytes
àîz7αan♣óàNµK2☻₧⌡▐`Γl½f{♂♂_KZÖÄ

Run and debug it

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


text:
Hello, new world! again
Objective:

This code-golf is about creating 2 different sourcecodes that both outputs exactly: Hello, new world! again. without linefeed, and when combining the two sourcecodes into one sourcecode it should still output exactly: Hello, new world! again.

Rules:

Your programs should take no input (from user, filename, network or anything).
You can choose any combination of programming languages, from one language for all three sourcecodes to three different languages.
The combination of the two sourcecodes to create the third is done by putting alternating characters from both from start to end and fill up the third sourcecode from start to end.
You must choose 10 different characters that both sourcecodes may use (case sensitive). All other characters is mutual exclusive between the two sourcecodes. Characters may be re-used without restriction. Exactly all 10 characters choosen must be used in both sourcecodes atleast once.

Clarification example on sourcecode combination:
Javascript          sourcecode: console.log("Hello, new world! again.");
GolfScript          sourcecode: 'Hello, new world! again.'
Combined (unknown?) sourcecode: c'oHneslolloe,. lnoegw( "wHoerllldo!,  angeawi nw.o'rld! again.");

The above example does however violate rule #4 as more than 10 characters is "shared" in both sourcecodes. And the combined sourcecode does not output: Hello, new world! again.
Be sure to declare what programming languages is used (all three) and what 10 characters that is allowed in both sourcecodes.
This is code-golf, least bytes in combined sourcecode wins! Good luck, have fun!

Are also symbols like ,.:( or the whitespace counted in the 10 common characters, or only letters?

The constraint is for All characters, including symbols. No more than total 10 characters (or symbols) can be common

Just to be 100% sure, also the whitespace?

Yes, that is correct! whitespace too.

The currently accepted answer does not comply with the without linefeed requirement.

Python + dc (160,141,137,116 81+27=108)
program1: (python)
'yyyyyyyyyyyyyyyyyyyyyyyyyy';exec'PRINT\'%sELLO, NEW WORLD! AGAIN.\''.lower()%'H'

program2: (dc)
[Hello, new world! again.]p

combined: (python)
'[yHyeylylyoy,y ynyeywy ywyoyrylydy!y yaygyayiyny.y]yp';exec'PRINT\'%sELLO, NEW WORLD! AGAIN.\''.lower()%'H'

Common characters (including space): ! ,.elorwH
The parts program1 and program2 are quite simple to understand, where the first has some case switches to reduce the common characters.
As program1 starts with a quotation ', in the combined code all the gibberish walks into a long string, becoming irrelevant for the interpreter. The string 'yy...y' is of the same length as program2, so after its closing ' the relevant code of program1 is appended to the combined program.

C99 + sh + C11, 165 162 146 145 combined chars
Edit: using @flonk's trick I managed to put the "comment" in C (making use of C11's u"" Unicode literals).
Common characters are: acehinortu.
hello.c (106):
*a="\2+++++++++++++++++++++++++++++++++";i;main(){for(;i<24;)putchar("Lipps0$ri{${svph%$ekemr2"[i++]+~3);}

hello.sh (39):
true
echo -n 'Hello, new world! again.'

hello-combined.c (145):
*tar=u"e\
2e+c+h+o+ +-+n+ +'+H+e+l+l+o+,+ +n+e+w+ +w+o+r+l+d+!+ +a+g+a+i+n+.+'";i;main(){for(;i<24;)putchar("Lipps0$ri{${svph%$ekemr2"[i++]+~3);}

Here are some utilities that might prove useful for other participants.
combine.c:
#include <stdio.h>
int main(int argc, char *argv[]) {
  FILE *f1 = fopen(argv[1], "r"), *f2 = fopen(argv[2], "r");
  while (!feof(f1) || !feof(f2)) {
    int c1 = fgetc(f1), c2 = fgetc(f2);
    if (c1 != EOF) putchar(c1);
    if (c2 != EOF) putchar(c2);
  }
  return 0;
}

char-check.{ba,z}sh:
comm -12 <(grep -o . "$1" | sort | uniq) \
         <(grep -o . "$2" | sort | uniq) | tr -d '\n'

Here's a variation that unfortunately ended up (considerably) longer, but it's pretty cool in how it works.  (I didn't bother getting the intersection between the sets of characters down to 10, since it ended up longer anyway.)
hello.c (113):
*a="\5Lipps0$ri{${svph%$ekemr2+++++++++++",*b=&a,c=6;i;main(){char*p=*b;for(i=c/8;p[i]-50;)putchar(p[i+=c/4]-4);}

hello.sh (51):
true
echo -n 'Hello, new world! again.' #     tr  1

hello-combined.c (164):
*tar=u"e\
5eLcihpop s-0n$ r'iH{e$l{lsov,p hn%e$we kweomrrl2d+!+ +a+g+a+i+n+.+'+ +#" , * b = &tar, c =16;i;main(){char*p=*b;for(i=c/8;p[i]-50;)putchar(p[i+=c/4]-4);}

This one is fun, because it doesn't just "comment out" a bunch of characters, but actually stores the characters it prints inside the string literal and accounts for the extra characters in the for-loop of the generated program.

+1 nice first! I would however do it the other way round, re-using the "longer" sourcecode and brick the shorter code into the sidelines dating the comments ;P That way you can shorten the long comment-row, I think... not sure.

@Plarsen well, it doesn't work that well with C since its comment marker is two characters... hmm, but I might be able to switch it around so the sh version is the one with the character translation. I'm just worrying about the 10-shared-characters rule...

Yeah, that is true it may introduce some additional obstacles. worth investigating though

Brainfuck + C (196+77)
Not a very golfy answer, but I just think it is fun
Brainfuck:
++++++++++[>+++++++>++++>++++++++++>+++<<<<-]>++.>>+.+++++++..+++.<++++.>>++.<-.---------.++++++++++++++++++.>.<.--------.+++.------.--------.>+.-.<---.++++++.------.++++++++.+++++.<++.printfHelo

C
main(){printf("Hello");putchar(44);printf(" new world! again");putchar(46);}

Combined (Also in brainfuck):
+m+a+i+n+(+)+{+p+r+i[n>t+f+(+"+H+e+l+l>o+"+)+;+p>u+t+c+h+a+r+(+4+4+)+;>p+r+i+n<t<f<(<"- ]n>e+w+ .w>o>r+l.d+!+ +a+g+a+i+n.".)+;+p+u.t<c+h+a+r+(.4>6>)+;+}.
<-.---------.++++++++++++++++++.>.<.--------.+++.------.--------.>+.-.<---.++++++.------.++++++++.+++++.<++.printfHelo

All the characters from the C code are considered as comments in brainfuck
The common characters are printfHelo, appended at the end of the brainfuck code as comments

Befunge + sh + Befunge, 111 chars
Common characters are: !,-Hehilor
hello.bef (78):
vHelo----------------------------
<v"Lipps0$ri{${svph%$ekemr2"
_>4-:,b4*2+-!#@

hello.sh (33):
echo -n Hello, new world\! again.

hello-combined.bef (111):
veHcehloo ---n- -H-e-l-l-o-,- -n-e-w- -w-o-r-l-d-\-!- -a-g-a-i-n-.
<v"Lipps0$ri{${svph%$ekemr2"
_>4-:,b4*2+-!#@


text:
Modifiable quine
For this challenge, write program A that when given no input, prints the code for A (a quine), but when given input, the output will be modified.  The input for A will be 0 or more statements in whichever language A is programmed.  The output of A will be the code for program B which runs the input to A and then does the function of A.  If the input to A ends with a comment, then B will only run the input of A.

Example:  (assume that the source is main=makeAQuine in Haskell)

input: none
output: main=makeAQuine

input: putStrLn"Hello, world!"
output: main=putStrLn"Hello, world!">>makeAQuine

input: {-
output: main=return

input: putStr"Hello, world!!"{-
output: main=putStr"Hello, world!!"

Whoever has the fewest bytes/chars wins, but you can subtract 20 from your count for each of

Comment Freindly: Accepts line-comments and block-comments
Multiline Input: Accepts more than one statement as input

Python, 83 (- Comment Bonus)
import sys;v=sys.argv
for a in v[1:]:print(a)
if v[-1].find('#')>=0:quit()
print(open(__file__).read())

If the source is ASCII and line endings are '\n', it's 103 bytes long.
There are issues that make me unsure about how many comment bonus points it would get, or if it's a complete answer at all.

it uses '#' to detect a comment in the last argument, which:

only detects line comments
detects '#' as a comment even if it's inside a string, which is wrong.

if the arguments contain an unfinished string comment (which, if triple-quoted, is as close as it gets to a block comment), running B indeed will only execute A's input, but then finish with a SyntaxError.

It does, however, accept an arbitrary number of input statements, so it gets at least 20 bonus if it is a valid answer.

Is reading the source file cheating? If so, I'm sorry and promise I won't do it again. I'm new to this...

Befunge '98, 74
There are no comments in Befunge, so I guess I can't subtract those 20. On the other hand, you can pass as many Befunge statements as you like, so I get that 20. Actual length of the code is 94.
0>:#;1+:0gff2++-#;_01-0pac+:y+>:#;1+:y#;_1->:#;1+::y:!j,#;_#;1+:y\1-\#;_0>:0#;g,1+:01-0g`!#;_@

Two things to note:

if the input contains spaces, program B will not behave correctly, because the first part of A scans east from (0,0) until it finds a space, to determine the code's length. You can pass several arguments separated by spaces, but no arguments containing spaces like "why not".
Befunge is a 2D language, but this quine only handles linear input correctly. With 2D input, B will only be able to execute A if the input ends at its last line, execution flowing east. Even then, A in B will only output the first line of B.
However, AFAIK it's not possible to pass command line arguments containing newlines?

Using one character more (and a LOT of time and memory), we can instead scan west until we wrap around and find the eastern-most non-space, which produces correct (but equally slow) B even if A gets input containing spaces:
0>:#;1-:0gff2++-!#;_01-0pac+:y+>:#;1+:y#;_1->:#;1+::y:!j,#;_#;1+:y\1-\#;_0>:0#;g,1+:01-0g`!#;_@

Explanation:

0>:#;1+:0gff2++-#;_ ensures that a 0 is on top of the stack, duplicates TOS, skips the ;, increments TOS, gets cell (TOS, 0), subtracts 32 (' ') from its content, skips the next ;, turns west if not 0 (was not a space). Heading west, it skips over :#;...; and turns back east at the >.
01-0pac+:y+ puts the determined length to cell (-1, 0), calculates 22 and executes y to get the number of stacks, adds that to the 22, resulting in the correct argument to y for obtaining the size of the top-most stack, after which  y would return the args. Using this method, B will operate correctly even if B creates more stacks before A in B executes.
>:#;1+:y#;_1- duplicates the incremented previous result (now pointing to the first char of args), gets a char using y, and repeats until that char is '\0'. This is to skip the first argument (which is the file name of the program). Finally, it decrements the counter so that the following code will find the same '\0' again.
>:#;1+::y:!j,#;_ does much the same thing as step 3.), ie. it reads one argument through y, but it prints each char of it except the delimiting '\0'.
#;1+:y\1-\#;_ checks if there follows another '\0' and in case there isn't, it decrements the counter so that the first character of each argument doesn't get truncated, and goes west, skipping over :#;...;_#;...;, back to step 4.)
0>:0#;g,1+:01-0g`!#;_@ initializes a new TOS counter to 0, then enters a loop to get cell (TOS, 0), print it, increment the counter, get cell (-1, 0) and terminate if that's less than the counter, else repeat.

JavaScript, 25
65 characters, minus 40 bonus points. Complete with abuse of escape! \o/
(_=$=>eval(prompt()+";alert(unescape('(_="+escape(_)+")()'))"))()

But for fewer characters, shell is always good.
zsh, −28
cat|zsh
<$0

This is close, but I wanted the input outputted before the quine, so that if you were to copy and run the alert, then your input would run, then the program would go.  I think you just have to move the prompt inside the alert and adjust the code.  Also, what version of JavaScript is this? I recognize that => is supposed to be a lambda function(){}, but it isn't supported in the chrome console.

@Zaq: ES6 arrow functions are supported by SpiderMonkey right now, so try a recent Firefox or js. Also, how does having the input before the rest of the quine work? Does the input not have to be evaluated? If it is, is it interspersed linewise with its output, before it, or after it?

You would output (but not run) the input before the quine part.  For instance, if I input console.log("Hello, world"), the output would be something like console.log("Hello, world");(_=$=>....  If you then ran this, and gave the input alert("Hello, again")//, your output would log "Hello, world" and look something like console.log("Hello, world");alert("Hello, again")//...

GTB, 12
`_~_+":prgmA

This compiles to :Input Str0:Disp Str0+":prgmA, right?  On my TI-84, this does not print a quine at all, it just appends prgmA to the input.  If I made the rules unclear, you are welcome to leave a comment so I can clarify.


text:
Create a chain of spam generators in as many languages as possible
The goal of a rosetta-stone challenge is to write solutions in as many languages as possible. Show off your programming multilingualism!
In this challenge, you will create a program that will generate spam messages, given an input seed-text. For example, given the input
[Thank you/Wow/Great], this [blog/post/writing] [gives/provides/delivers] [great/excellent/wonderful/superior] [content/information/data]. You [may/could] [find/get/retrieve] [similar/related] [content/information/data] at spammysite.com.

A possible output could be
Thank you, this writing delivers excellent data. You may find similar content at spammysite.com.

(idea from https://security.stackexchange.com/q/37436/29804)
There's a catch, though! You will also have to output a program in a different language. This program, when run, will also output the spam text and a program in a different language, which will also output the spam text and a program in a different language...
Your score will be character count / (number of languages ^ 2).
For example, I could have a Ruby program. It would take the input seed-text as input, and output the random spam text and a Python program.
Running this Python program (with no input), it would output another random spam text and a Perl program.
Running this Perl program (no input), it would output another random spam text.
In this example, my score would be the length of the original Ruby program divided by 9 (I have 3 languages, and 3 ^ 2 is 9).
Other miscellaneous things:

You must use at least 2 different programming languages.
Please list each program that is output. This way if someone doesn't have all of the languages, they can still see their sources. You may use this short example text: [Please/Kindly] [visit/see] my [site/blog]., or you may just use a placeholder (like {insert text here}).
You may assume that there will be no non-alphanumeric characters except []/.,, to simplify some things.
Different versions of languages do not count as different languages (ex. Python 2 == Python 3).
It must be fully random, i.e. not predictable and outputting a different combination every run. It must also be able to output every combination in an arbitrary amount of runs.
Since this is code-golf as well as rosetta-stone, the shortest overall score (charcount / (langs ^ 2)) will win.

is it okay if the distribution is not uniform, e.g if the first word gets chosen more often than the other?

@mniip Hmm, I never really specified that :-P I suppose you could do that and bend the rules if it saves characters

PHP 5.5 -> Ruby 2.0 -> Python 2.7 -> Lua -> C# -> Java -> PdfTeX -> GolfScript 855 / 8^2 = 13.359375
The main ideas were:

Instead of actually creating the logic to create the n+1th language in all programming languages do this only one time, and only use the basic random and stdout writing facilities of each programming language
To shorten the template generator, just compress it with zLib. Make this generator the second language
Use PHP as the first language, as it has built-in zLib decompressor

So the initial code is:
<?php $x=file_get_contents("php://stdin");echo preg_replace_callback("/\[(.*?)\]/",function($m){$r=explode("/",$m[1]);return $r[array_rand($r)];},$x).gzuncompress("BINARY_DATA")."__END__\n".$x;

Where BINARY_DATA is the gzcompressed version of the template generator (e.g. the result of the php code, which is the ruby version)
The complete initial code in base64 (should be 855 bytes after decoding):
PD9waHAgJHg9ZmlsZV9nZXRfY29udGVudHMoInBocDovL3N0ZGluIik7ZWNobyBw
cmVnX3JlcGxhY2VfY2FsbGJhY2soIi9cWyguKj8pXF0vIixmdW5jdGlvbigkbSl7
JHI9ZXhwbG9kZSgiLyIsJG1bMV0pO3JldHVybiAkclthcnJheV9yYW5kKCRyKV07
fSwkeCkuZ3p1bmNvbXByZXNzKCJ42o2UwXKbMBCG7zyFZj0doElV55BLiNJmmump
7aHpTA+Yg4xErA6SGCQSZ4jevZIBx3biTHywzO6y/7+fYRm5uf5zjVtOGS5XWjbY
NLWwSZzHKVx4OTa06Z/oE51iRZw6XFzV1FquXiQ/+2TEMKflKsSbViiLfFx4OTbK
puYuajpr0OUlBDmIoqrVErVUMX8I2ejWXCIvL0oejVfm0USznk0y4Fx4YWaxsUx3
Fj+0wvJkKE9mPcVCmYaX1qUpuI+wUODlgvzwjeI4XHg5NtSu8CBnOGeJNthcbsmT
NN0ToWSnHbatx1DEp3Hv/GyZ0KMyzXfaJWen4Z6aqzu7cmmRZvseknQ8c0JyT2FZ
ixKVNTUGUdRPAWOp9ce9Fgz9pEIlqc/dPhrLJf49UGqJ4g9oL1x4OTak2a79Jfl0
JXs5eiHk7AuM5d+0Mrrm+O/G/8zXVKI19hlcXAYXICqUtPgXX9sb7V15OJdzfJ72
R3uYlah2ezheG97DyTKXxQk4D1wiW+YUs64pJiRceGFm9fohFA+THM19hTd5ycDr
1nrId3mBaHtnArx/9J7izop6n99h+N0Iw4M3/JELeAlwATsIlUf4vdbUHhA8bLHP
L7R4P8FtXHhhZloNI6wJUMjeGGS0fIFgMX5EpTp5Pp9fTYGGVZ0SlW4l4/eCWn42
n8/R1qqb6oJLNLmcgpXwbtdkjU1XXHg5Ntn0RlxcvULQW17AYnsj4xWafuvG+lEc
6mf9dnD3IVQHvgjgDQxceDAwLyi8audAq3e+MR3g+O7gXHgwMJ4fxgPMR1TZ8zLc
yiDIw17YJFx4OTZPEPuBXFwMG4FiZ2GEJUJceDAw+dHiEB1cXIx1x4zAdoTlI98U
uciNR1QQ4ndQ5HdeFFZt9B9+DwFHIikuIl9fRU5EX19cbiIuJHg7

Let's go through all of the languages with the test input string [Thank you/Wow/Great], this is [awesome/wonderful].
PHP
$ cat ti2 | php a.php
Great, this is wonderful.
d=DATA.read.chomp.split('[').map{|a|a.split(']')}.flatten.map{|a|a.split('/')}
d.each{|a|print a.sample}
puts <<"DATA"

from random import choice
import sys
#{d.map{|a|"sys.stdout.write(choice(#{a.inspect}))"}*"\n"}
print
print '''math.randomseed(os.time())
#{d.map{|a|"a=#{a.inspect.tr('[]','{}')};io.write(a[math.random(1,#{a.length})]);"}*"\n"}
print()
print([==[
public class a {
public static void Main() {
System.Random r=new System.Random();
#{d.map{|a|b=->m{m.length==1?"System.Console.Write(#{m.first.inspect});":"if (r.NextDouble()<0.5){System.Console.Write(#{m.shift.inspect});}else{"+b[m]+"};"};b[a.dup]}*"\n"}
System.Console.WriteLine();
System.Console.WriteLine(@"class a {
public static void main(String[] args) {
java.util.Random r=new java.util.Random();
#{d.map{|a|b=->m{m.length==1?"System.out.print(\"#{m.first.inspect}\");":"if (r.nextFloat()<0.5){System.out.print(\"#{m.shift.inspect}\");}else{"+b[m]+"};"};b[a.dup]}*"\n"}
System.out.println();
#{x="a";d.map{|a|b=->m{m.length==1?m.first: "\\\\\\\\ifnum500>\\\\\\\\pdfuniformdeviate1000 #{m.shift}\\\\\\\\else "+b[m]+"\\\\\\\\fi"};x=x.succ;a.length>1?"System.out.println(\"\"\\\\\\\\def \\\\\\\\opt#{x} {#{b[a.dup]}}%\"\");": ""}*"\n"}
System.out.println(""#{x="a";d.map{|a|x=x.succ;a.length>1?"\\\\\\\\opt#{x}{}": a.first}*""}"");
System.out.println();
System.out.println(""#{d.map{|a|a.length>1? "[#{a.map{|b|"'#{b}'"}*""}]#{a.length}rand=" : "'#{a.first}'"}*""}"");
System.out.println(""\\\\\\\\bye"");
}
}");
}
}
]==]);
'''
DATA
__END__
[Thank you/Wow/Great], this is [awesome/wonderful].

Ruby
$ ruby a.rb
Great, this is awesome.
from random import choice
import sys
sys.stdout.write(choice(["Thank you", "Wow", "Great"]))
sys.stdout.write(choice([", this is "]))
sys.stdout.write(choice(["awesome", "wonderful"]))
sys.stdout.write(choice(["."]))
print
print '''math.randomseed(os.time())
a={"Thank you", "Wow", "Great"};io.write(a[math.random(1,3)]);
a={", this is "};io.write(a[math.random(1,1)]);
a={"awesome", "wonderful"};io.write(a[math.random(1,2)]);
a={"."};io.write(a[math.random(1,1)]);
print()
print([==[
public class a {
public static void Main() {
System.Random r=new System.Random();
if (r.NextDouble()<0.5){System.Console.Write("Thank you");}else{if (r.NextDouble()<0.5){System.Console.Write("Wow");}else{System.Console.Write("Great");};};
System.Console.Write(", this is ");
if (r.NextDouble()<0.5){System.Console.Write("awesome");}else{System.Console.Write("wonderful");};
System.Console.Write(".");
System.Console.WriteLine();
System.Console.WriteLine(@"class a {
public static void main(String[] args) {
java.util.Random r=new java.util.Random();
if (r.nextFloat()<0.5){System.out.print(""Thank you"");}else{if (r.nextFloat()<0.5){System.out.print(""Wow"");}else{System.out.print(""Great"");};};
System.out.print("", this is "");
if (r.nextFloat()<0.5){System.out.print(""awesome"");}else{System.out.print(""wonderful"");};
System.out.print(""."");
System.out.println();
System.out.println(""\\\\def \\\\optb {\\\\ifnum500>\\\\pdfuniformdeviate1000 Thank you\\\\else \\\\ifnum500>\\\\pdfuniformdeviate1000 Wow\\\\else Great\\\\fi\\\\fi}%"");

System.out.println(""\\\\def \\\\optd {\\\\ifnum500>\\\\pdfuniformdeviate1000 awesome\\\\else wonderful\\\\fi}%"");

System.out.println(""\\\\optb{}, this is \\\\optd{}."");
System.out.println();
System.out.println(""['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'"");
System.out.println(""\\\\bye"");
}
}");
}
}
]==]);
'''

Python
$ python a.py
Great, this is wonderful.
math.randomseed(os.time())
a={"Thank you", "Wow", "Great"};io.write(a[math.random(1,3)]);
a={", this is "};io.write(a[math.random(1,1)]);
a={"awesome", "wonderful"};io.write(a[math.random(1,2)]);
a={"."};io.write(a[math.random(1,1)]);
print()
print([==[
public class a {
public static void Main() {
System.Random r=new System.Random();
if (r.NextDouble()<0.5){System.Console.Write("Thank you");}else{if (r.NextDouble()<0.5){System.Console.Write("Wow");}else{System.Console.Write("Great");};};
System.Console.Write(", this is ");
if (r.NextDouble()<0.5){System.Console.Write("awesome");}else{System.Console.Write("wonderful");};
System.Console.Write(".");
System.Console.WriteLine();
System.Console.WriteLine(@"class a {
public static void main(String[] args) {
java.util.Random r=new java.util.Random();
if (r.nextFloat()<0.5){System.out.print(""Thank you"");}else{if (r.nextFloat()<0.5){System.out.print(""Wow"");}else{System.out.print(""Great"");};};
System.out.print("", this is "");
if (r.nextFloat()<0.5){System.out.print(""awesome"");}else{System.out.print(""wonderful"");};
System.out.print(""."");
System.out.println();
System.out.println(""\\def \\optb {\\ifnum500>\\pdfuniformdeviate1000 Thank you\\else \\ifnum500>\\pdfuniformdeviate1000 Wow\\else Great\\fi\\fi}%"");

System.out.println(""\\def \\optd {\\ifnum500>\\pdfuniformdeviate1000 awesome\\else wonderful\\fi}%"");

System.out.println(""\\optb{}, this is \\optd{}."");
System.out.println();
System.out.println(""['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'"");
System.out.println(""\\bye"");
}
}");
}
}
]==]);

Lua
$ lua a.lua
Great, this is wonderful.
public class a {
public static void Main() {
System.Random r=new System.Random();
if (r.NextDouble()<0.5){System.Console.Write("Thank you");}else{if (r.NextDouble()<0.5){System.Console.Write("Wow");}else{System.Console.Write("Great");};};
System.Console.Write(", this is ");
if (r.NextDouble()<0.5){System.Console.Write("awesome");}else{System.Console.Write("wonderful");};
System.Console.Write(".");
System.Console.WriteLine();
System.Console.WriteLine(@"class a {
public static void main(String[] args) {
java.util.Random r=new java.util.Random();
if (r.nextFloat()<0.5){System.out.print(""Thank you"");}else{if (r.nextFloat()<0.5){System.out.print(""Wow"");}else{System.out.print(""Great"");};};
System.out.print("", this is "");
if (r.nextFloat()<0.5){System.out.print(""awesome"");}else{System.out.print(""wonderful"");};
System.out.print(""."");
System.out.println();
System.out.println(""\\def \\optb {\\ifnum500>\\pdfuniformdeviate1000 Thank you\\else \\ifnum500>\\pdfuniformdeviate1000 Wow\\else Great\\fi\\fi}%"");

System.out.println(""\\def \\optd {\\ifnum500>\\pdfuniformdeviate1000 awesome\\else wonderful\\fi}%"");

System.out.println(""\\optb{}, this is \\optd{}."");
System.out.println();
System.out.println(""['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'"");
System.out.println(""\\bye"");
}
}");
}
}

C#
$ mcs a.cs
$ mono a.exe
Thank you, this is wonderful.
class a {
public static void main(String[] args) {
java.util.Random r=new java.util.Random();
if (r.nextFloat()<0.5){System.out.print("Thank you");}else{if (r.nextFloat()<0.5){System.out.print("Wow");}else{System.out.print("Great");};};
System.out.print(", this is ");
if (r.nextFloat()<0.5){System.out.print("awesome");}else{System.out.print("wonderful");};
System.out.print(".");
System.out.println();
System.out.println("\\def \\optb {\\ifnum500>\\pdfuniformdeviate1000 Thank you\\else \\ifnum500>\\pdfuniformdeviate1000 Wow\\else Great\\fi\\fi}%");

System.out.println("\\def \\optd {\\ifnum500>\\pdfuniformdeviate1000 awesome\\else wonderful\\fi}%");

System.out.println("\\optb{}, this is \\optd{}.");
System.out.println();
System.out.println("['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'");
System.out.println("\\bye");
}
}

Java
$ javac a.java
$ java a
Wow, this is wonderful.
\def \optb {\ifnum500>\pdfuniformdeviate1000 Thank you\else \ifnum500>\pdfuniformdeviate1000 Wow\else Great\fi\fi}%
\def \optd {\ifnum500>\pdfuniformdeviate1000 awesome\else wonderful\fi}%
\optb{}, this is \optd{}.

['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'
\bye

PdfTeX
(the code will be inside a.pdf instead of the stdout. I hope this is still okay)
$ pdftex a.tex
This is pdfTeX, Version 3.1415926-2.4-1.40.13 (TeX Live 2012)
 restricted \write18 enabled.
entering extended mode
(./a.tex [1{/usr/local/texlive/2012/texmf-var/fonts/map/pdftex/updmap/pdftex.ma
p}] )</usr/local/texlive/2012/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.p
fb>
Output written on a.pdf (1 page, 15967 bytes).
Transcript written on a.log.
$ open a.pdf

Result:

In text:
Great, this is wonderful.
['Thank you''Wow''Great']3rand=', this is '['awesome''wonderful']2rand='.'

Golfscript
$ ruby golfscript.rb a.gs
Wow, this is awesome.

Notes

It seems PHP is quite forgiving with binary data in string literals, except for hex codes AF and 96. Don't ask why.
I could've probably added perl and C++11 code as well easily (as they both support raw string literals), but 8 is a more round number than 10 :)
The distribution of values is not uniform, as the first element comes more often than later ones. According to comments this should be okay.
The initial code was actually generated using the following PHP 5.5 code. orig.rb is actually the same as the Ruby code without the footer (__END__ and the appended data afterwards)

generator.php:
<?php
$d=file_get_contents('orig.rb');
$dc = gzcompress($d,9);
echo '<?php $x=file_get_contents("php://stdin");echo preg_replace_callback("/\\[(.*?)\\]/",function($m){$r=explode("/",$m[1]);return $r[array_rand($r)];},$x)';
?><?php
echo ".gzuncompress(\"";
for ($i=0;$i<strlen($dc);$i++) {
  switch($dc[$i]) {
  case '"':
    echo "\\\"";break;
  case "\n":
    echo "\\n";break;
  case '\\':
    echo "\\\\";break;
  case "\x00":case "\xaf":case "\x96":
    echo sprintf("\\x%02x",ord($dc[$i]));
    break;
  default:
    echo $dc[$i];
  }
}
echo "\").\"__END__\\n\".\$x;";

(you can potentially use this code to zLib encompress PHP solutions for other challenges)

...wow. That's all I have to say :O +1

you can omit semicolons in lua, and you can replace a spurious print() call by simply placing another newline after [==[

Ruby 1.9 -> Perl 5 -> Python 2, 227/9 = 25.22222...
$><<(g=gets).gsub(/\[(.*?)\]/){$1.split(?/).sample}+"say'#{g.chop}'=~s|\\[(.*?)\\]|@a=split'/',$1;$a[rand@a]|reg;say'import re,random;print re.sub(\"\\[(.*?)\\]\",lambda m:random.choice(m.group(1).split(\"/\")),\"#{g.chop}\")'"

Output for [Please/Kindly] [visit/see] my [site/blog].:
Please see my site.
say'[Please/Kindly] [visit/see] my [site/blog].'=~s|\[(.*?)\]|@a=split'/',$1;$a[rand@a]|reg;say'import re,random;print re.sub("\[(.*?)\]",lambda m:random.choice(m.group(1).split("/")),"[Please/Kindly] [visit/see] my [site/blog].")'

The Perl program (my first ever! :-P) outputs:
Kindly see my blog.
import re,random;print re.sub("\[(.*?)\]",lambda m:random.choice(m.group(1).split("/")),"[Please/Kindly] [visit/see] my [site/blog].")

The Python program outputs:
Kindly visit my site.


text:
Hello world! with NO repetition
In any programming language that existed before this question was asked, write a program (not a function) that outputs the characters Hello world! followed by a newline. Your program:

should not use any character more than once (including whitespace)
should only use ASCII characters
should not use any built-in libraries
should not get input (user, file, filename, system variable, internet, anything)
should not output anything else

Winner is whoever has the most votes after 14 days and abides to the six rules.
The sixth rule is that you cannot use H9+, HQ9+, HQ9+B, HQ9++, HQ9+2D, Hello, Hello+, Hello++, Hexish, CHIQRSX9+, or Fugue. Also, all answers which require implementations that are newer than this challenge must be marked as non-competing.

Disclaimer: This question was posted with the assumption that Hello world! with limited repetition did not cause any damage to your computer or your brain in the process of coming up with the answers.

if We are escaping character codes, can the "" character be used more than once?

What about piet?

@Victor "should only use ASCII characters"

@Eliseod'Annunzio No, I'm sorry.

Just checking, buddy! :)

Is the "followed by a newline" requirement really necessary? This is hard! D:

@FireFly Yeah, it's necessary.

Why ASCII only?

Are Huby and CHIQRSX9+ allowed?

Are ASCII control characters allowed?

@tobyink I don't see why not. ASCII should include all bytes 0-127, and after all LF and CR are control characters too.

@tobyink Yes, they are ASCII.

That was a great puzzle, and I enjoyed doing it :-).

You should also disallow "Hello", "HQ9+B", and "CHIQRSX9+"

@RyanCarlson Okay, added them.

About ASCII only: a few days ago i heard some bad things about developers of programming languages (C#, Java, ...), because they said that his language supports unicode, but at the same time don't do a correct abstraction of unicode. The length function returns the length in bytes instead of characters, for example. Now talking about ASCII only could be interpreted as discriminatory, because natural languages with more or other letters are handicapped.

“should only use ASCII characters” — what a draconian restriction. That removes an entire class of languages that don’t happen to use ASCII.

So since Dom Hastings' answer seems to follow the specs, are command line arguments ignored?

I know this challenge is old, but would you mind adding Help, WarDoq! to the list of disallowed languages?

@MDXF Don't worry, that language was created after the challenge was posted.

@Timtech No, the rule requiring languages created after challenges to be marked as non-competing has phased out, per this meta thread by me and Martin Ender.

@MDXF Alright, I added it for this challenge specifically then.

The rule about "getting no input" - is it intended just to close a loophole (like fetching missing chars from elsewhere), or does it actually forbid to make any use of STDIN? Say, if I have a program that needs a single line of input to run correctly (the content doesn't matter, it could be any single hardcoded char unused in the code, it just must be non-empty), would this count as a violation?

@KirillL. That could be okay in the same spirit as a command-line flag (so it still counts towards the bytecount), but I'm not understanding why you would need input if the contents of the input doesn't matter.

@Timtech, I'm trying to solve this in Ruby, and the idea is using "-p" flag that runs the script once for each input line with implicit print. With empty input it just won't run at all. I've seen people using a trick that makes this flag work without input in Perl, but I couldn't find a functional Ruby equivalent.

To be more specific, here is my current solution. Do you think it's OK?

What do you think this is... The radio program "Just a Minute?"

"should not use any built-in libraries" makes it impossible for I/O in languages like C and C++ where the I/O is in a built-in library.

Raku (29 28 characters)
This was somewhat annoying, but I finally managed to make a program for this task. Thanks go to the great #perl6 community, for helping me with this task. It took me two hours, hope you enjoy. The output is completely up to specification, including a newline.
say
Q[@A`DO world!]~|<HeLhg>

There are four tokens of interest.

say
This outputs the argument with new line at end. The new line after the command itself is needed as a space replacement.

Q[@A`DO world!]
This is the first string. Q[] is for raw strings (like r"" in Python). It can take any delimiter (or pair of them), in this case []. In this case, I use this for quotes, I don't need raw string behavior.

~|
This is stringwise (~) bitwise or (|) operator.

<HeLhg>
<> is list literal, which takes space separated list of elements. In this case, it has one element, and used as a scalar, it gives a string.

Amazing! I need to get on learning. Some Perl 6 syntax! I agree with your comment too, was definitely a fun problem!

Woah... my mind is blown :O +1

Perl 5.10+: 24 chars
say+He,YZX^q(567 world!)

OK, I think this is as short as it gets in Perl.
Run with perl -M5.010 (or just perl -E) to enable the Perl 5.10+ say feature.

Seriously impressed! I spent ages trying to get around the lls...

Perl 5 with -M5.010, 29 bytes
say+He.v108
x2,q(O world!)^$"

Try it online!
I've gained a lot of knowledge since I first attempted this. Still not as short as the other answers, but the best I can come up with!

Challenge has lower case w.

@ØrjanJohansen Thanks, I forgot!

Vim 7.3, 18 keystrokes
:h-cu
9j3wy$<C-^>P<End>r!o

Copies the string Hello world from this helpfile, which unfortunately has been removed in never versions of Vim.

According to this, Keystrokes like <Esc> and combinations involving the Ctrl-key count as one byte

So it wasn't a permanent solution

Maybe something like iHelwxrd<Esc>3|yl3pr $P2hro0E. or similar

Golfscript 42 33
I might as well golf this, considering that I had to fit some of the code and all of the data in the same block with no way of delimiting the two I think this is a pretty short result. Unlike my first submission the block code is now a fully integrated part of the data, thus {1 do not only begin the block and put a 1 on the stack, it is also the data that defines the H, and so forth. The array creation now includes the empty input string, which means that I don't have to crop the beginning as there is only one character between the empty string and the H, that character is cut away when I take every second character, and the empty string eventually is output as nothing.
{1wZ$Qei^Ak 3h-)ulmsogr7}.`*]2%n+

Online demo: http://golfscript.apphb.com/?c=ezF3WiRRZWleQWsgM2gtKXVsbXNvZ3I3fS5gKl0yJW4r

[{1$^(r iFNGDJUHv98oIMgtplbh4m}.`\*]6>2%n+

Defines a code block. Makes a copy of the code block and converts it to string. Uses the code block to iterate over the string. For each iteration the code will make a copy of the previous char value, xor it with the current char value, and subtract 1. The resulting string then has the first 6 characters removed, and every second character removed. Finally a line feed is appended.
"r iFNGDJUHv98oIMgtplbh4m" is just two undeclared variables, they do nothing, but they are carefully constructed to produce the desired result.
Online demo: http://golfscript.apphb.com/?c=W3sxJF4ociBpRk5HREpVSHY5OG9JTWd0cGxiaDRtfS5gXCpdNj4yJW4r

Befunge-98, 34 31 bytes
f"v!dlrow
+c<>a,kb@#*98e':g05-3

Try it online!
Uses quite a few different methods to avoid duplicated characters.
First, we use wrapping string literal to avoid using two "s. This adds " world!" to the stack.
Going left on the second line, we add 9 to the extra f to make the o of the "Hello". We get the character from cell 5,0 (l) and then duplicate it. The ' is used to fetch the letter e. Multiply 9 by 8 to get 72, the ASCII value of H. We then print it everything using ck,, and flip the direction with the > to reuse the , to print the newline (a).

Very good but this challenge is without the comma.

Oh lol, that makes it easier... Thanks @ØrjanJohansen

You have two of + and d.

@ØrjanJohansen oops. should be fixed now

Elixir, 37 bytes
IO.puts~c(He#{[?n-2,108]}\x6f world!)

Try it online!
I can't guarantee that this would have worked back in 2014 when this challenge was posted, and Elixir was still pre-1.0 (and thus, whether it is formally "competing", but looking at their release notes, I think it should be OK).
Anyway, I'm happy that I finally found a valid solution to this task using a conventional general purpose language other than Perl!
Walkthrough
IO.puts     #Print with trailing newline
~c(...)     #Sigil: charlist with interpolation
He          #Start of literal string...
#{...}      #Interpolated block
[?n-2,108]  #A list of codepoints for 2 'l's
\x6f        #Hex code for 'o'
world!      #...and done!

Keg, 17 bytes
Hel:o Wn1+rp4-d\!

Try it online!

Vyxal, 6 bytes
kh\!+,

Try it Online!
Basically the normal way of printing "Hello World!" in Vyxal.

should only use ASCII characters

Vim, 21 keystrokes

2iHelo WORLD!Escgu8h10X

Try it online!
Vim adds a newline at the end of the file so there's no need to add it explicitly.
To run it locally:

Save the code to a file (here hello_world.vim) replacing Esc with `` (\x1b).
run vim -u NONE -s hello_world.vim hello_world.txt.
exit Vim.

Uiua, 30 bytes
&p+mod107\*-,:@$ H`eFMbv/5la

Try it online! (Note that the formatter automatically converts some ASCII tokens to Unicode equivalents, but you can verify the solution by copy-pasting the code above and running it manually.)
Verify the restrictions!
Contains two ASCII control characters; I'm assuming this is valid based on the existing Vim answers.
This code solves the duplicate character problem by finding an integer p and a list of integers L such that the cumulative product of L modulo p gives the desired string. Also, a character literal is used twice because both "convert string to a list of charcodes" and "convert a list of charcodes to string" require a character literal, and it is chosen so that the resulting p and L meet the no-duplicates requirement.
$ <string> is a multiline string literal that continues through lines that start with $  and ends at a newline after that.
&p+mod107\*-,:@$ H`eFMbv/5la
                $ H`eFMbv/5la    push a string literal, S
              @                  push a character literal, c
            ,:   swap and over; c S c
           -     S-c; convert S to charcodes and subtract c's charcode
         \*      cumulative product
   mod107        % 107
  +              add c; add c's charcode and convert to string
&p               print with newline

Stax, 8 bytes
`dx/&\p4

Try it online!
Just a compressed string literal. Luckily Stax lets me go without the closing backtick.

An answer from https://codegolf.stackexchange.com/a/55425/118820:

Stuck, 0 bytes
Well, can't get shorter than that... An empty program
will output Hello, World! in Stuck.

Even Stuck comes with 3 plugins, but we don't need they.

this programming language was made after the question was asked

@ld_spectrum "Also, all answers which require implementations that are newer than this challenge must be marked as non-competing."

"In any programming language that existed before this question was asked, write a program"

@ld_spectrum that was an old default rule, it is no longer applicable to this site.

Gol><>, 25 bytes
"v!dlrow
H>{7-5k:`e01ga}

Try it online!
"v!dlrow      push "v!dlrow " where v is the bottom of the stack
 >{           bring v to the top
 7-           subtract 7 from v to get o
 5k:          fetch 5th number down the stack which is l, and duplicate it
 `e           push e
 01g          fetch H from the code area
 a}           put 10 (newline) at the bottom of the stack
H             print the whole stack as chars from top to bottom and halt

Gol><>, 30 bytes
"\>mX.RMkp
r<;|%q`*o+a:Fd~

Try it online!
Same strategy as my own Uiua answer applied to Gol><>.
Uses printing offset of 10 (a+o) so that the newline can be printed without an explicit stack item.
"\...    push a backslash and the string, and then reflect down
r<   ~   reverse stack and discard the backslash
|...Fd   repeat the loop 13 times:
o+a:       print the current number plus 10 as char
%q`*       multiply modulo 113
;        halt

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


text:
Expand tabs (implement expand(1))
Your task this time is to implement a variant of the POSIX expand(1) utility which expands tabs to spaces.
Your program is to take a tabstop specification and then read input on standard in and replace tab characters in the input with the appropriate amount of spaces to reach the next tabstop.  The result should be written to standard out.
Tabstop specification
A tabstop specification consists of either a single number, or a comma-separated list of tabstops.  In the case of a single number, it is repeated as if multiples of it occurred in a comma-separated list (i.e. 4 acts as 4,8,12,16,20,...).  Each entry in a comma-separated list is a positive integer optionally prefixed by a +.  A + prefix indicates a relative difference to the previous value in the comma-separated list.  The first value in the list must be absolute (i.e. unprefixed).  The tabstops specify the column of the next non-space character (following the expanded tab), with the leftmost column taken as number 0.  Tabs should always expand to at least one space.
Input/output
The tabstop specification is either to be taken as the first command-line parameter to the program, or read from standard in as the first line of input (terminated by a newline), at your discretion.  After the tabstop has been read, the remaining input (all input, in the former case) until EOF is to be processed and expanded.  The expanded output shall be written to standard out.
All expanded tabstops, and all input, is assumed to be a maximum of 80 columns wide.  All expanded tabstops are strictly increasing.

Example
Tabstop specification 4,6,+2,+8 is equivalent to 4,6,8,16, and with both the input
ab<Tab>c
<Tab><Tab>d<Tab>e<Tab>f

is expanded into (␣ indicates a space)
ab␣␣c
␣␣␣␣␣␣d␣e␣␣␣␣␣␣␣f

01234567890123456   (Ruler for the above, not part of the output)
          1111111

Scoring is pure code-golf; shortest code wins.

GolfScript (77 75 chars)
n/(','/{'+'/{~t++}*~:t}%81,{t*}%+:T;{[0\{.9={;T{1$>}?(.)@-' '*}*\)}/;]n+}/;

I'm quite pleased with the tabspec parsing.
# Split on commas
','/
# For each element:
{
    # Split on '+'
    '+'/
    # We now have either ["val"] or ["" "val"]
    # The clever bit: fold
    # Folding a block over a one-element array gives that element, so ["val"] => "val"
    # Folding a block over a two-element array puts both elements on the stack and executes,
    # so ["" "val"]{~t++}* evaluates as
    #     "" "val" ~t++
    # which evaluates val, adds the previous value, and concatenates with that empty string
    {~t++}*
    # Either way we now have a string containing one value. Eval it and assign to t
    ~:t
}%

Then I add multiples of the last element until I'm guaranteed to have enough to reach the end of the 80 columns:
81,{t*}%+

This gives the desired behaviour when only one tabstop was specified, and is otherwise only relevant in cases which the spec doesn't mention. (NB it makes the list of tab-stops dip back to 0 and then repeat the last parsed element, but that's irrelevant because when it comes to using the list I look for the first element greater than the current position).
The rest is pretty straightforward.

C, 228 chars
Here is a C solution to start things off.  There's still a lot of golfing to do here (look at all those ifs and fors and putchars...).  Tested with the example testcase, as well as with the same input but 4 and 8 for the tab spec.
S[99],i;L,C;main(v){for(v=1;v;)v=scanf("+%d",&C),v=v>0?C+=L:scanf("%d",&C),
v&&(S[L=C]=++i,getchar());for(;i==1&&C<80;)S[C+=L]=1;for(C=L=0;C=~getchar();)
if(C+10)putchar(~C),L+=C+11?1:-L;else for(putchar(32);!S[++L];)putchar(32);}

Ruby 161 145
Reads the tabstop specification on the first line of input.
i=t=[]
gets.scan(/(\+)?(\d+)/){t<<i=$2.to_i+($1?i:0)}
81.times{|j|t<<j*i}
while gets
$_.sub!$&," "*(t.find{|s|s>i=$`.size}-i)while~/\t/
print
end

edit: Added two lines that makes the last read tabstop repeat so that tabstop specifications of a single number also works correctly
i is a temporary variable for holding the last parsed tabstop. t is the list of tabstobs, parsed from the gets.scan line. For good measure we add 81 multiples of the last parsed tabstop. the while gets loop keeps going until there is no more input. For each line of input we substitute tabs for spaces, one tab at the time because the string moves as we add the spaces and we must recalculate the correct tabstop.

I don’t really know Ruby, but can you write x+($1?i:0) as the shorter $1?x+i:x?

@Timwi Nope! Ruby is a little strange with the ternary operator. Usually you need to put a space in there somewhere, because the colon (:) could also mark the beginning of a symbol, but since a symbol can't start with a digit, :0 is OK without space. Or something. It's weird. The parentheses are crucial also it seems.

That tabstop scanning looks buggy to me. In t<<x+($1?i:0);i=x the first statement doesn't change x, does it? I think you need to reverse it as i=x+($1?i:0);t<<i

In fact you can save 16 by replacing the first two lines with i=t=[] (since i is guaranteed not to be needed the first time around); simplifying the tab-stop parse to {t<<i=$2.to_i+($1?i:0)}, and eliminating l entirely (i already holds that value). But nice one on not caring about the tab stop being strictly increasing: that saves you 4 chars, and I can borrow it to save 2.

@PeterTaylor Thanks for the input! It wasn't directly buggy, but certainly a little bloated. I find it too easy to stare oneself blind on code like this.

It was directly buggy: given input of 4,6,+2,+8 it produced tab-stops 4,6,8,10 rather than 4,6,8,16.

@PeterTaylor Wow, I did actually at some point fix exactly that issue; Don't know how it got back in there. Probably during some golfing process. Good catch!

Pascal, 441 B

The Pascal programming language is standardized by ISO standards 7185 (“Standard Pascal”) and 10206 (“Extended Pascal”).
Since the notion of command-line arguments something highly specific, not universally found on all computing systems, Pascal lacks of a standardized facility to access command-line arguments (if such exist).
Therefore the following complete program expects the tabulator specification given on the first line of input.
The tabulator stop specification reading algorithm uses the built‑in read procedure.
Such will allow and ignore leading blanks.
Thus 8, 12, 14, 15 is accepted, too.
However, relative tabulator stop specifications are only processed correctly if the plus sign is immediately adjacent to the comma.
With respect to (POSIX™ locale) blank characters, the Pascal programming language only guarantees there is a space character.
The provision of a tabulator character is an implementation-defined characteristic.
Obviously the following program requires that there is a horizontal tabulator character in the utilized implementation.
The golfed version omits certain verification steps (non-empty input, first tabulator specification must be non-relative).
It is unclear whether such vigorous enforcement is required by the task specification.

program e(input,output);var t:set of 1..80;c,p:1..80;begin
read(p);t:=[p];while','=input^do begin
get(input);if'+'=input^then begin read(c);p:=p+c end else
read(p);t:=t+[p]end;readLn;if[]=t-[p]then begin for c:=1
to 80 do if c mod p=0 then t:=t+[c]end;p:=1;while not EOF
do begin if EOLn then begin writeLn;p:=1 end else begin
if' '=input^then repeat p:=p+1;write(' ')until p-1 in t
else begin write(input^);p:=p+1 end end;get(input)end end.

Ungolfed:
program expand(input, output);

    const
        { The character count of the longest line this program can process. }
        lineIndexMaximum = 80;

    type
        { A valid character index in an `input` line. }
        lineIndex = 1‥lineIndexMaximum;
        { A set of valid character indices. }
        lineIndices = set of lineIndex;

    var
        { This mimics a mechanical typewriter implementation
          that has retractable pins installed catching the carriage. }
        tabulatorStop: lineIndices;
        { Where are we at in the currently processed line. }
        position: lineIndex;

    { Processes an input line containing a tabulator stop specification. ┈┈┈ }
    procedure processTabulatorStopSpecification;
        var
            { In Pascal `for`-loop counter variables must be declared
              in the _closest_ containing block. }
            column: lineIndex;
        begin
            { A negative number will be caught by the `lineIndex` data type. }
            read(input, position);
            tabulatorStop ≔ [position];

            while input↑ = ',' do
            begin
                { Skip comma. }
                get(input);

                { “A `+` prefix indicates a relative difference
                   to the previous value in the comma-separated list.” }
                if input↑ = '+' then
                begin
                    read(input, column);
                    position ≔ position + column;
                end
                else
                begin
                    read(input, position);
                end;

                tabulatorStop ≔ tabulatorStop + [position];
            end;

            { Discard the rest of the line, especially the end-of-line mark. }
            readLn(input);

            { “In the case of a single number, it is repeated as if
               multiples of it occurred in a comma-separated list.” }
            if tabulatorStop − [position] = [] then
            begin
                for column ≔ 1 to lineIndexMaximum do
                begin
                    if column mod position = 0 then
                    begin
                        tabulatorStop ≔ tabulatorStop + [column];
                    end;
                end;
            end;
        end;

    { Expands `input` lines according to `tabulatorStop`. ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ }
    procedure expandTabulatorCharacters;
        begin
            position ≔ 1;

            while not EOF(input) do
            begin
                if EOLn(input) then
                begin
                    { `Input` is a variable possessing the data type `text`.
                      A `text` file automatically replaces
                      the character (sequence) that indicates the end-of-line
                      with a single space character (`' '`).
                      The only /universally/ valid way to
                      emit an end-of-line character (sequence) is `writeLn`. }
                    writeLn(output);
                    { Reset `position` to the beginning of a new line. }
                    position ≔ 1;
                end
                else
                begin
                    { Note, as this might not be properly displayed,
                      this checks for a tabulator character. }
                    if input↑ = '   ' then
                    begin
                        { “Tabs should always expand to at least one space.”
                          Ergo elect a `repeat … until` loop. }
                        repeat
                        begin
                            write(output, ' ');
                            { Cannot fail: “All expanded tabstops […] is
                              assumed to be a maximum of 80 columns wide.” }
                            position ≔ position + 1;
                        end
                        until position − 1 in tabulatorStop;
                    end
                    else
                    begin
                        write(output, input↑);
                        { Note, fatal error if exceding `lineIndexMaximum`. }
                        position ≔ position + 1;
                    end;
                end;
                { Advance the reading cursor. }
                get(input);
            end;
        end;

    { ─── MAIN ───────────────────────────────────────────────────────────── }
    begin
        { Accessing `input↑` is invalid if `input` is an empty file. }
        if not EOF(input) then
        begin
            { “The first value in the list must be absolute […]” }
            if input↑ ≠ '+' then
            begin
                processTabulatorStopSpecification;
                expandTabulatorCharacters;
            end;
        end;
    end.


text:
Sourcecode combinatorics
Objective:

The task is to create two programs using the same or different
  programming languages. The sourcecodes will be combined in two
  different ways and the resulting sourcecodes can be in any programming
  languages. The four programs (original two + the two combinations)
  should output different things.

Rules:

Your programs (all four) should not take any input (from user, filename, network or anything).
The first program should output exactly Hello, nothing else.
The second program should output exactly world, nothing else.
The first combinated program should output Hello human!, nothing else.
The second combinated program should output Hello computer!, nothing else.

Here is how the two combinated programs may be created:
First combined program:

Choose two numbers (equal or different) between 1 and 6 (that is: 2, 3, 4 or 5), the two numbers are called: n1 and n2.
Copy n1 number of characters from the first program and paste into the combined sourcecode
Copy n1 number of characters from the second program and paste into the combined sourcecode
Copy n2 number of characters from the first program and paste into the combined sourcecode
Copy n2 number of characters from the second program and paste into the combined sourcecode
Next, start over copy n1 number of characters again and so on. Copy from start to end from the sourcecodes, paste from start to end into the combined sourcecode.

Second combined program:

The sourcecode is the reverse of the first combined program sourcecode above. You may replace up to 3 characters at any place afterwards (optional). You can replace the up to 3 characters with any other characters. Replacing means 1 char for 1 char at up to 3 different positions on the sourcecode. The final sourcecode size in characters should therefor be exactly the same size as the first combined program size.

Example creating the combinated programs using numbers 3 and 4:
            First program:    {'Hello'}:p
           Second program:    /*         */ console.log ("World");
 First combinated program:    {'H/* ello    '}:   */ console.log ("World");
Second combinated program:    ;)"dlroW"( gol.elosnoc /*   :}'    olle */H'}

Be sure to declare all four programming languages that you use (even if they are all the same) and what numbers you have used when creating the first combinated sourcecode.
This is code-golf, shortest code in bytes for the two sourcecodes wins! Good luck, have fun!

+1. Your challenges are crazy; you make us work really hard on short pieces of code, you impose strict requirements, etc.

I'm going to guess it has to work for only 1 chosen combination of numbers, not all combinations? Also, if one of the programs runs out of characters during combination procedure, is the remainder of the other program just appended?

Yes, only 1 number combination needs to work and yes if one code run out of chars, the rest of the pther is appended last on first combinated source

Befunge-98 × 4, 69 chars
Following @user12551's lead, I went with 4× Befunge (although -98 rather than -93).  Program code is reversed on byte-level, line ending is LF, program #1 has no terminating newline.
Program 1:
"!namolleH"4k,@

Program 2:
"vdlrow"4k,@
      >"uh olleH"bk,@,ke"Hello computer!"

Combined 1 (n₁ = 5, n₂ = 2):
"!nam"volleHdl"4k,@row"4k,@
      >"uh olleH"bk,@,ke"Hello computer!"

Combined 2 (has a bunch of trailing spaces):
"!retupmoc olleH"ek,@,kb"Hello hu">
@,k4"wor@,k4"ldHellov"man!"

Befunge-93 x4; n1=5, n2=5; 100 75 chars
I put the 4 programs into 1 file for debugging:  (it outputs a random one of the four programs)
 vv  |2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|23
>??#@"oll""eH"   >:#0#,_ @    #
     |2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|23
>? #@"dlr""ow"        >:#0#,_ @0"!namuh olleH">:#,_@#:>"Hello computer!"
     |2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|23
 > #@"oll""dlr""eH" "ow"   >:#     0#,_   >:#@    0#,_ #@0"!namuh olleH">:#,_@#:>"Hello computer!"
     |2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|2345|23
  >#@"!retupmoc olleH">:#,_@#:>"Hello human!"0@# _,#0    @#:>   _,#0     #:>   "wo" "He""rld""llo"

The separate programs are: (one per line)
"oll""eH"   >:#0#,_ @    #
"dlr""ow"        >:#0#,_ @0"!namuh olleH">:#,_@#:>"Hello computer!"
"oll""dlr""eH" "ow"   >:#     0#,_   >:#@    0#,_ #@0"!namuh olleH">:#,_@#:>"Hello computer!"
"!retupmoc olleH">:#,_@#:>"Hello human!"0@# _,#0    @#:>   _,#0     #:>   "wo" "He""rld""llo"

Edit:  This time, I took advantage of the replacement rule and replaced two characters in the second combination.

Windows Command script x4; n1=2; n2=2 - 92 Bytes
1st script (marked eol and eof):
 %: !rupc leoh %\r\n
 % eo llhun!% \r\n
 %echo Hello\eof

2nd script (marked eol and eof):
 %&&etmoolH ce %\r\n
 %chHeo ma% % \r\n
echo world%  \eof

Results in:
 % %: &&!retupmoc olleH ohce % %
 % % echo Hello human!% % %
 %ecechoho w Horelldlo%

And reversed:
 %oldlleroH w ohohcece%
 % % %!namuh olleH ohce % %
% % echo Hello computer!&& :% %