text:
Find the Interwoven Source Codes (Cops)
This is the cops' thread. For the robbers' thread, go here.
Introduction
For this Cops/Robbers challenge, the cops will write output-producing programs and interweave them together. It is the robber's job to pick apart the cops' programs to produce the desired outputs.
Cop rules
The cops may use up to 256 bytes total to write between 2 and 8 (inclusive) programs, all of which must produce some output. All programs written must be in the same language. The cops will "interweave" their programs together to make it harder for the robbers to figure out what the programs are.
Now for a description of interweaving. Consider the strings representing the different programs. The process of interweaving is the repeated pulling off of the first character of any of the programs and concatenating it to the end of a new string until no characters in any of the programs are left. For example, if two programs are lion and TIGER, a possible interweaving is TIliGoEnR. However, the programs cannot be scrambled in any way, so RoITEnlGi is not acceptable.
It should be noted that when the characters of all but one program are removed from the results of an interweaving, the remaining program would be shown intact. Removing the letters TIGER from TIliGoEnR results in lion.
All of the cops' programs and outputs must contain only printable ASCII characters (20-7E) and newlines. Programs must not contain errors and must run in 10 seconds on a reasonable machine. For any submission, there must be a free interpreter of the language somewhere. Adding comments to the submissions is not allowed, as are hashing and other forms of cryptography. Blank programs are not allowed (Sorry Stuck).
The cop will post the interweaved code, the language, the number of different programs used, and the output for each program. A big thanks to Martin for writing this CJam script to automatically interweave your programs.
Programs are deemed safe after one week has elapsed from the time of posting. At that point, the cops must post the individual programs in order to receive points.
Scoring
There are two components that are added together when scoring a safe submission.

256 divided by the quantity 2 raised to the power of the number of programs used.
Round the number of bytes in the interweaving up to the nearest power of 2 and divide it into 256.

For example, if the entry TIliGoEnR (9 bytes) were safe, it would receive 256/2^2+256/16=80 points.
When a cop's submission is cracked, the cop loses 16 points. The cop must indicate that their submission has been cracked.
The winner of the cops' challenge will be the person with the most points after a sufficient period of time for people to participate.
Leaderboard
This is a work in progress that was adapted by intrepidcoder from this question.
To make sure that your answer shows up, please start your answer with a headline, using the exact Markdown template:
# Language Name, N programs, M bytes; Score ###/### (if safe/cracked)

Anything after a semicolon will be ignored, so you can put your score there.
If your submission is safe put a header like this:
# Language Name, safe, N programs, M bytes; Score ###

If it is cracked, put a header like this:
# Language Name, [cracked](link-to-crack), N programs, M bytes; Score -16

/* Configuration */

var QUESTION_ID = 64520; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 43444; // This should be the user ID of the challenge author.
var SECONDSINDAY = 86400;
var SAFECUTOFFDAYS = 7;
var SORTBYTIME = true;
var SUBTRACTCRACKEDPOINTS = true;
var EXPIREDTIME = 1448232502000;

/* App */

var SAFE_REG = /<h\d>.*?[sS][aA][fF][eE].*<\/\h\d>/;
var POINTS_REG = /<h\d>.*(\d+)\s*program.*<\/h\d>/i; // /(?:<=|≤|<=)\s?(?:<\/?strong>)?\s?(\d+)/
// var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var LENGTH_REG = /<h\d>.*?((\d+)\s*byte).*<\/h\d>/i;
var CRACKED_HEADER_REG = /<h\d>.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<\/h\d>/;
var CRACKED_COMMENT_REG = /(.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<a href=.*)|(.*<a href=.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*)/
var OVERRIDE_REG = /^Override\s*header:\s*/i;
var LANGUAGE_REG = /<h\d>\s*(.+?),.*<\/h\d>/;
var LANGUAGE_REG_ALT = /<h\d>\s*(<a href=.+<\/a>).*<\/h\d>/
var LANGUAGE_REG_ALT_2 = /<h\d>\s*(.+?)\s.*<\/h\d>/;
var LANGUAGE_REG_ALT_3 = /<h\d>(.+?)<\/h\d>/;

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

function answersUrl(index) {
  return "//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 "//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) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

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

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body.replace(/(<h\d>.*);.*(<\/h\d>)/,"$1$2"); // Ignore all text after a semicolon.
    var cracked = false;

    a.comments.forEach(function(c) {
      var was_safe = (c.creation_date + (SECONDSINDAY * SAFECUTOFFDAYS) > a.creation_date);
      if (CRACKED_COMMENT_REG.test(c.body) && !was_safe)
        cracked = true;
    });

    if (CRACKED_HEADER_REG.test(body)) cracked = true;

    // if (SUBTRACTCRACKEDPOINTS||!cracked) {

    var createDate = a.creation_date;
    var currentDate = Date.now() / 1000;
    var timeToSafe = (createDate + (SECONDSINDAY * SAFECUTOFFDAYS) - currentDate) / SECONDSINDAY;
    var SafeTimeStr = (timeToSafe > 2) ? (Math.floor(timeToSafe) + " Days") :
      (timeToSafe > 1) ? ("1 Day") :
      (timeToSafe > (2 / 24)) ? (Math.floor(timeToSafe * 24) + " Hours") :
      (timeToSafe > (1 / 24)) ? ("1 Hour") :
      "<1 Hour";

    var expired = createDate > (EXPIREDTIME);

    var safe = timeToSafe < 0;
    var programs = body.match(POINTS_REG);
    var length = body.match(LENGTH_REG);
    safe = safe && !cracked

    isOpen = !(cracked || safe);

    if (programs && length) {

      var safepoints = (256/Math.pow(2,parseInt(programs[1],10)) +
                    256/Math.pow(2,Math.ceil(Math.log2(parseInt(length[1],10)))));

      var crackedpoints = Math.pow(2, parseInt(programs[1],10),2) +
          Math.pow(2,Math.floor(Math.log2(parseInt(length[1],10))));

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: (safe && !expired) ? 1 : 0,
        points: (safe && !expired) ? safepoints : 0,
        open: (isOpen && !expired) ? 1 : 0,
        cracked: (cracked && !expired) ? 1 : 0,
        expired: (expired) ? 1 : 0
      });

    }

    if ((isOpen || expired) && programs) {

      var language = body.match(LANGUAGE_REG);
      if (!language) language = body.match(LANGUAGE_REG_ALT);
      if (!language) language = body.match(LANGUAGE_REG_ALT_2);
      if (!language) language = body.match(LANGUAGE_REG_ALT_3);

      open.push({
        user: getAuthorName(a),
        safePts: programs ? safepoints : "???",
        crackedPts: programs ? crackedpoints : "???",
        language: language ? language[1] : "???",
        link: a.share_link,
        timeToSafe: timeToSafe,
        timeStr: (expired) ? "Challenge closed" : SafeTimeStr
      });
    }
    // }
  });

  if (SORTBYTIME) {
    open.sort(function(a, b) {
      return a.timeToSafe - b.timeToSafe;
    });
  } else {
    open.sort(function(a, b) {
      var r1 = parseInt(a.length);
      var r2 = parseInt(b.length);
      if (r1 && r2) return r1 - r2;
      else if (r1) return r2;
      else if (r2) return r1;
      else return 0;
    });
  }

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) {
      if (SUBTRACTCRACKEDPOINTS && a.cracked) a.points -= 16;
      pointTotals.push(a);
    }
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions += a.numberOfSubmissions;
      pointTotals[index].cracked += a.cracked;
      pointTotals[index].expired += a.expired;
      pointTotals[index].open += a.open;
      if (SUBTRACTCRACKEDPOINTS && a.cracked) pointTotals[index].points -= 16;
    }

  });

  pointTotals.sort(function(a, b) {
    if (a.points != b.points)
      return b.points - a.points;
    else if (a.numberOfSubmissions != b.numberOfSubmissions)
      return b.numberOfSubmissions - a.numberOfSubmissions;
    else if (a.open != b.open)
      return b.open - a.open;
    else if (a.cracked != b.cracked)
      return a.cracked - b.cracked;
    else return 0;
  });

  pointTotals.forEach(function(a) {

    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.numberOfSubmissions)
      .replace("{{OPEN}}", a.open)
      .replace("{{CLOSED}}", a.expired)
      .replace("{{CRACKED}}", a.cracked)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

  });

  open.forEach(function(a) {
    var answer = jQuery("#open-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.safePts)
      .replace("{{CRACKED}}", a.crackedPts)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{TIME}}", a.timeStr)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#opensubs").append(answer);
  });

}
body {
  text-align: left !important
}
#answer-list {
  padding: 10px;
  width: 350px;
  float: left;
}
#open-list {
  padding: 10px;
  width: 470px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

        Author
        Safe
        Open

        Cracked
        Late Entry
        Score

Open submissions

        Author
        Points if Safe
        Points if Cracked
        Language
        Time Remaining
        Link

      {{NAME}}
      {{SAFE}}
      {{OPEN}}

      {{CRACKED}}
      {{CLOSED}}
      {{POINTS}}

      {{NAME}}
      {{SAFE}}
      {{CRACKED}}
      {{LANGUAGE}}
      {{TIME}}
      Link

I'd be extremely impressed if someone manages to crack one of the 8-programs.

I added a leaderboard, Feel free to edit it if anything isn't right.

@intrepidcoder Nice work! Thanks (If you enter, I'll give you a 50-rep thank you). Maybe you could implement the second half of ETH's suggestion too? Also, I'm not sure why, but it says that Dennis's score for his submission if cracked is 68 instead of 65.

"only printable ASCII characters" ... there goes my plan to use left to right overrides to confuse everyone.

How do you determine the score? I have to post with the following format Score ###/###, but what does the second ### mean?

@Adriandmen The first score is the number of points you get if you are safe. The second score is the number of points the robber would get if you are cracked.

I understand what you're trying to do with the opposing scoring systems for cops and robbers, but it creates weird incentives. It means that robbers will predominantly try to crack those answers for which the cops wouldn't receive many points anyway, whereas they have much less motivation to tackle those which would give the cop a decent amount of points.

May programs terminate with an error?

@mbomb007 No, as errors go to STDERR instead of STDOUT.

If it's useful for anyone here is a CJam script which randomly interleaves any number of programs. Just provide the programs on STDIN, one on each line. If that's not practical (because your programs themselves contain linefeeds), you can choose any other delimiter (||| say) and then replace the N in the code with a string containing your delimiter, e.g. "|||". (@Eridan feel free to include this in the challenge.)

can we output to the console? e.g. javascript console?

@ETHproductions I cracked an (albeit easy) 8-program.

Honestly, if that one made it I  would have laughed so much.

Someone pls write a cop so I can try to crack

@ev3commander Okay ^_^

Hexagony, 6 programs, 53 bytes; Score 8/96 (if safe/cracked)
  [&;//&z
 ;!X;!!/@!
@)6!< @[!.J
 @a5|9o;""
  |@!!!@]

Even if this goes safe, it will be very few points for me, but I thought I'd provide a nice puzzle for robbers to bank some points. :) I have no idea how easy or hard this actually is.
Here are the outputs:
Jazz

XX88XX88

1234562345610

111111111111111111111111

9999999999999999999999999999999999

66566565665656566565656566565656565665

Holy crap on a cracker. I wish luck and sanity to whoever solves this. +1

Is the interleaved program valid as well?

@mbomb007 This is what it would look like and it terminates immediately, because the [ switches control to the instruction pointer that starts on the @ in the left corner.

Hex programs with Hexagony!

@ΚριτικσιΛίθος Agony or cracking codes using Hexagony!

This will be safe once you post the programs.

im trying to crach this right now, can you give me today?

@Eumel sure, I'm more interested in someone cracking it than those 8 points ;)

is the first one /z;;@Ja?

@Eumel I don't have the originals with me right now, but if it works, that's very likely. ;)

do you remember if you used anything bigger than a sidelenght of 2?

@Eumel I thought the total number of non-space characters would be a good hint towards answering that question. :)

Let us continue this discussion in chat.

Is your answer saved? You should reveal the solution.

@zyabin101 Eumel has cracked half of them, and I wanted to give them a chance to figure out the rest as well.

JavaScript, cracked, 2 programs, 110 bytes; Score -16
+(![]+!![])[[]+[]]+(![]+[])+[+[]]+(!![]+[])[[+[]]+[]]+(!![]+[])+[+[]]+(+(![]+!![])[])[+[]]+(![]+[])+[+[]](+[])

 good luck with this one.
Note: I recommend running on a modern browser (basically not IE)
Output, first program:
ffttff

Output, second program:
1010

CJam, safe, 2 programs, 250 bytes; Score 65
Interweaved programs
"":9(x5M/Cle-Dn,1'AFjsQYirG3@+,~unY</CyUAJ!`L.Xkdq'hF_X&=-`!SnxM!hqv~'GW!4!qIfp$h,ld-;i0JM79Xs'orb@#+sE${?.Eet""""/4M.D:}~Cc^est+2]c9>^W<O%8rR(kg)(ra-P{^Fthm?WF[#KJfRxOe-5zYueb~SiX@tnFyb2-M}G8@0;Z.$u']Qc0R{\.M9V$_NyTc,HR]y""22{{''  ffmm9955bb\\}}****

Output, first program
169004397811215505136757551914260640157209814479670875629464038264532260025741074366481672115039451444875174892900756838476896193165147376670615268045482935802126657286722969566601154866449492847343470441618498401

Output, second program
236156588886135909534842810119847991195053526225488685859715966203756668582804035289768525426132740118856398404195457578486865119219669643999456580063310899697265496162944335336660228420754397359091438096239696929

Solution
First program
"9(M/l-n'FsQrG@~n<CyA`.XdhF&-`SMhq~W!qI$hd-0M7X'b#sE{Ee""/MD~c^s2]>^O%r(gra{FhmW#KfOezYbSi@Fy-}G0;$u]cR.9V_TcRy"2{' fm95b\}**

Try it online!
Second program
":x5CeD,1AjYi3+,uY/UJ!Lkq'_X=!nx!v'G4!fp,l;iJ9sor@+$?.t""4.:}Cet+c9W<8Rk)(-P^t?F[JRx-5ue~Xtnb2M8@Z.'Q0{\M$Ny,H]"2{' fm95b\}**

Try it online!
How it works
Both programs have this format:
 "…""…"2{' fm95b\}**

       2{        }*   Do the following twice:
         'fm            Subtract the char code of ' ' from each character.
            95b         Convert from base 95 to integer.
               \        Swap the two topmost stack elements.
                      This pushes two prime numbers on the stack.
                  *   Compute their product.

De-interweaving the programs should require either brute force or factoring the semi-primes.

Congrats on being the first safe submission!

I guessed the outputs were semiprimes. Brute-forcing a 213 (decimal) digit semiprime would certainly not be possible on a single machine in a week. This 212-digit one took over a year. I doubt brute forcing the interweaving would be feasible either.

-1 This is against at least the spirit of the "no hashing or cryptography" restriction.

BitShift, cracked, 2 programs, 110 bytes; Score -16
Interweaved programs
10011110011111001011101110110110110110011001100010110000010010011100101111000111100110111101011110011101001100

Output, first program
! ?

Output, second program
? !

I'm so sorry

Java, cracked, 2 programs, 155 bytes; Score -16
Interleaved programs
cliantsesr fai{pce ubc{stlaic sttatiic voidc  mavioin(Sd tmariinn(Stg[rin]g)g{Syst[em]n.)o{ut.prSiysntemtln.out.(prin"Hell"\u002bg.tlen(gth)"By;e!\n}")};}}

Output, first program
Hell0

And trailing newline.
Output, second program
Bye!

And trailing newline.
Original programs
First
class i{public static void main(String[]g){System.out.println("Hell"\u002bg.length);}}

Second
interface c{static void main(String[]n){System.out.print("Bye!\n");}}

I forgot you could put interface instead of class until I saw your answer on the Hello, World! challenge. I'll try to crack this during my lunch.

Ugh, my lunch time is up. I'll try again tonight.

Pyth, safe, 2 programs, 63 bytes; Score 68
Interweaved programs
V8j5kIqlPN1[C7=3+Z1d=G"<"C38p5)IqdZ21=ZNB;C-jk[C9Zd\</.5n0T1dG2

First program
Output:
 I <3 U

Program:
jk [C73d"<"3pdC-95T

j                   # Join
 k                  # Standard variable: ""
   [                # Creates a new list
    C73             # Char 73 = I
       d            # Standard variable: " "
        "<"         # String: "<"
           3        # Number 3
            pd      # Prints " ", the leading whitespace
              C     # Char
               -95T # -95T = 95 - 10 = 85. Char 85 = U

Second program
Output
I <3 U2

Program:
V85IqlPN1=+Z1=GC85)IqZ21=ZNB;jk[CZd\</.n01dG2

                                              # implicit Z = 0
V85                                           # For N in range(85)
   I                                          # If
    qlPN1                                     # Length of the prime factors of N equals 1
         =+Z1                                 # Z = Z + 1
             =GC85                            # G = Char 85 = U
                  )                           # Ends the if statement
                   IqZ21                      # If Z equals 21(th prime)
                        =ZN                   # Z = N (73)
                           B                  # Break out of the for loop
                            ;                 # Infinite ), to close open parentheses
                             jk               # Join ""
                               [              # New list
                                CZ            # Char Z = Char 73 = I
                                  d           # Standard variable: " "
                                   \<         # Single character '<'
                                     /        # Floored division
                                      .n0     # Pi, 3.14159...
                                         1    # Divide by 1 and round down
                                          d   # Standard variable: " "
                                           G  # G = C85 = U
                                            2 # Number 2

remember to write # Pyth, safe, 2 programs, 63 bytes; Score 68

@ev3commander, thanks for noticing!

Befunge, Safe, 2 programs, 228 bytes; Score 65
Interweaved programs
7b*2"!+:,l9ooa"v +2^*<>+:::v,v
  1- v2:,+9 -,\,,<$+":4b*,
v>"i g>:nb:"^,2$+,1'g#
+0^"gs "-*<  :-*,n,
v\,a3+v
-9*b6-3b ,*a<b:u,+|11 B'<
,:+>19v>,:'m+:9,:+3a^:,:a+"c*@9a, >': 'e^
<^;*+<v" gr"< ^
     >@,"+*or:\*:3pa, g"^0>'f^8<;

Output, first program
Output, first program

Output, second program
Befunge programming is cool!

I doubt this will be a easy one to crack. In fact you should just give up now.
Who needs 132 points anyway?
Answer
Program 1:
7b*2+:,9a+2*+:::,1-:,\5-,\,,4b*,v>::,2+,'+0g\1-:,\,3+v
-9*bb,,+1,:+1,:+9,:+3,:+c*9a,: '<^;    @,+*:\*:3a,g08<;

Output, first program

Program 2:
"!loo"v ^<>vv
   v2+9 <$+":
>"i gnb"^$1g#
^"s "*<  -*n,
va6-3 *a<b:u|1 B'<
>9v>'m:a^:a"@ >'e^
*+<v"gr"<^
   >"orp "^>'f^

Befunge programming is cool!

No, no - change that source code back. As soon as you post it, it's the code you use, otherwise, it's unfair.

@VoteToClose I realized the code had an error and was invalid. I can  change the code or the output text, which would be better?

Oh. Uh. Never mind then. (insert something about checking code first here) Make sure it's clearly been changed, though.

<1 hour left for people to try. I gave up already...

Vitsy, cracked, 2 programs, 15 bytes; Score -16
Interweaved Programs
a'5oF'2\\aI/NZO
Vitsy is so pretty, so clean. Look into its source, and be awed.
Output, first program
NaNo
Output, second program

That's 121 newlines.

With 32766 possibilities, this is almost brute-force-able :P

@Eridan I would be so pissed if someone bruted this. Seriously, don't brute force this beauty that is Vitsy. You must caress it, must take good care of it, nuture it...

@Eridan Also, that would take 32766 seconds, because Vitsy's a little slow. c:

It's a nice itsy bitsy Vitsy!

Cracked. (fairly and squarely)

Well that was a lot shorter than 9 hours of brute-forcing

Ruby, cracked, 2 programs, 64 bytes; Score -16
Interleaved
p w,%=?(w.ord,40,?)(;"jb inv inv is{2").bytes{|*b|?aput%?c} b-w}

Output
1st program
"bananas"

2nd program
BANANAS

Both outputs have trailing newlines.

Cracked.

JavaScript (ES6), safe, 2 programs, 255 bytes; Score 65
Interleaved programs
aalleerrtt((l=[](+(!l[=[l])+="(l "=l+[]l][[+l>=+1l]]=l+=>(l>l=>l=l<l,")"+l+(l(=l>l>=l)=+ (l)l+= +l)l+=>((ll==l)>(l=l)+l++ ()l+>l()+(l=>l(l===l>l=l)(l()l>=l)+))+""(l +(=""l=+)+(l+l(=)l<)+(=l+)+l++(ll=<<l)+++l)(l+=(=l(==ll)=>l+<l()(ll=))))(l<=l)<l)+(+l<l)))

Output of First Program
false12truetruetruefalse

Output of Second Program
falsefalseundefinedtruetruetruetruefalse116truetruefalse

I tried to use the characters (l)+=<> as much as possible. The rest is just type conversion.
First program
alert((l=[l=" "][+l>=+1]=l=>l>=l<l,""+l(l=l>=l)+ +l)+((l>=l++ )+((l=>l=l>=l)(l>=l))+(l="")+(l+=l<=l)+l+(l=l)+(l==(l=>l<l)(l))))

Second program
alert((l=[]+![])+(l=l+[l][l]+(l>=l)+(l>=l)+ (l=l=>l==l)(l)+l(l>l)+(l==l(l))+"" +(l=+l())+(++l<<++l)+(l==l)+(l=(l<=l)<l)+(+l<l)))

Gave you the bounty. Thanks for the leaderboard!

JavaScript ES6, cracked, 2 programs, 255 bytes; Score -16
Good job @Bas! GG.
trvya{"fru nxcti;on{;ale"r;Otb(j(fe=c>t(.kfe.yrs(efv)e}rcsate(cf+h(e~)~{ff,=Mast=h>!.posw?f((12),:M"a"t;hal.Ee)r))t)((nfe(wf A(rfr(a0y/(909)) +.f(7/f5il)l()0))+.fma(pf()(x,+`i$,{ff)}=>i`/.s3p)l).ijt`o`.imn(ap"("e)=.>repela.cceh(/ar.Co.d/egA,t""())*)2}3))}

Output 1:
36666666666666643333333333333336323666666666666668333333333333333231366666666666666833333333333333323026666666666666682333333333333332292666666666666668233333333333333228266666666666666823333333333333322726666666666666682333333333333332262666666666666668233333333333333225266666666666666823333333333333322426666666666666682333333333333332232666666666666668233333333333333222266666666666666823333333333333322126666666666666682333333333333332201666666666666668133333333333333219166666666666666813333333333333321816666666666666681333333333333332171666666666666668133333333333333216166666666666666613333333333333341516666666666666661333333333333334141666666666666666133333333333333413166666666666666613333333333333341216666666666666661333333333333334111666666666666666133333333333333410666666666666666333333333333334966666666666666633333333333333486666666666666673333333333333337666666666666667333333333333333666666666666666733333333333333356666666666666673333333333333334666666666666666533333333333333353666666666666666533333333333333352666666666666666733333333333333331666666666666666633333333333333330

Output 2:
2645,1403,1426,759,2645,1449,2346,920,1127,943,1334,782,782

cracked?

@Bas indeed! Nice work.

PHP, cracked, 2 programs, 71 bytes; Score -16
Interleaved
$ec=tchR;$ho =qs;$cu=$ho.$tc.e_me.$tha(.'p^l/it]';e.cchoo.$c('[$$h'));;

Output
1st program
Array

2nd program
\^/\]co\[\$

Note: Notices should be suppressed.

Are you sure this isn't missing one space?

@primo Argh, you're right. I have fixed it. Sorry. I assume you've cracked it already? :)

Cracked.

Malbolge, 2 programs, 194 bytes; Score 65
Interweaved
D'`D$'#`pK~A5:]|3!W1ICw;A|RXsWP0xgN;BLeJmd[c#bGa!`3p%n$BS9?~m*,+N)6ii9E%CAxw"Y!Xtbslw2SR|n^gf)9ex+ZLphuan`s_l%F2bS[ZRYn}@gVfUey+SL;QPba`O_s^$[MZR_K^JWO{N>G=kY.XJQuCHUAT@65d>QJ&nN<0;FjJ,H@G@9d]JQ

Output 1
haha nope

Output 2
malbolge

It was only a matter of time.
Programs
O1
D'`A:]\!I;|XWxgBedcba`pn9m*6iiE%CA"!bw|^)9xZpunsl2SRngfe+Lba`_^$\[Z_^W{>=YXQuUT65QJnN0FjJ,HG@dQ

O2
D'`$#pK\~5|3W1CwARsP0N;LJm[#G!3%$BS?~,+N)9xwYXtsl2SRngfe+Lha`_%Fb[ZY}@VUyS;QPOsMRKJONGk.JCHA@d>&<;@9]J

https://www.youtube.com/watch?v=D5wUr4Lut4A

Perl, safe, 2 programs, 102 bytes; Score 66
sprint""@(u{[|<$/{W)xor$^ldH&~!<]#3,/H-61+e#]l#:l7o#3:3}>]3$^WS}[_$#:,=(~s#30-)3;)^#,]$")]>=">reverse]

First Output
Hello, World!

Second Output
Hello, World!

Solution
First Program:

print@{[<{World!,Hello}>]}[$,=~s)),$")=>rvrs]

Second Program:

 s""(u|$/)x$^H&~<]#3/-61+#]#:7#3:33$^WS_#:(#30-3;^#]]>"eee

Is your answer saved? Say so in the header.

@zyabin101 done.

PHP, cracked, 3 programs, 31 bytes; Score -16
This should be an easy one using 3 programs.
Interleaved
print ppprrriiinnnttt!!$x'0';;;

Output
1st program
1

2nd program
1

3rd program
1

Note: Notices should be suppressed.

Assuming notices are to be ignored (as in your other answer), you've been cracked..

@SuperJedi224 You're right. I've updated the answer. And nice solution. :)

Javascript, safe, 2 programs, 106 bytes; Score 66
alert(2ale98374rt("q883wope2jv+sjn[d]s^234j8kfdk7j9b|12f8ns7"[9]98+"jskfsd3"2+13()3892721+[]+{}*6^5|27&3))

Output 1
-35655169

Output 2
njskfsd7

Solution
Program 1
alert(2983748832+[]^234879|1287983213)

Program 2
alert("qwopejvsjndsjkfdkjbfns"[9]+"jskfsd"+(3892721+[]+{}*6^5|27&3))

Pyth, 2 programs, 61 bytes; Score 68/36 (if safe/cracked)
Interleaved programs
*vsC{`.m`DsPCd..[Gn9`T2vjkpv`/JmsC\Pid~T.n1tt`.VJp~T%n*TCG731

Output, first program
491670984540320247032212137862815

Output, second program
46252265449938954198657919684976120662891392853344868455756073
1063494620552721403954429737131814326362865215612332412466411486182225511644503132172962643458535768453543651970155938693047567602310634946205527214039544297371318143263628652156123324124664114861822255116445031321729626434585357684535

Shouldn't be too hard.

Frankly, that looks terrible. Then again, I don't know Pyth very well.

Well done me, I've lost the source code.

Japt, safe, 3 programs, 63 bytes; Score 36
The version of the interpreter that this was built for can be found here. Unfortunately, I've lost the originals, so I'll have to see if I can crack it myself...
Interweaved programs
"AARoooLv mLv m@(_y6Xpp33*  ay%2%|v2n"+95+'H+2   m@(Xdcq)q -A d

Output 1
112221174199804510029601998159214179608538147196191138431341951029363738456410116231158105100149362111411782137669714451962921697122751841161758017110476673747582101138199681951421371867326511541191741031345182116631134159

That's 222 digits, in case you were wondering.
Output 2
R!2,tR+dE34N('QM!2'e4Xx;e>+2YGaNsw`4Xs,Gk?(,Q>XFmta:d'Gk:xm~RNxwQklZ;tM+sm~M?ZEea?dw~ !(;`

Output 3
Hello, World!

Is your answer saved? You'd reveal the solution already.

@zyabin101 This is safe, but I've lost the solution. Plus, it doesn't even work with the current version of Japt! I'll add a link for the old version, then see if I can crack it myself.

Microscript II, safe, 2 programs, 44 bytes; score 68
Interleaved sources:
6$4sv{{3@0s>s"`+`"}s<s3320s*{1+s+K+s<}*p}*h`

Output, first program:
>=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"! >=<;:9876543210/.-,+*)('&%$#"!

Output, second program:
[5.477225575051661,2.340347319320716,1.5298193747370035,1.2368586720951604,1.1121414802511236,1.0545811871312343,1.026928034056542,1.0133745773683798,1.0066650770580947,1.0033270040510693,1.001662120702919,1.0008307153074985,1.0004152714285695,1.0002076141624645,1.0001038016938364,1.000051899500139,1.0000259494133834,1.0000129746225213,1.0000064872902181,1.0000032436398485,1.0000016218186092,1.0000008109089757,1.0000004054544056,1.0000002027271822,1.000000101363586,1.0000000506817917,1.0000000253408956,1.0000000126704478,1.000000006335224,1.000000003167612]

And here's the answer:
Program 1:
64s{30s>""s<32s{1+s>K+s<}*p}*h

Program 2:
$v{@s`+`}s30*`

JavaScript ES6, 2 programs, 225 bytes; Score 65/132 (if safe/cracked)
Interweaved:
 alaelretrt((((cb=>c=>b.replace(/.replace[a-(/[azA-Z]-z]/gi/g,a,s=>String=>String.fromCharCode(s.fromCharCode(("Z">=a.charCodeAt(0)?90:122)>=(a=a.charCodeAt(0+(s.toLowerCase())+13)?a<'n'?13:-13:a-26)))))))((""gfvbznfcyrg""))))

First output:
simple

Second output:
toast

Cracked. Thanks for a good puzzle.

Brainfuck, 4 programs, 251 bytes; 17/144 (if safe/cracked)
Interweaved programs
--[+++++--+[----++[+-->+[+++++><-]--++->->---<>--]<]+>><.+-+[-+.--[+-++]+.>->-+.-+-.>-+<-<][]>[----+---+>->->.-+<+<]]>>+--..++----+-++-.---+--++-+..----.-----.-.--.--++..-+++++.++-+++[-++-[-->>++++++<+]<>-+.++]++>.+[->++++.<]>+.[--->+<]>++.---.------.

Output, first program
Eridan
Output, second program
Ampora
Output, third program
PPCG
Output, fourth program
Code Golf

What is the specific Brainfuck variant, e.g. is there any cell wrapping/overflow, are the cells 0..255 or unlimited, etc.?

Candy, safe, 2 programs, 85 bytes; Score 66
See: Candy
75~z43+/k20*416+k-1612+1++k2
8343-k92k*4+5k~7*Ak70kR(4122
5612=x53bAR2((hkDXhZ*h)))ZZ??

Outputs:
51450000
1609944
Update:  This is the two programs followed by their interleaving:
7 ~z4  /k 0 41 +k  612   +k28 4 -k92k 4 5k~  Ak70k  41225612  53   2(  kD  Z*h)  Z  ?
 5   3+  2 *  6  -1   +1+    3 3     * +   7*     R(        =x  bAR  (h  Xh    )) Z?
75~z43+/k20*416+k-1612+1++k28343-k92k*4+5k~7*Ak70kR(41225612=x53bAR2((hkDXhZ*h)))ZZ??

Vitsy, 4 programs, 228 bytes; Score 17
(Uses an older version, which is linked)
Heeeyyyy @VoteToClose. I don't expect this one to be up long, but you never know… I love your language, now that I'm using it a lot!
Interweaved program
1E2P-0P1E^l*312359121E4/13+1*-205+-5Pv*92t\9\[931[2-\D+\*12/]1N5*[t22*^50\+[\72C]\[[2r***t]PC^s]]2TNL2l\*2v2-D2E12[+48/3*-]2\**v+i8+1D+++NL*5N]-*4Z525L5L2*26E/-{'^2N6+l"015v52\2[{v/\[1*12]/r+^ZDs"6p'TO2N{^v]1v{\/3N\[52*]*4-^*N\*

Output 1
2014794345195992700000000000000000000000000.00000049.2129129367736101

Output 2
679:;=>@ABDEFHIJLMNPQSTUWXY[\]_`b

Output 3
44.5'+26

Output 4
100000.315464876785728777498798913309289000000000000000000000000000000000000000000000000.000000

Good luck! I used the online interpreter, but it should work in the safe jar.

Programs
O1
El94+*2+Pt*t7\[rP^]N2248*2*8**2LLE{^N0v\[v1+DpN{v]v\N

O2
EPP^*E/3-05-v\[32\[52]***vDE2/-v++]Z

O3
12-1313111159991-\+12/152*0+\[2*]2Ll2-1+\+DN5-552*/-'+"5522\[*]rZ"6'O

O4
0252*2\[D*]N2^\[CtCs]T2\[3]*i1++LN452626l1{/12/^sT2^1{/3\[52*]*4-^*N\*

:D I didn't see this until just now! fangirls Just about to go to sleep as well, but I'll work on it.

Don't forget to mention that you're using a certain version... ;)

@VoteToClose Oh, yeah, right.

JavaScript, 2 programs, 255 bytes; Score 65/132 (if safe/cracked)
a=c(([]o[0]+[][0n]+[][0]s+[][0o]+"l")e+(((new .Date)+"l").osplit(" g")[8])+"".match((/aa/)+t([0o][1]+"b")).split(")").join("('").split("bn");Vconssole.blog(aA=[1]=.toUpperCase()+a[7]+a[13]+" '))"+a[4].toUpperCase()+"`"+a[5]+" "+a[15]+a[16]+a[17;]+a[018]);

First program output:
And I`m fine

Second Program output:
null

The second programs output is text and not JavaScript's:null
This should be easy for the robbers.

Is your answer saved? Reveal the solution.

Foo, 6 programs, 197 bytes; Score 5/192 (if safe/cracked)
Interweaved code:
&(@@11&5@@756&@04$+110)c5*@@1$*1+c52$&&@+15*@@2c$(c61>(51/6+10)@<*2$0c*-$0+6c*$6@1$+$c-01c@1c4$c$@/2&-)$50c++c(+$@2*$c2($+6c+c>0*(>+42&$1c+1$6+c--2@<$<5)c>$c>+7$$cc)-<++1+11$$cc)@2(32/$c)&+5*2$c"B"

Output from 1st program:

@
B

Note the tab on first line and trailing space on second line
Output from 2nd program:

<83.-

Note that the first line is blank
Output from 3rd program:

<=$)

Output from 4th program:

72}

Output from 5th program:

$#%*+&

Output from 6th program:

Foo

There is only one interpreter for Foo which i know of, you can find it here

Welcome to Programming Puzzles and Code Golf. Great first answer. If you need any help with the site, reply by including @wizzwizz4 in your comment.

JavaScript, 8 programs, 233 bytes; Score 2/384 (if safe/cracked)
OK, now I'm being evil:
aalaaalaalllelreeereatlrterlreer(trtr(t(("t(t(!ft(!u\(untc!(y!t[0![p(!ty2!0p6ioee]a[8+0[0tbon(\o!fuo0)fb0 0 |(|h!6["t!Z5y!{!ze"[)0pb}b]01e]+"+")"+o\uo[]0]o0b1f110 al)]4d+1")+)]cl)"("\o!fu0u))0.4slc\incu00c6e(4,f"t)8))ion(){}+![])+"")

1st Output:
false

2nd Output:
true

3rd Output:
heLLo

4th Output:
2015

5th Output:
0

6th Output:
good

7th Output:
fine

8th Output:
string

The snippet says 2/384 as the score.

Python 2, 8 programs, 92 bytes; Score: -16
Another easy one:
ppprirnriipnnprtp rrpti"piirnrinio"ntt n n"bt"Tunht" t"is ""dot n"t ohhe"el""w lo"aleal"l"s"

8 outputs:
This

hello

well

no

alas

but

oh

done

Cracked. BTW, you don't need to put spaces after print in Python 2.

That was quick, this was probably the easiest answer.

Python 2, safe 2 programs, 148 bytes; Score 65
execexec'prin'""it`sum(map(ormpd,(stor.rparrt""('""thellitio"on.__n"'ame_)'_*".3**/7".__len.__()re)pl[ace++-2(]))**061`[+*+2]'.re'"_pl'a)ce(*"+:")

Output 1:
Hello world...

Output 2:
188381387815229576775053627587460257651836527329727069542076068076585927926328856199896

Program 1:
exec'""import""(\'""hello""\')'.replace(*'"_')

Program 2:
exec'print`sum(map(ord,(str.rpartition.__name__*".3**/7".__len__())[++-2]))**061`[++2]'.replace(*"+:")


text:
Find the Interwoven Source Codes (Robbers)
This is the robbers' thread. For the cops' thread, go here.
Introduction
For this Cops/Robbers challenge, the cops will write output-producing programs and interweave them together. It is the robber's job to pick apart the cops' programs to produce the desired outputs.
Robber rules
Robbers will try to find the different programs that people post in submissions to the cops' thread (linked above). If a robber solves a cop's code, they must post the separated programs and match them with their outputs in an answer here and post that they have cracked the code on the cop's answer.
Scoring
There are two components that are added together when scoring a cracked submission.

2 to the power of the number of different programs used in the cop's answer
Round the number of bytes in the interweaving down to the nearest power of 2.

For example, if a robber cracks TIliGoEnR as being TIGER and lion, then the robber receives 2^2+8=12 points.
The winner of the robbers' challenge will be the person with the most points after a sufficient period of time for people to participate.

(Who wants to help with a snippet?)

Vitsy, 12 points
'o'2\I/NO

Try it online!
a5F\aZ

Try it online!
The NaN in NaNo was a dead giveaway.
The obvious way to push NaN would be to divide 0 by itself, 2\I pushes the input length (0) twice, / performs division, and N prints a float.
We're left with printing o, and 'o' is a string literal that O prints.
Whatever characters were left had to belong to the other program. In fact, a pushes a linefeed, 5F the factorial of 5 (120), \a turns that into 120 linefeeds, and Z prints the entire stack.

So fancy, so beautiful. Well done. +1

PHP, 68 points
$c=tR;$h=s;$c=$h.$c._.$h.plit;echo$c($h);

Output: Array
echo quotemeta('^/]'.co.'[$');

Output: \^/\]co\[\$

I like this submission, because it relies on a few lesser know features - one might say misfeatures - of PHP. PHP allows function references to be assigned to variables, so for example:
$f = function($a, $b) { return pow($a, $b); };
echo $f(2, 4);

would do exactly what you expect. As would:
$f = pow;
echo $f(2, 4);

...except it's not doing what you think. $f = pow does not assign a function reference to $f (that would make too much sense, right?), but rather the string 'pow'. The implication is that any string may be used as a function call, if it represents the name of a defined function. Bad code waiting to happen. I don't even know why you'd want to allow this.
Another misfeature of PHP, is that function names and keywords are case-insensitive. I wish I were joking. So echo pow(2, 4), ECHO POW(2, 4), and EcHo PoW(2,4) are all functionally equivalent.
The last misfeature on showcase is that whenever an array is typed as a string, such as for printing, the result is always the amazingly helpful string Array. Take a moment to reflect on the fact that someone actually did this deliberately.
So in the first program, @insertusernamehere builds up the string stR_split, this string is used as a function reference (which, for reasons above, actually works), and the result, an array, is output.

Nice work that comes with a great explanation. :)

BitShift, 2^2 + 64=68 points
cops thread
0101100110110101001001010110111011101110111011101101010

prints ! ?
1011101110111011101110110101000000000110010101101101010

prints ? !
Code
0101100110110101001001010110111011101110111011101101010 # '! ?'
01011001101101010 # '! '
0101              # XOR 0 with 128
                  # Making current value 128 (1000 0000)
    10            # Bitshift 1 to left making 10000000 -> 01000000
      01          # Bitshift 1 to left making 01000000 -> 00100000
        101       # XOR 00100000 with 1 making it 00100001
           101010 # print 00100000 which is binary for !
010010101         #
010               # XOR 00100001 with 1 making it 00100000
   010101         # print 00100000 which is binary for <space>
10111011101110111011101101010  # '?'
101               # XOR 00100000 with 1
   1              # Bitshift 1 to left making 00100001 -> 01000010
                      # This gets repeated till 01000010 becomes 0111111
101010                # print 0111111 which is binary for ?

I will add some description later(split the code in the parts that print individual parts)

Can someone explain how to calculate the score I don't quite understand the calculation

Well done. The score is calculated by 2^programs + 256/bytes=points. In this case it's 2^2 + 256/128=6 points. I think this will be edited though, because as it is now, fewer byte count programs receive a higher bonus for robbers. Which feels off

@Bas As of yesterday, that was changed.

Ruby, 68 points
First:
p %w(b n n s)*?a%?}

Second:
w,=?(.ord,40,?);"jivivi{2".bytes{|b|putc b-w}

It followed pretty naturally from working out the end, with putc.

Whoops, I had a slightly different intended solution with one more weird syntax trick, but I guess I'll keep that in my back pocket for another challenge. Well done!

JavaScript, 68 points
Cops thread
First program
Output: ffttff
(![]+[])[+[]]+(![]+[])[+[]]+(!![]+[])[+[]]+(!![]+[])[+[]]+(![]+[])[+[]]+(![]+[])[+[]]

Second program
Output: 1010
+!![]+[+[]]+(+!![])+(+[])

Interweaving
+     !!    []             +                [    +[]]          +      (+     !![])                 +     (+[])
 (![]+  [])[  +[]]+(![]+[]) [+[]]+(!![]+[])[ +[]]    +(!![]+[]) [+[]]+  (![]+     [])[+[]]+(![]+[]) [+[]]

Javascript, 132 points
Program 1
var x;{;alert((f=>(f.reverse(f+~~f,Math.pow(2,Math.E))))(new Array(99).fill(0).map((x,i,f)=>i/3)).join("").replace(/../g,""))}

Program 2
try{"function";Object.keys(f)}catch(e){f=s=>!s?f(1):"";alert(f(f(f(0/0) +f(7/5)))+f(f)+`${f}`.split``.map(e=>e.charCodeAt()*23))}

Whew. This was terrible.
After a lot of debugging I found out that after calling (parts of) the 2nd program, it wouldn't run again. This is because the global variable f was still assigned. Because of f being assigned, the try/catch didn't fail on Object.keys(f). I don't know if this is a sneaky trick or unintentional but it caused me a headache.
Also, I believe the output of the first program is platform specific.
/../g removes all characters on my machine, because of the regex . which means any character. Escaping it with /\../g works however, I hope someone can shed more light onto this. Also, my output is prone to rounding errors, perhaps some global javascript variable can change this?
Output
32666666666666643233333333333336323166666666666668313333333333333231306666666666666830333333333333323029666666666666682933333333333332292866666666666668283333333333333228276666666666666827333333333333322726666666666666682633333333333332262566666666666668253333333333333225246666666666666824333333333333322423666666666666682333333333333332232266666666666668223333333333333222216666666666666821333333333333322120666666666666682033333333333332201966666666666668193333333333333219186666666666666818333333333333321817666666666666681733333333333332171666666666666668163333333333333216156666666666666615333333333333341514666666666666661433333333333334141366666666666666133333333333333413126666666666666612333333333333341211666666666666661133333333333334111066666666666666103333333333333410966666666666666933333333333334986666666666666683333333333333487666666666666677333333333333337666666666666667633333333333333656666666666666753333333333333354666666666666674333333333333334366666666666666533333333333333353266666666666666523333333333333352166666666666666713333333333333331066666666666666603333333333333330

This was tested on chrome 46 (my only browser), Windows 7.
I hope this is still a valid submission, despite the different output

There was a slash in there, I don't know how it was missed. Good job, though! This is correct. I will update my submission when I am not on mobile ;)

Java, 132 points
Cops thread
First program:
interface c{static void main(String[]g){System.out.println("Hell"\u002bg.length);}}

Second program:
class i{public static void main(String[]n){System.out.print("Bye!\n");}}

The first program outputs Hell0 and the second program outputs Bye!

Ah, I was an hour too late. Good job.

JavaScript (ES6), 68 points
Program 1
alert((c=>c.replace(/[a-z]/gi,a=>String.fromCharCode(("Z">=a?90:122)>=(a=a.charCodeAt(0)+13)?a:a-26)))("fvzcyr"))

Program 2
alert((b=>b.replace(/[a-zA-Z]/g,s=>String.fromCharCode(s.charCodeAt(0)+(s.toLowerCase()<'n'?13:-13))))("gbnfg"))

Interweaved programs
 alaelretrt((((cb=>c=>b.replace(/.replace[a-(/[azA-Z]-z]/gi/g,a,s=>String=>String.fromCharCode(s.fromCharCode(("Z">=a.charCodeAt(0)?90:122)>=(a=a.charCodeAt(0+(s.toLowerCase())+13)?a<'n'?13:-13:a-26)))))))((""gfvbznfcyrg""))))
 al e r t  ( ( c =>c             .replace   (/[a     -z]/gi  ,a  =>String                       .fromCharCode(("Z">=a              ?90:122)>=(a=a.charCodeAt(0                 )+13)?a           :a-26)))    ( "  fv z  cyr " ))
   a l e rt ( ( b   =>b.replace(/        [a-    zA-Z]      /g  ,s        =>String.fromCharCode(s                     .charCodeAt(0)                           +(s.toLowerCase()       <'n'?13:-13        )))) ( "g  b nf   g "  ))

This would've been a lot harder, had the cop torn apart the keywords. ;)

I manually interwove it and got lazy, but good job. I tried being sneaky. Oh well. Actually thank you for cracking this one because I lost The original unweaved programs somehow.

PHP, 24 points
Program 1
print!0;

Program 2
print!$x;

Program 3
print print'';

Tested with http://sandbox.onlinephpfunctions.com/.

Python 2, 320 points
print "This"
print "hello"
print "well"
print "no"
print "alas"
print "but"
print "oh"
print "done"

source: Stack Exchange

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

sort: votes


text:
String Zip and Sort
Given a list of strings, output a single string formed by taking a character from each string at each position, sorting them by ASCII ordinal, and appending them in order to the output string. In other words, for n input strings, the first n characters of the output will be the first characters of each of the inputs sorted by ordinal, the second n characters of the output will be the second characters of each of the inputs sorted by ordinal, and so on. You may assume that the strings are all of equal length, and that there will be at least one string. All strings will be composed of only ASCII printable characters (ordinals 32-127).
Reference implementation in Python (try it online):
def stringshuffle(strings):
  res = ''
  for i in range(len(strings[0])):
    res += ''.join(sorted([s[i] for s in strings],key=ord))
  return res

Examples:
"abc","cba" -> "acbbac"
"HELLO","world","!!!!!" -> "!Hw!Eo!Lr!Ll!Od"

Rules

Standard loopholes are forbidden
This is code-golf, so shortest answer in bytes wins

Leaderboard
The Stack Snippet at the bottom of this post generates the leaderboard from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

GS2, 4 bytes
*Ü■/

This reads the strings from STDIN, separated by linefeeds.
The source code uses the CP437 encoding. Try it online!
Test run
$ xxd -r -ps <<< '2a 9a fe 2f' > zip-sort.gs2
$ echo -e 'HELLO\nworld\n!!!!!' | gs2 zip-sort.gs2
!Hw!Eo!Lr!Ll!Od

How it works
*       Split the input into the array of its lines.
 Ü      Zip the resulting array.
  ■     Map the rest of the program over the resulting array.
   /        Sort.

Haskell, 39 36 bytes
import Data.List
(>>=sort).transpose

Usage example: ((>>=sort).transpose) ["HELLO","world","!!!!!"] -> "!Hw!Eo!Lr!Ll!Od".
Transpose the list of strings, map sort over it and concatenate the resulting list of strings (>>= in list context is concatMap).

i came up with exactly this!

I did not; I keep forgetting to exploit the Monad instance for things like lists.  (+1)

Pyth, 5 bytes
Zips(C) the input(Q), Maps Sort, then sums.
sSMCQ

Try it online.

TeaScript, 9 bytes
_t¡ßlp¡)µ

TeaScript has all the right built-ins implemented in all the wrong ways.
Try it online
Ungolfed
_t()m(#lp())j``

Explanation
_t()        // Transposes input array
    m(#     // Loops through inputs
       lp() // Sorts characters by char code
     )
j``         // Joins back into string

@intrepidcoder works fine for me. Perhaps your browser has cached some files? Perhaps clearing your cache might work. I'm using Safari though. I'll try refreshing the files

JavaScript (ES6), 57 bytes
a=>a[0].replace(/./g,(c,i)=>a.map(w=>w[i]).sort().join``)

CJam, 5 bytes
q~z:$

Try it here.

I beat you by like 14 seconds ;P.

Python, 50 48 bytes
lambda x,y=''.join:y(map(y,map(sorted,zip(*x))))

Thanks to @xnor for -2 bytes!

You can save "".join to a variable.

Oh, I had no idea. Thanks!

Vyxal d, 3 bytes
∩vs

Try it Online!

Octave, 15 bytes
@(a)sort(a)(:)'

Example:
octave:1> (@(a)sort(a)(:)')(["abc";"cba"])
ans = acbbac
octave:2> (@(a)sort(a)(:)')(["HELLO";"world";"!!!!!"])
ans = !Hw!Eo!Lr!Ll!Od

K, 10 bytes
,/{x@<x}'+

Join (,/) the sort of ({x@<x}) each (') of the transpose (+) of a list of strings.
In action:
  ,/{x@<x}'+("HELLO";"world";"!!!!!")
"!Hw!Eo!Lr!Ll!Od"

Simple, but K is hurt a bit here by not having a single-character sort function and instead dividing the operation into a scatter-gather index operator @ and a primitive which yields the permutation vector which would sort a list <.

Stax, 5 bytes
LMFop

So close to LMNOP :(
Run and debug it at staxlang.xyz!
Put all inputs into one list of strings (L), and transpose this list (M). For each resulting string (F), sort (o) and print (p) it.

Pip, 5 bytes
SS*Zg
Attempt This Online!

Japt, 12 bytes 20
Ny m_q n q)q

Try it online!
Explanation
Ny       // Transpose inputs
  m_     // Maps through each new string
    q    // Split string
    n    // Sort string
    q    // Join
)q       // Join again

Julia, 46 bytes
x->(j=join)(map(i->j(sort([i...])),zip(x...)))

This creates an unnamed function that accepts an array of strings and returns a string. To call it, give it a name, e.g. f=x->....
Ungolfed:
function zipsort{T<:AbstractString}(x::Array{T,1})
    # Splat the input array and zip into an iterable
    z = zip(x...)

    # For each tuple consisting of corresponding characters
    # in the input array's elements, splat into an array,
    # sort the array, and join it into a string
    m = map(i -> join(sort([i...])), z)

    # Take the resulting string array and join it
    return join(m)
end

, 15 chars / 30 bytes
Ѩťªï)ć⇀ѨŌ$ø⬯)ø⬯

Try it here (Firefox only).
Just realized that Lodash's sortBy function works on strings, too.

C++14, 152 bytes
#include<iostream>
#include<regex>
[](auto s){for(int i=0;i<s[0].size();++i){auto r=""s;for(auto k:s)r+=k[i];std::sort(begin(r),end(r));std::cout<<r;}};

Not using any advantage of map+zip (guess why)
Ungolfed + usage
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

int main()
{
    auto lambda = [](auto s)
    {
        for (int i = 0; i < s[0].size(); ++i)
        {
            auto r = ""s;
            for (auto k : s)
                r += k[i];
            std::sort(begin(r), end(r));
            std::cout << r;
        }
    };

    std::vector<std::string> data = { "HELLO", "world", "!!!!!" };
    lambda(data);
}

Mathematica, 51 bytes
""<>SortBy@ToCharacterCode/@Transpose@Characters@#&

String manipulation in Mathematica is expensive...

Perl 6, 33 bytes
{[~] flat ([Z] @_».comb)».sort}

Example usage:
say {[~] flat ([Z] @_».comb)».sort}(< abc cba >) # acbbca

my &code = my $code = {[~] flat ([Z] @_».comb)».sort}

say code "HELLO","world","!!!!!"; # !Hw!Eo!Lr!Ll!Od

say ((<cba abc>),(<testing gnitset gttseni>)).map($code);
# (acbbac ggtentiststteisenngit)

Jelly, 3 bytes
ZṢ€

Try it online!
Only valid if considered as a full program: the resulting value is a list of strings, but when it's printed Jelly implicitly flattens it.
  €    Map
 Ṣ     sort
Z      over the columns of the input.

PHP, 92 91 bytes
for($argv[0]='';$a=array_column(array_map(str_split,$argv),$i++|0);print join($a))sort($a);

Try it online!
I'm confident this could be done shorter by not trying to use PHP's built-in array functions, but had to try!
Or 85 bytes
@Night2's swing, done shorter by not trying to use PHP's built-in array functions:
for(;''<$argv[1][$i++];print join($a))for($a=[];''<$a[]=$argv[++$$i][$i-1];sort($a));

Try it online!

@Night2 nicely done!  You should post that one as your own.  It's too bad that array_column won't work on an array of strings otherwise it'd be quite a bit more useful for CG. And of course having to skip $argv[0] is always a pain too...

Japt -P, 3 bytes
Õmñ

Try it here

PowerShell Core, 56 50 bytes
-join(($a=$args)[0]|% t*y|%{$a|% c*rs($i++)|sort})

-6 bytes thanks to mazzy
Try it online!

? Try it online!

Factor, 34 bytes
[ flip [ natural-sort ] map-flat ]

Attempt This Online!

rSNBATWPL, 39 bytes
x~strfor{flip$x}{y~y sort>}crush-with""

Try It Online!

GolfScript, 8 bytes
~zip{$}%

Try it online on Web GolfScript.
How it works
~         # Evaluate the input.
 zip      # Zip it.
    {$}%  # Map sort ($) over the resulting array.

Minkolang 0.13, 46 bytes
$od0Z2:$zIz:$xd0G2-[i1+z[di0c*+c$r]xz$(sr$Ok].

Try it here. Expects input like "HELLO""world""!!!!!" (so no commas).
Explanation
$o     Read in whole input as characters
d      Duplicate top of stack (the ")
0Z     Count how often this appears in the stack
2:     Divide by two
$z     Store this in the register (z)
Iz:    Length of stack divided by z (k)
$x     Dump one element from the front/bottom of stack
d      Duplicate top of stack (which is k)
0G     Insert it at the front/bottom of stack
2-     k-2

  [                              Open for loop that repeats k-2 times
   i1+                           Loop counter + 1 (i)
      z[                         Open for loop that repeats z times
        d                        Duplicate top of stack (which is i)
         i                       Loop counter (j)
          0c                     Copy k from front of stack
            *                    Multiply (j*k)
             +                   Add (j*k + i)
              c                  Copy character at position j*k+i to the top
               $r                Swap top two elements of stack (so i is on top)
                 ]               Close for loop
                  x              Dump the top of stack (dump i)
                   z$(           Start a new loop with the top z elements
                      s          Sort
                       r$O       Reverse and output the whole (loop) stack as characters
                          k      Break - exits while loop
                           ].    Close for loop and stop

Clojure/ClojureScript, 43 bytes
#(apply str(mapcat sort(apply map list %)))

Creates an anonymous function.  Written in a ClojueScript REPL, should also be valid Clojure.
Enter it here, then call via (*1 ["HELLO" "world" "!!!!!"]).  Or do (def f *1) and then use (f ["abc" "cba"]).

Ceylon, 166
String z(String+l)=>String(expand(t(l).map(sort)));[T+]n<T>(T?+i)=>[for(e in i)e else nothing];{[X+]*}t<X>([{X*}+]l)=>l[0].empty then{}else{n(*l*.first),*t(l*.rest)};
While Ceylon has a zip function, it takes only two iterables instead of an iterable of them. unzip, on the other hand, takes an iterable of tuples, and I don't want to convert my strings into tuples. So I implemented my own transpose function, inspired by a Haskell implementation which Google found for me somewhere.
// zip-sort
//
// Question:  http://codegolf.stackexchange.com/q/64526/2338
// My answer: ...

// Takes a list of strings (same length), and produces
// a string made by concatenating the results of sorting
// the characters at each position.
String z(String+ l) =>
        String(expand(t(l).map(sort)));

// Narrow an iterable of potential optionals to their non-optional values,
// throwing an AssertionError if a null is in there.
[T+] n<T>(T?+ i) =>
        [for (e in i) e else nothing];

// Transpose a nonempty sequence of iterables, producing an iterable of
// sequences.
// If the iterables don't have the same size, either too long ones are
// cut off or too short ones cause an AssertionError while iterating.
{[X+]*} t<X>([{X*}+] l) =>
        l[0].empty
        then {}
        else { n(*l*.first), *t(l*.rest) };

The types of n and t could be defined much more general, but this is Codegolf ;-) (n is a special case of what I proposed as assertNarrow two weeks ago).

Red, 85 bytes
func[b][repeat c length? b/1[foreach a sort collect[foreach m b[keep m/:c]][prin a]]]

Try it online!

Brev, 53 41 bytes
(as-list flatten(over(sort args char<?)))

Example:
((as-list flatten (over (sort args char<?))) "HELLO" "world" "!!!!!")

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

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


text:
I like to move it move it
King Julian needs to get through the jungle, but he's feeling lazy. He wants a computer to be able to calculate a route through the jungle for him.
Using STDIN get a map of the jungle for the computer to crack. It will follow the following format:
01001E
010110
000P00
1100J1
S00111

The way the jungle map works is:
0 is ground that Julian can move along.
1 is dense impassable jungle.
P is an area with predators in it, that you must avoid at all costs.
J is relatively thick jungle. Julian's minions can break through one of these before tiring.
S is where Julian starts. It can be anywhere on the map.
E is where Julian wants to go; the end of the path. It also can be anywhere on the map, just like any other tile.
Every character is a tile on the map. Line breaks indicate a new row of tiles. If STDIN in your language does not support line breaks, the line break must be replaced by a space to signify a new row.
To move between the tiles, you must output a string using STDOUT containing the following special characters:
F - Forward
B - Backward
L - Rotate Julian left (90 degrees anticlockwise)
R - Rotate Julian right (90 degrees clockwise)
M - Minions destroy a J tile 1 tile forward from Julian, if there is one (M just clears out the tile, you still have to move onto it)
A possible output would be:
RFFLFRFMFLFRFLFF

Which solves the map above.
Notes:

If your program outputs a solution which hits predators, game over.
If you hit impassable jungle, you just bounce back to where you were before you ran into dense jungle, facing the same way. (Toward the jungle)
Julian starts facing upwards. (^ That way ^)
The output doesn't have to be the fastest solution, FFF and FBFBFBFBFBFFF are the same. However, outputting the fastest possible solution gives a -10% byte count bonus.
If a map is invalid, STDOUT 'Invalid map.' (That includes if the map is unsolvable)
A map cannot have rows or columns of different lengths; that makes it invalid.

Your answer should somewhat follow this format:
#Language name, *n* bytes

    code

Explanation (optional)

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

Your solution example has Julian walking straight into a predator. Something like RFFLFRFMFLFRFLFF should work instead.

@Emigna, Oops. I got mixed up between thick jungle and a predator's lair...

Does a P tile really add something different from a 1 tile?  I can't really imagine a plausible solution that treats them any differently.

@dan1111 The P tile kills Julian when he travels over it. The 1 tile Julian can't pass through, but if Julian hits it he doesn't die, he just bounces back.

@Tobsta, yes, I understand.  But does that make a difference?  It seems like any successful solution would just avoid 1 and P tiles.

@dan1111 Yes, it would.

Do minions have a limit on how many tiles they can destroy?

@JAtkin no, they don't.

Do you have more mazes?

Clarification request: In comments, you said minions don't have a limit on how many tiles they can destroy, but how does that fit with "Julian's minions can break through one J before tiring"? I assumed that meant a solution could only use M once.

Groovy, 656 bytes
That was too long...
i={println"Invalid map."
System.exit(1)}
m=[]
q=System.in.newReader()
r=q.readLine()
while(r!=''){m<<r
r=q.readLine()}
o=m[0].size()
m.each{if(it.size()!=o)i()}
f=[0]*4
m.eachWithIndex{l,n->s=l.indexOf('S')
e=l.indexOf('E')
if(s!=-1){f[0]=s;f[1]=n}
if(e!=-1){f[2]=e;f[3]=n}}
v=[]
t={x,y,d->if(d.contains([x,y])|y>=m.size()|x>=o|x<0|y<0)return
a=m[y][x]
def p=d+[[x,y]]
if(a=='E')v=p
if(a=='J'|a=='0'|a=='S'){t(x-1,y,p)
t(x+1,y,p)
t(x,y+1,p)
t(x,y-1,p)}}
t(f[0],f[1],[])
if(!v)i()
o=0
p=''
v.inject{t,s->
c=m[s[1]][s[0]]
k=[t[0]-s[0],t[1]-s[1]]
z=[[0,1]:0,[1,0]:1,[0,-1]:2,[-1,0]:3][k]
p+=((((o-z)==0)?'':(z>0?'R':'L'))+(c=='J'?'M':'')+'F')
o=z
s}
println p

Output for the maze:
RFFLFRFMFLFRFLFF

Ungolfed:
invalid = {
    println "Invalid map."
    System.exit(1)
}
map = """01001E
010110
000P00
1110J1
S00111""".split('\n')

//map = [""]// TODO remove this, this is type checking only
//map.remove(0)
//reader = System.in.newReader()
//line = reader.readLine()
//while (line != '') {
//    map << line.replace('P','1')
//    line = reader.readLine()
//}

size = map[0].size()
map.each {if(it.size() != size) invalid()}

startAndEnd = [0,0,0,0]
map.eachWithIndex {it, idx -> s=it.indexOf('S');e=it.indexOf('E');
    if(s!=-1){ startAndEnd[0]=s; startAndEnd[1]=idx}
    if(e!=-1){ startAndEnd[2]=e; startAndEnd[3]=idx}}

def validPath = []

testMove = {x, y, visited ->// visited is an array of x y pairs that we have already visited in this tree
    if (visited.contains([x,y]) || y>=map.size() || x>=size || x<0 || y<0)
        return;

    def valueAtPos = map[y][x]
    def newPath = visited + [[x,y]]

    if (valueAtPos == 'E') validPath = newPath
    if ((valueAtPos == 'J' || valueAtPos == '0' || valueAtPos == 'S') && !validPath) {
        testMove(x-1, y, newPath)
        testMove(x+1, y, newPath)
        testMove(x, y+1, newPath)
        testMove(x, y-1, newPath)
    }
}
if (!validPath) invalid()
testMove(startAndEnd[0],startAndEnd[1], [])

println validPath

orintation = 0
path = ''
validPath.inject {first, second ->
    def chr = map[second[1]][second[0]]
    def sub = [first[0]-second[0],first[1]-second[1]]
    println "acc:$first, second:$second"
    def newOrin = [[0,1]:0, [1,0]:1, [0,-1]:2, [-1,0]:3][sub]
    path += ((((orintation - newOrin)==0)?'':(newOrin>0?'R':'L')) + (chr=='J'?'M':'') + 'F')
    orintation = newOrin
    second
}
println "path: $path"

I will try this again in python soon to see if I can shorten it further.

Python3, 273 bytes
E=enumerate
def f(b):
 d={(x,y):v for x,r in E(b)for y,v in E(r)}
 q=[(i,[])for i in d if'S'==d[i]]
 for(x,y),p in q:
  if'E'==d[(x,y)]:return p
  for X,Y in[(0,1),(0,-1),(1,0),(-1,0)]:
   if d.get(t:=(x+X,y+Y))in['0','J','E']and t not in p:q+=[(t,p+['M']*(d[t]=='J')+[t])]

Try it online!


text:
Carrot Popularity Statistics
In the PPCG chatroom the Nineteenth Byte, using carets ^ (or carrots) is a way of indicating that you agree with one of the previously made comments just above yours.
A caret message consists solely of N ^ characters (where N is a positive integer) and it means agreement with the Nth previous message. So a single ^ means agreement with the message immediately previous, ^^ means agreement with the message two lines up, ^^^ means agreement with the message three lines up, and so on.
Additionally, when a caret message X is in agreement (a.k.a. pointing towards) another caret message Y, then X is said to be in agreement with what Y is in agreement with. There may be multiple layers of this and, in the end, all caret messages are indicating agreement with one non-caret message.
For example, if a chat transcript looks like this: (one message per line)
I like dogs           [line 1]
I like cats           [line 2]
^                     [line 3]
^^^                   [line 4]
^^                    [line 5]
I like turtles        [line 6]
^                     [line 7]
^^^                   [line 8]
^^                    [line 9]

Then lines 1, 2, and 6 are non-caret messages and all the others are caret messages which point to non-caret messages:

Line 3 points directly to line 2.
Line 4 points directly to line 1.
Line 5 points to line 3, which points to line 2.
Line 7 points to line 6.
Line 8 points to line 5, which points to line 3, which points to line 2.
Line 9 points to line 7, which points to line 6.

Thus, including the users who wrote the non-caret message (and assuming people don't caret their own message) we can conclude that:

2 people agree with I like dogs (Lines 1 and 4.)
4 people agree with I like cats (Lines 2, 3, 5, and 8.)
3 people agree with I like turtles (Lines 6, 7, and 9.)

Challenge
Write a program or function that takes in a multiline string similar to the example above where every line represents a chat message, with older messages coming first.
Every line will have at least one character and there will be at least one line. All messages will either be caret messages consisting solely of ^'s, or be non-caret messages consisting of letters and spaces ([ a-zA-Z]+ in regex).
For every non-caret message, in any order, output the number of people that agree with it in some clear format that contains the message text, e.g.
2 - I like dogs
4 - I like cats
3 - I like turtles

or
I like cats (4)
I like dogs (2)
I like turtles (3)

or
{"I like cats" : 4, "I like turtles" : 3, "I like dogs" : 2}

You can assume that:

People always agree with their own messages and do not caret themselves.
No two non-caret messages are identical.
Caret messages won't point to things before the first message.
Lines will not contain leading or trailing spaces.

The shortest code in bytes wins.
Test Cases
bread is bread

1 - bread is bread

---

animals are fuzzy
^
^
^
^^^
^^
^^^^^^

7 - animals are fuzzy

---

pie
^
^^
pi
^
^^
^^^^
^
^^^^^
^^^^^
^^^
^^^^
^^
^
^^^^^^^^^

9 - pie
6 - pi

---

a
b
c
^
^
^

1 - a
1 - b
4 - c

---

a
b
c
^
^^
^^^

1 - a
1 - b
4 - c

---

a
b
c
^^^
^^^^
^^^^^

4 - a
1 - b
1 - c

---

W
^
^^
X
^^^
^^^^
Y
^^^^^
^^^^^^
Z
^^^^^^^
^^^^^^^^

1 - Y
3 - X
1 - Z
7 - W

---

ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqretuvwxyz
^
ABCDEFGHIJKLMNOPQRSTUVWXYZ  abcdefghijklmnopqretuvwxyz

2 - ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqretuvwxyz
1 - ABCDEFGHIJKLMNOPQRSTUVWXYZ  abcdefghijklmnopqretuvwxyz

---

I like dogs
I like cats
^
^^^
^^
I like turtles
^
^^^
^^

2 - I like dogs
4 - I like cats
3 - I like turtles

Related.

Next year, we can solve this problem with unicode: http://blog.unicode.org/2015/05/unicode-90-candidate-emoji.html #1F955 carrot

@RobertFraser

CJam, 18
qN/{_'^e=$\;}%$e`p

2 bytes eliminated thanks to Martin :)
Try it online
Explanation:
q         read the input
N/        split into lines
{…}%      transform each line as follows:
  _       make a copy
  '^e=    count '^' characters in the string
  $       copy the corresponding earlier line from the stack
           if 0, it copies the current line again
  \;      discard the current line (from before the copied line)
          * after the loop, all caret lines have been replaced
          * with the original messages they agree with
$         sort the messages
e`        RLE encode
p         pretty print

Pyth, 19 18 bytes
rSu+G@+HG_/H\^.zY8

Demonstration
A similar approach to aditsu, especially the rle part.
rSu+G@+HG_/H\^.zY8
  u           .zY      Reduce over the list input lines, starting with [].
                       G is the working value, H is the next input line.
   +G                  Append to the current value
      +HG              H prependeded to G
     @   _/H\^         Indexed at -(H.count('^')). This is H if no carets are in H,
                       or the appropiate distance from the end of G otherwise.
 S                     Sort
r                 8    Run length encode

JavaScript (ES6), 110 bytes
x=>(r={},l=x.split`
`,l.map((_,i)=>(a=n=>(m=l[n])[0]=="^"?a(n-m.length):r[m]=r[m]+1||1)(i)),JSON.stringify(r))

Explanation
x=>(
  r={},                   // r = results
  l=x.split`
`,                        // l = array of messages
  l.map((_,i)=>           // check each message
    (a=n=>                // n = index of the message to agree with
      (m=l[n])            // m = message
        [0]=="^"          // if this is a caret message
          ?a(n-m.length)  // agree with the message it points to
          :r[m]=r[m]+1||1 // else add one to this message's agreements
    )(i)
  ),
  JSON.stringify(r)       // return the results as a string
)

Test

<textarea id="input" rows="7">I like dogs
I like cats
^
^^^
^^
I like turtles
^
^^^
^^</textarea>

<button onclick='result.textContent=(

x=>(r={},l=x.split`
`,l.map((_,i)=>(a=n=>(m=l[n])[0]=="^"?a(n-m.length):r[m]=r[m]+1||1)(i)),JSON.stringify(r))

)(input.value)'>Go</button>

Python 2.7 - 122 114 bytes
def c(s):
 l=s.split('\n');c=len(l);d=[1]*c
 while c:
  c-=1
  if'^'in l[c]:d[c-len(l[c])]+=d[c]
  else:print l[c],d[c]

Pretty much the most straightforward solution there is, and not particularly golfed.

Mathematica, 83 77 bytes
Tally@#[[Range@Length@#-#~StringCount~"^"//.x_:>x[[x]]]]&@StringSplit[#,"
"]&

Ruby 89
m={}
v={}
i=0
$<.map{|l|(t=l.chop![/\^+/])?v[m[i]=o=m[i-t.size]]+=1:v[m[i]=l]=1;i+=1}
p v

This is a program that gets input from STDIN and prints out the result.
It keeps track of the messages and their vote counts in the variable v, which is a Hash.
Online demos:

http://ideone.com/SdRcPD
http://ideone.com/H7fWVf

Python 2.7 96 bytes
l=s.split();b={}
for i in l:_=l.index(i);l[_]=l[_-i.count('^')];b[l[_]]=b.get(l[_],0)+1
print b

explanation:
in-place overwrite of l, each call of l[_] = ... stores the word pointed to, and a dictionary is used to tally the results by initializing or adding to the current count of b[l[_]]

You could probably shave off some bytes with for _,i in enumerate(l):.


text:
Josephus problem with three inputs
There's a question on this site that is similar to this question, but I have added a twist.
You have three inputs, the number of people in the circle n, the k-th person counted out at each step, and the q-th person that survives. The people in the circle are numbered 1 to n.
For example, in a circle of 20 people, the 20th person to survive is the very first person removed, the 19th survivor is the second person removed and so on. Normally, the Josephus problem is to determine the last person removed, here called the first survivor.
Write the shortest program or function that, with those three inputs, returns the number of the q-th person to survive.
If there are any issues with clarity, please let me know.
Some examples:
>>> josephus(20, 3, 9)
4
>>> josephus(4, 3, 1)
1
>>> josephus(100, 9, 12)
46

Edit: Assume all inputs are valid. That is no one will ask for 0 or any negative numbers and no one will ask for the 20th survivor in a circle of 5 people (that is, 1 ≤ q ≤ n)
Edit: I'll accept an answer at midnight UTC+7 at the start of December 2.

Please post your own solutions as answers instead of including them in the question.

Got it. Sorry about that

For clarification, if q=1 this is exactly the same as the linked Josephus question, right?

@TimmyD Exactly

Pyth, 16 bytes
eu.<PGvzh-QvwShQ

Try it online: Demonstration or Test Suite
Input is of the form k<newline>n<newline>q.
Explanation:
eu.<PGvzh-QvwShQ   implicit: z = first input line (string)
                             Q = second input line (integer)
              hQ   Q + 1
             S     the range [1, 2, ..., Q+1]
 u      h-Qvw      apply the following statement (Q-input()+1) times to G=^
    PG                remove the last number of G
  .<  vz              and rotate eval(z) to the left
e                  print the last number of the resulting list

Piet, 280 273 codels

Edit: I have golfed this down some more, and I think I can golf it down even further, but that is still to come. For now, I'm just glad it works, and that I had room to sign it in the bottom left-hand corner. Two ideas I have to save more codels are a) to change the end instructions be pop, push 1, add, out num (pop n, output r+1) and b) to duplicate again at the bottom left corner to save codels in stack manipulation later on in the loop.
The picture above is my code at 8 pixels per codel. In general, it's the same algorithm as my Python answer, but with the inputs in the order of k, q, n. In practice, there is a also a great deal of stack manipulation. You can try it here by opening the image there and running the code with it.
Explanation
This is a step-by-step ungolfing of the solution.
in num    get k
dup       Stack: k k
push 1
subtract  Stack: k k-1
in num    get q
dup       Stack: k k-1 q q
dup       Stack: k k-1 q q q
push 4
push 2
roll      Stack: k q q k-1 q
mod       Stack: k q q r
in num    get n
# note: the loop will return to the following codel
dup       Stack: k q q r n n
push 4
push 3
roll      Stack: k q r n n q
greater   1 or 0
pointer   Here the loop begins. If q>n, the pointer moves clockwise.
          Else, it points straight ahead

LOOP:     Stack: k i r n (i=q at the start of the loop)
push 4
push 2
roll      Stack: r n k i
push 1
add       Stack: r n k i=i+1
push 2
push 1
roll      Stack: r n i k
dup       Stack: r n i k k
push 5
push 4
roll      Stack: n i k k r
add       Stack: n i k m=r+k
push 3
push 2
roll      Stack: n k m i
dup       Stack: n k m i i
push 3
# here it turns the corner
push 1
roll      Stack: n k i m i
mod       Stack: n k i r=m%i
push 4
# here it turns the corner and avoids the black codels
push 1
roll      Stack: r n k i
dup       Stack: r n k i i
push 5
push 3
roll      Stack: k i i r n
dup       Stack: k i i r n n
# and we meet up with the dark green codel once more
push 4
push 3
roll      Stack: k i r n n i
greater   Stack: k i r n (0 or 1)
pointer   if else again

# else    Stack: k i r n
push 2
push 1
roll      Stack: k i n r
# and turn the corner
push 1
add       Stack: k i n r+1
out num   print r+1
# turn the corner into the end pattern (the shape with the black edges)
END

You aren't counting empty space? Is there a meta post somewhere about how to score Piet? There probably should be.

@Sparr, I am counting empty space. That is a 21 codel by 13 codel image, so the score is 273 codels.

Ahh, I miscounted. Sorry.

CJam, 22 20 19 bytes
q~_,@a@*{m<)\}%\~=)

This reads the input as q k n. Try it online in the CJam interpreter.
How it works
q~                   Read and evaluate all input. This pushes q, k, and n.
  _,                 Push A := [0 ... n-1].
    @a               Rotate on top of the stack and wrap it in an array.
      @*             Rotate the original n on top and repeat [k] n times.
        {    }%      For each of the n k's:
         m<            Rotate A k units to the left.
           )\          Pop the last element and swap it with A.
               \~    Swap the resulting array with q and apply bitwise NOT.
                 =)  Select the corresponding element and add 1 to it.

Golfscript, 58 56 55 35 31 30 bytes
Assuming the three inputs are already in the stack, in the order n, k, q
~1$(1$%3$),@),-{\2$+\%}%\)])\;

That solution assumes I need to get rid of everything but the final answer.
How it works
See j(n,k,q) in my Python 3 solution for more detail.
~                                   Read the inputs n, k, q
 1$(                                Duplicate k, decrement
    1$                              Duplicate q
      %                             (k-1)%q
       3$),                         Create array [0..n+1]
           @),                      Create array [0..q+1]
              -                     Subtract the second array from the first,
                                        leaving only [q+1..n+1]
               {      }%            Map the following statement onto [q+1..n+1].
                                        The numbers from this array will be denoted i.
                \                   Swap i and r
                 2$+                Duplicate k, add to r
                    \               Swap r and i
                     %              r mod i
                        \)          Swap the leftover array from map with r, increment
                          ]         Put the whole stack into an array
                           )        Remove the last member of the array, r
                            \;      Pop the array, leaving only the result

Edit 1: Used @Doorknob's suggestion (Added a + to get all the inputs into the array)
Formerly,
\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)\;\;\;\;

Edit 2: Added ~, per the rules of the wiki, and shortened the code. Thanks @Dennis
Formerly,
[\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)]+)\;

Edit 3: Implemented a shorter algorithm.
Formerly,
~\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)]-1=

Edit 4: Figured out that I could use % as map.
Formerly,
~1$(1$%{1$4$<}{\)\2$+1$%}while)])\;

Edit 5: Minor edit. Changed 2$ to @ to make [0..q-1] and 3$ to 2$ to retrieve k. Saved a bite
Formerly,
~1$(1$%3$),2$),-{\3$+\%}%\)])\;

\;\;\;\; can be replaced with ])\; (wrap in array, right-uncons, swap, and pop).

Edited my code for clarity @Dennis.

Alright @Dennis. Added the ~ and edited the question to allow only programs and functions. Do you have any other suggestions?

No, all good. :)

JavaScript (ES6), 56 bytes
(n,k,q)=>{r=(k-1)%q;for(i=q;i<n;r=(r+k)%++i);return r+1}

Ungolfed
Basically a JavaScript adaptation of @Sherlock9's Python answer.
(n,k,q)=>{
  r=(k-1)%q;
  for(i=q;i<n;r=(r+k)%++i);
  return r+1
}

Test

n = <input type="number" id="N" value="100" />

k = <input type="number" id="K" value="9" />

q = <input type="number" id="Q" value="12" />

<button onclick="result.innerHTML=(

(n,k,q)=>{r=(k-1)%q;for(i=q;i<n;r=(r+k)%++i);return r+1}

)(+N.value,+K.value,+Q.value)">Go</button>

I wouldn't call your ungolfed version ungolfed :P

Python 3, 72 66 62 bytes
A dynamic programming function in 62 bytes. Adapted from the algorithm on Wikipedia. There used to be a direct implementation of this algorithm when q=1 (i.e. i=1, r=0) on that page, but I see that has been removed now.
Edit 1: I removed i to save 4 bytes. Explanation remains unchanged.
Edit 2: Miscalculation in byte count. I was using \r\n for EOL and didn't notice when that added 3 bytes. I have lowered my byte count accordingly.
def j(n,k,q):
 r=(k-1)%q
 while q<n:q+=1;r=(r+k)%q
 return r+1

How this works
def j(n,k,q):
 i=q;r=(k-1)%q              We start with the smallest possible circle to have a q-th
                                survivor, a circle of q people.
 while i<n:i+=1;            Iterate from q to n
                r=(r+k)%i   Every time you add people to the circle, r increases by k,
                                modulo the current size of the circle i.
 return r+1                 Return the result.

Thanks to @Dennis for reminding me that I should explain my code (if only implicitly, because he included one in his answer). If anything is unclear, please let me know.
Edit:
Formerly,
An iterative function that is adapted from Concrete Mathematics by Graham, Knuth and Patashnik. Though this algorithm is longer, it is faster for large n and small k.
def t(n,k,q):
 m=k-1;z=q*k-m%q
 while z<=n*m:z=-(-z*k//m)
 return n*k-z+1

It looks like you cut something off in copying-pasting, there's a hanging +.

C, 81 73 bytes
Based off @user81655's Javascript implementation of my Python answer.
Edit: Removed i
int j(int n,int k,int q){int r=(k-1)%q;for(;q<n;r=(r+k)%++q);return r+1;}

Test
#include <stdio.h>
int j(int n,int k,int q){int r=(k-1)%q;for(;q<n;r=(r+k)%++q);return r+1;}
int main()
{
    printf("%d\n", j(20,3,9));
    return 0;
}

In some versions of C, you can drop the int before the parameter names.

Mathematica, 50 bytes
<<Combinatorica`
Tr@Position[Josephus@##2,1+#2-#]&

An anonymous function. Takes inputs in the order q,n,k.

Haskell, 48 47 43 bytes
(n!k)q=1+foldl(mod.(k+))(mod(k-1)q)[q+1..n]

Based on a Haskell algorithm on the Rosetta Code page of the Josephus function with two inputs. Golfing suggestions are welcome.
Edit: My thanks to nimi for help with golfing the first algorithm via suggesting a pointfree version, and for help with golfing the second algorithm by letting me know that the until keyword exists.
(n#k)q|m<-k-1=1+n*k-until(>n*m)(\z-> -div(-z*k)m)(q*k-mod m q)

A version of the algorithm at the end of my Python answer adapted from Concrete Mathematics by Graham, Knuth and Patashnik. Though this algorithm is longer at 62 bytes, and has not been golfed down as much as the first, it is faster for large n and small k.
Ungolfed:
First algorithm
jos_g num step q = 1 + foldl (\x -> mod (x + step) ) (mod (step-1) q) [q+1..num]

Second algorithm
jos_gkp num step q
    -- ceiling throws a type-related fit with ceiling(z*k/(k-1))
    -- better to use - div (-z * k) (k - 1)
    | m <- step-1 = 1 + num*step - until (>num*m)(\z-> -div (-z*k) m) (q*step - mod m q)

So did you pick this question to learn new languages with? 6/10 of the answers are yours :P

@Mego I mentioned this in chat :D I asked if I should post it anyway and they said go ahead. Also, yes. My friends have told me that this is my "Hello, World!" for new languages :D

I'm not saying this is a bad thing. I'm just amused, that's all.

@Sherlock9: you can use until for a (more or less) direct translation of the Python version of the 2nd algorithm: (n#k)q|m<-k-1=1+n*k-until(>n*m)(\z-> -div(-z*k)m)(q*k-mod m q).

God bless you, @nimi :D I was banging my head on that problem for ages, trying foldl and infinite lists and all sorts of stuff. Thanks for your help!

PHP, 71 bytes
Based off of @Sherlock9's answers. See his Python answer for the algorithm.
function a($n,$k,$q){for($r=($k-1)%$q;$q<$n;$r=($r+$k)%++$q);echo$r+1;}

Alternatively, here is my original naive approach without the algorithm. This uses an array to mark which people are found.
91 bytes
function a($n,$k,$q){for($r=--$i;$q<=$n;++$i%$k||$c[$r]=$q++)while($c[$r=++$r%$n]);echo$r;}

GameMaker Language (GML), 88 bytes
Based on @user81655's answer
r=argument0
k=argument1
q=argument2
r=(k-1)mod q;for(i=q;i<n;r=(r+k)mod ++i){}return r+1

Jelly, 14 13 bytes
Rµṙ⁴ṖµL>⁵µ¿⁴ị

TryItOnline!
How?
Rµṙ⁴ṖµL>⁵µ¿⁴ị - Main link: n, k, q
 µ            - monadic chain separation
R             - range(n): [1,2,3,...,n] - the circle of people
     µ   µ¿   - while
      L       -     length
       >      -     greater than
        ⁵     -     5th program argument (3rd input), i.e. q
  ṙ           -         rotate left by
   ⁴          -         4th program argument (2nd input) i.e. k
    Ṗ         -         pop - remove the rightmost person
            ị - get index
           ⁴  - 4th program argument (2nd input), i.e. k

Ruby, 53 48 bytes
A lambda.
->n,k,q{r=(k-1)%q;(q+=1;r=(r+k)%q)while q<n;r+1}

How it works
def j(n,k,q)
  r=(k-1)%q   # r starts at j[q,k,q]
  while q<n
    q+=1
    r=(r+k)%q # Every time you add people to the circle, r increases by k,
              # modulo the current size of the circle q.
  end
  r+1         # Return the result.
end


text:
How many typos?
A typo is said to have occurred if:

A character is missing.
A character is extra.
A character is replaced with another wrong character.

For the purpose of this challenge, only lowercase characters and spaces are used.
Input will be a dictionary of words, followed by one line of input. You need to find the (minimum) number of typos in it.
Sample data
For all testcases, I've assumed the dictionary to be:
heart
hearth
heard
heaves
aves
he
art
ear
Input 1
heart heard

Output 1
0

Input 2
he art

Output 2
0

Input 3
kill us

Output 3
6

(1 to delete the space, and 5 more to change the word to hearth)
Input 4
heave art

Output 4
1

Input 5
earth artear

Output 5
2

Shortest code wins.
Please let me know of any other ambiguous testcases. I will add them here as well.
P.S.
Someone flagged this as a duplicate of Find the minimum edit distance between two strings
It is not a duplicate, in fact, my challenge is much harder. The main reasons being that:

Substitutions are counted only as one typo in my Q, not two.
The space is also counted as a character, and at the same time behaves like a word-separator.

Can you provide a list of english words?

Because I know I can use /usr/share/dict/words but that file is like, a megabyte

@flawr Please see my clarification on why this is not a dup.

Scoring a substitution as 1 vs 2 involves literally no more than changing a single character from 1 to 2 in some (most?) of the answers to the older question, so I have no idea why you think that makes it "much harder". I'm not sure I understand what you mean with the other reason.