text:
Run Stackylogic
Stackylogic is a logic-based programming language I made up that take in 0's and 1's for input and outputs a single 0 or 1 upon completion.
A Stackylogic program consists of lines that can only contain the three characters 01? as well as exactly one < at the end of one of the lines. Lines may not be empty and the line with the < must have at least one 0, 1, or ? before it.
Here's a sample program that (as I'll explain) computes the NAND of two bits:
1
?<
11
?
0

Every line in a Stackylogic program is considered a stack, with the bottom on the left and the top on the right. Implicitly, there is an empty stack (empty line) before the first line in a program and after the last line.
The <, which we'll call the cursor, marks the stack to start on when a Stackylogic program is run. Execution of a Stackylogic program proceeds as follows:

Pop the top character off the stack the cursor is currently pointing to.

If the character is ?, prompt the user for a 0 or a 1 and act as if that was the character.
If the character is 0, move the cursor one stack up (to the line above the current line).
If the character is 1, move the cursor one stack down (to the line below the current line).

If the stack the cursor moves to is empty, output the last value that was popped off a stack (always a 0 or 1), and end the program.

Else, if the stack the cursor moves to is not empty, go back to step 1 and repeat the process.

Notice that Stackylogic programs always end because they must eventually deplete their stacks.
NAND Example
In the NAND program the cursor starts on a ?:
1
?<
11
?
0

We'll assume the user inputs a 1 once the ? is popped, which means the cursor will move down, making the program look like this:
1

11<
?
0

Now a plain 1 is at the top of the cursor stack. It is duly popped and the cursor moves again:
1

1
?<
0

Now assume the user inputs 0 for the ?, which means the cursor will move up:
1

1<

0

Again, a 1 is on the cursor stack so the cursor pops and moves down:
1

<
0

Finally the cursor stack is empty, so the last value popped, the 1, is output and the program ends.
This is accurate for a NAND gate because 1 NAND 0 is 1. This of course works for the other three two-bit inputs if you care to check.
OR Example
This Stackylogic program simulates an OR gate:
?
?<

It's easy to see that an initial input of 1 will push the cursor to the implicit empty stack below the last line, ending the program and outputting the 1 that was just input.
For an input of 00 on the other hand, the cursor will make its way to the implicit empty stack at the top, ending the program and outputting the last 0 to be input.
Challenge
Write a program or function that takes in a Stackylogic program as a string and runs it, printing or returning the resulting 0 or 1.
Upon ?'s, you may prompt the user for a 0 or 1 input, or read the value from a preset string of 0's and 1's that you also take as input. (This could be another string input to your program/function or you could just assume the first or last line of the program string will be the input stream).
You may assume the program and the input are always well formed. You may optionally assume input programs come with a single trailing newline (though remember there is always an implicit empty stack at the end).
The shortest code in bytes wins.
More Sample Programs
ZERO
0<

ONE
1<

BUFFER
?<

NOT
1
?<
0

AND
?<
?

NAND
1
?<
11
?
0

OR
?
?<

NOR
1
?
00
?<
0

XOR(v1)
?
0
1?<
?
0

XOR(v2)
?
?<
11
?
0

XNOR(v1)
1
?
0?<
1
?

XNOR(v2)
1
?
00
?<
?

MEDIAN(v1)
1
???<
0

MEDIAN(v2)
?
1?<
??

Thanks Martin for the median programs.

If you want to add a 3-input function, here's one way to implement median: ?\1?<\??. Alternatively, here's a symmetric 5-line implementation: ?\?0\?<\?1\?

Oh, I found an even neater implementation: 1\???<\0.

@MartinEnder's neater implementation of the 3-input median function (equivalently, the majority-rules function) generalizes nicely. For example, the 7-input majority-rules function is 111\???????<\000.

Let the "bizarro" of a Stackylogic program $P$ be the program $BP$ formed by reversing the order of the lines of the original programs, and changing all 1s to 0s and vice verse (but leaving ?s and < alone). It seems that the output of $BP$ on inputs $b_1,b_2,\dots$ is the NOT of the output of $P$ on inputs $!b_1,!b_2,\dots$. Notice that the given implementations of AND and OR are bizarro-related in this way, as are NAND and NOR, and the two versions of XOR/XNOR. Some programs are their own bizarro (BUFFER, NOT, MEDIAN(v1)).

Anyway, those thoughts came up while I was finding the following implementation of the 3-input "sum the bits mod 2" function: ?\0\1?\?0\00\?<\11\?1\0?\1\? (Note how it splices together XOR(v1) above the starting cursor and XNOR(v1) below it.)

@GregMartin Yep. I believe the technical term is duality.

Can input be an array of strings instead of a multiline string?

@HelkaHomba I lurked around this question for a while, and I kinda want to make Stackylogic a thing (add new functions and stuff). Can I do that?

@DerpfacePython Sure.

Retina, 79 78 73 68 66 65 63 62 55 44 bytes
Byte count assumes ISO 8859-1 encoding.
+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3
1<

Input is via STDIN and is expected to be the user input separated by two linefeeds from the source code.
Try it online! (The first two lines enable a test suite, where each line is a separate test case with / instead of linefeeds.)
I'm not entirely sure what happened here. This feels like a really clunky solution and this is really not the kind of problem Retina was made for but it still beats all the current answers for some reason.
Explanation
The final version of this actually ended up being fairly simple.
+`(.)([^_]*)\?<|(¶.*)0<|1<(¶.+)
$2$1$4<$3

The first stage is simply a loop (due to the + option) which does the actual interpreting of the language. The stage is a single regex substitution, but in fact it's really three different substitutions squeezed into one stage, by making use of the fact that capturing groups from unused branches are simply considered empty during the substitution.

Processing ?:
(.)([^_]*)\?<
$2$1<

This simply takes the first character of the input, then matches arbitrary characters until it finds ?<, and puts that first character in front of the < (deleting the ?).
Processing 0:
(¶.*)0<
<$1

This matches the line preceding a 0< and puts it after the <, removing 0. (Effectively, this just deletes the 0 and moves the < one line upwards.)
Processing 1:
1<(¶.+)
$1<

Pretty much the same thing, except that we move < one line down while deleting a 1. One important detail to notice is the use of + instead of *, that is, we require the next line not to be empty.

The interesting part is figuring out why this works and why we don't need to keep track of the last value we popped to determine the final output. To do that, we need to consider how the above loop can terminate. Since every possible match changes the string (since at least one character is dropped from it), we only need to consider cases where the match fails altogether.
If the character in front of < is ? the only way for the match to fail is that there isn't non-linefeed character anywhere in front of it, but that can't happen because we're guaranteed that there's always enough input.
If the character in front of < is 0, the regex will always match, since there's always another line above the current one (which may be the empty line separating input from source code).
If the character in front of < is 1, the regex will fail if either we're on the last line (since the ¶ will fail to match) or if the next line is empty (since the .+ will fail to match). Note that both of those cases correspond to terminating the program after popping a 1.
Finally, there's also the possibility that < isn't preceded by any of ?01. It turns out we can only reach this situation by popping a 0 and moving up to an empty line, so that the < is now preceded by a linefeed.
So, when the program terminates on a 1, the < will still be after that 1. But if the program terminates on a 0, it will have moved to an empty line. We can easily turn this information into the desired output with a simple match stage:
1<

This simply counts the matches of 1< in the string. By the above reasoning this will be 1 if the program terminated on a 1, and 0 if it terminated on a 0.

You sir, are a wizard.

Such Regex Mch Wow

Convex, 102 95 bytes
Well, a list-of-stacks-based language coded in a stack-based language turned out to be quite difficult. Mark my words: I will get this to 100 bytes or less! EDIT: Success!
N/S\+{s)_'<={R:M;}{R):R;+}?}%'<-M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

Try it online!
Program input is via command-line args. Input 0s and 1s normally (on TIO, this means newline-separated in the "input" box).

Explanation:
All of the code can be split into three pieces:
N/S\+

This bit simply takes the input program and converts it into an array of lines, and also adds " " lines to the beginning of the array. Since Convex's arrays wrap, having only an empty stack at the beggining will do.
{s)_'<={R:M;}{R):R;+}?}%'<-

This part determines what line (or stack) to start execution with. It searches through each line and puts the correct stack number into the M variable.
M){(æ=)s_:Q;"?10 ""l+ M):M; M(:M; W:M;A~p"S/Ë~~_!S*+tM)Q:A;}h;;

This is the fun bit! It continually loops until it reaches a line with only a space (" ") on it (symbolizing an empty stack). If the line is not empty it does the following:

Pop the last character off the stack.
Switch statement:

If the character is a ?, take input and append that character to the line.
If the character is a 0, move the line pointer up one.
If the character is a 1, move the line pointer down one.
If the character is a (space), print the most-recently popped item and end program.

32-bit x86 machine code, 70 bytes
In hex:
FC89E1565F31D28A07A8DF740B3C3C7511428D5C24FCEB0A5729142484C07405B20147EBE2578B3B8A17F6C2DF7414FF0B923C3F7501AC3C30750383C30883EB04EBE389CCC3

Input is a NULL-terminated multi-line string (linefeed-separated) passed via ESI. User input is assumed to be the first line. Returns '0'/'1' in AL.
Disassembly:
fc           cld
89 e1        mov    ecx,esp
56           push   esi
5f           pop    edi                  ;EDI=ESI
31 d2        xor    edx,edx              ;EDX=0
_loop0:
8a 07        mov    al,BYTE PTR [edi]    ;AL=*EDI
a8 df        test   al,0xf5              ;AL&~0x0a==0 => separator ('\n' or '\0')
74 0b        je     _stck
3c 3c        cmp    al,'<'
75 11        jne    _loop0end
42           inc    edx                  ;For "cursor" symbol adjust stack pointer offset
8d 5c 24 fc  lea    ebx,[esp-0x4]        ;and load EBX with the address where this pointer
eb 0a        jmp    _loop0end            ;is going to be stored in the next iteration
_stck:
57           push   edi                  ;Pointer to the separator
29 14 24     sub    DWORD PTR [esp],edx  ;adjusted to point to the top of the stack
84 c0        test   al,al                ;AL==0?
74 05        je     _loop0break          ;break
b2 01        mov    dl,0x1               ;EDX can be [0..2], resets to 1
_loop0end:
47           inc    edi                  ;++EDI
eb e2        jmp    _loop0
_loop0break:
57           push   edi                  ;*EDI==0, add lower implicit empty stack
_loop1:                                  ;The actual state machine code
8b 3b        mov    edi,DWORD PTR [ebx]  ;EDI=*EBX
8a 17        mov    dl,BYTE PTR [edi]    ;DL=*EDI
f6 c2 df     test   dl,0xf5              ;DL&~0x0a
74 14        je     _loop1break          ;ZF==1 => current stack is empty
ff 0b        dec    DWORD PTR [ebx]      ;--(*EBX): pop the stack
92           xchg   edx,eax              ;AL=DL
3c 3f        cmp    al,'?'
75 01        jne    _skplods             ;AL=='?' => substitute char from the input string
ac           lodsb
_skplods:
3c 30        cmp    al,'0'
75 03        jne    _0x31                ;EBX+=AL==0?4:-4
83 c3 08     add    ebx,0x8              ;But to avoid wasting 2 bytes for the jump after the 'add'
_0x31:                                   ;add 8 and fall through to subtract 4 back
83 eb 04     sub    ebx,0x4
eb e3        jmp    _loop1
_loop1break:
89 cc        mov    esp,ecx              ;Clear the stack
c3           ret                         ;Returns '0'/'1' in AL

JavaScript (ES6), 136 138
Assuming a terminating newline in the program
(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

Less golfed
(p, i, j=0)=>{
  p=`\n${p}`
     .split`\n`
     .map(
       (x,i)=>
       (
         x = [...x],
         c = x.pop(),
         c == '<' ? k=i : x.push(c),
         x
       )
     )
  for(; a = p[k].pop(); k -= 1-c-c)
    c = 1/a ? a : i[j++];
  return c;
}

Test

F=(p,i,j=0)=>eval("for(p=`\n${p}`.split`\n`.map((x,i)=>((c=(x=[...x]).pop())=='<'?k=i:x.push(c),x));a=p[k].pop();k-=1-c-c)c=1/a?a:i[j++]")

function run() {
  var pgm=P.value+'\n'
  var i=I.value
  O.textContent = F(pgm,i)
}

run()
#P { width:60%; height: 6em }
#I { width:50%;  }
Program

<textarea id=P>1
?<
11
?
0</textarea>

Input

<input id=I value=01>
<button onclick='run()'>Run</button>

Output

05AB1E, 58 56 55 53 51 50 46 bytes
Saved 2 bytes thanks to Emigna! Code:
õ|`õ)[¤'<å#À]`¨[¬V¨Y'?QiI«ëYi1U)À`ëY_i0U)Á`ëXq

Uses the CP-1252 encoding. Try it online!.

Python 3, 147 146 145 144 bytes
1 byte thanks to @Lynn.
def f(p):
 i=p[:p.find("<")].count("\n");p=p.split()
 try:
  while 1:*p[i],c=p[i];c=c>"<"and input()or c;i+=c<"<"and int(c)*2-1
 except:return c

Python 3, 318
def s(f,z):
 p=b="";g=0;a=[];n=a.append;n(p)
 for i in f:
  if i=="\n":n(p);p=''
  else:p+=i
 n(p);p=b;n(p)
 while g<len(a):
  if'<'in a[g]:q=g;a[q]=a[q][:-1]
  g+=1
 while 1:
  v=a[q]
  if v=='':print(b);break
  if v[-1]=='1':a[q]=v[:-1];q+=1;b=1
  elif v[-1]=="0":a[q]=v[:-1];q-=1;b=0
  else:a[q]=v[:-1]+z[0];z=z[1:]

F being the program, z being input. Yes, my variable names are insane.

ES6, 190 bytes
f=(p,i)=>{
n=p.split`<`[0].split`\n`.length-1
p=p.split`\n`.map(o=>o.split``)
i=i.split``
p[n].pop()
while(p[n]&&p[n].length){
c=p[n].pop()
v=c=='?'?i.shift():Number(c)
n+=v*2-1
}
return v
}

Use like f(program, input)

A couple of general golfing tips (there's a list of these somewhere): use [...o] instead of o.split\`, and use forinstead ofwhile, as that lets you move two expressions into the forsaving two bytes. A couple of specific tips: I think yourNumbercast is unnecessary, as the*2will cast for you, and I would just readiusingj=0andi[j++]` which I think saves 11 bytes.

You don't need the f=, anonymous functions are allowed.

Java, 256 255 231 219 215 213 bytes
int f(char[][]p,char[]I){int l=p.length,d=0,j=-1,c=0,k=0,i[]=new int[l];while(++j<l)if(p[j][i[j]=p[j].length-1]==60)i[k=j]--;try{for(;;k+=c>48?1:-1)c=(c=p[k][i[k]--])>49?I[d++]:c;}catch(Throwable t){}return c-48;}

Demo on Ideone.
Takes the program and input as arguments and returns the result as an integer.

@LeakyNun Changed to a for loop, but what does your first comment mean?

@Pietu1998 LeakyNun means it can be int f(String[]I)... and you can avoid the String[]p=I.split("\n");

It means you can declare the function as int f(String[]P)

@cat ninja'd by 7 seconds :/

Also, if you settle for Java 8 you can have a lambda like (I think) ->(String[]I){...

@LeakyNun Is taking input as an array of lines (or even array of char arrays) implicitly allowed? The OP explicitly says takes in a Stackylogic program as a string.

@LeakyNun If it is, then it's worth it to take input as an argument (b=0, ... a[b++]). Using a string argument is actually one byte longer (b=0, ... a.charAt(b++)).

Relevant meta post.

OK, I was unaware of that. Golfing.

Let us continue this discussion in chat.

PHP (<7.0), 195 192 bytes
Takes the program as first argument and each value as an additional argument.
Note that I tested this with split(" ",..) asn spaces rather than newlines but it should work anyway.
Gives a deprecated notice if run in php >5.3.Also gives a warning if you go off the top of the program. However it still works and outputs correctly so it's fine.
<?php foreach(split("\n",$argv[++$t])as$l)$p[]=str_split($l);for($i=-1;end($p[++$i])!='<';);array_pop($p[$i]);for(;($v=array_pop($p[$i]))!==null;$i+=$n?:-1)($n=$v)=='?'&&$n=$argv[++$t];echo$n;

C, 264 249 244 242
C doesn't do so well with manipulating strings, but this is pretty short.
It works by scanning the string for the cursor (<), moving back 1 place, reading the command, replacing it with a tab character, and moving either forward or backward one line. Input is in the form of a C char array, like char array[]="1\n?<\n11\n?\n0";result = f(array);, although carriage returns are permitted as well.
Although the input string is modified, the length is not changed.
t;f(char*n){char*p=strchr(n,60);for(*p--=9;;){if(*p==63)scanf("%d",&t),*p=t+48;if(*p^49){for(*p--=9;p>n&&*p^10;--p);for(--p;p>n&&*p==9;--p);if(p<n||*p==10)return 0;}else{for(*p++=9;*p&&*p^10;++p);for(p+=!!*p;*p>10;++p);if(*--p<11)return 1;}}}

Test program
Run this program with each test case as a separate parameter, using a single backslash in place of newlines. Test cases will be separated by a blank line.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    while (*++argv)
    {
        char *input=malloc(strlen(*argv)+1),*p;
        strcpy(input,*argv);
        printf("testing %s\n",input);
        for (p=input;*p;++p)
            if (*p=='\\')
                *p=10;
        printf("result: %d\n\n",f(input));
        free(input);
    }
    return 0;
}


text:
Generate a Stack Exchange Favicon
Do you recognize the PPCG logo?
it looks like this, when you do an ascii art of it.
+---+
|PCG|
+---+
   v

Now, In this Code Golf, You will make a code, that makes logos for other sites, similar to the PPCG logo.
What You should do
The "Shortened" string will be the string, with all upper case letters and numbers in the input string.(Which would be PPCG when the input string is Programming Puzzles & Code Golf)
The "Box" (
+---+
|   |
+---+
   v

)
should fit the Shortened string perfectly.(No bigger or smaller)
Also the v part should be exactly 1 down and 1 left to the down right +.
Then output the box which has the shortened string in it.
Example
Stack Overflow:
+--+
|SO|
+--+
  v

Area 51:
+---+
|A51|
+---+
   v

Rules
You may assume that the input contains at least one digit or upper case letter.
Standard code-golf rules apply.

Very closely related. Also related.

@MartinEnder Yes, Very closely related, but not duplicate.

Also, This is Highly inspired by PPCG itself.

Can you clarify what the text inside should be? For example, what if the name of the site was 99 bottles of beer. Would that be 99BOB? Does the box get bigger to compensate for that? Is there a maximum box size, or site name size? What kind of characters might appear in the site title?

@MatthewRoh The purpose of the links is so that the challenges show up in the sidebar, it's not a dupe vote. That said, I personally think removing the unwanted characters and also printing the ^ doesn't add much compared to the second challenge I linked, but I won't cast a dupe hammer on that but let the communitz decide whether they consider it a dupe or not.

Unlimited Box and Site name size. Also, if it was 99 bottles of beer, It would be 99.

@MartinEnder The related ones you linked have a whitespace front and behind the string. mine don't.

@MatthewRoh The actually seems like the most minor difference which isn't going to require any substantial changes to any of the existing solutions. The best case for this challenge is the acronymisation and the v.

Also related

Why does 99 bottles of beer become 99 and not 99BOB? Is everything after a number excluded?

Because It is numbers and uppercase, not numbers and first character.

If it was 99 Bottles Of Beer, it would be 99BOB.

Oh okay, I missed that part :p.

@MatthewRoh That would be a useful test case to add.

What about uppercase letters inside the string? i.e. would 99 bOttles Of Beer turn into 99OOB?

Yes. Every uppercase letters.

THERE IS NO BF ANSWER SO I AM GIVING AWAY TO MY FAVORITE

NOOOOO @MattherRoh, I have been working on it :( I am so close. I even created an assember to convert "readable" code to BF :(((

@Rohan :O Im really impressed

@MatthewRoh if I manage to get close I'lll still post it

@MatthewRoh its still buggy,  let me see if i can get a bf answer after all

@MatthewRoh heres what I have so far. https://sange.fi/esoteric/brainfuck/impl/interp/i.html

Just cant figure out how to stirip uppercase characters in brainf***

@RohanJhunjhunwala Check all uppercase. That would be simple I think.

@MattheyRoh yeah I think I may have an interesting solution

@Matthew I can just check if it is less than 96 :D

related

Vim, 42 strokes
:s/[^A-Z0-9]//g
YPVr-i+<DOWN><LEFT>|<ESC><C-V>ky$pYjppVr $xrv

Replace <DOWN> with ↓, <LEFT> with ←, <ESC> with esc and <C-V> with CTRL+V.
Here's an animation of this script running (old version which uses a V instead of a v):

Explanation of the script:
:s/[^A-Z0-9]//g                               # Remove all the characters that are not uppercase or numbers using a Regex.
YPVr-                                         # Duplicate the current, and replace all the characters of the upper one with dashes.
     i+<DOWN><LEFT>|<ESC>                     # Insert a + on the upper line, and a | on the second line.
                         <C-V>ky$p            # Copy the + and | to the end of both lines.
                                  Yjpp        # Copy the upper line to the bottom two times.
                                      Vr $    # Replace the bottom most line with spaces and put the cursor on the last character.
                                          xrv # Remove the last character and replace the second last character with a v.

lowercase V, not uppercase V

One character more, but avoids the special escaped characters:  r|y uP$pYPVr-r+$.YjppVr $hrV

You can replace i+↓←|␛␖ky$p with A+↓|␛␖ky0P to save a byte.

Alternatively, replace the first eight strokes in Bryce’s approach with I|<END>|␛

I wonder if this has the most upvotes because of the cool picture.

@SirBidenXVII Probably.

V 34 bytes
Ó[^A-Z0-9]
ys$|ÄVr-r+$.YLppVr x$rv

Note that this worked in an older version, but doesn't work in the current version on try it online. I changed Ä to YP which is functionally equivalent.
Try it online!
Explanation:
Ó[^A-Z0-9]

Remove everything except for digits and uppercase characters.
ys$|              "Surround this line with '|' characters.
    Ä             "Duplicate this line
     Vr-          "Replace this whole duplicated line with '-' characters
        r+        "replace the first character with '+'
          $       "Move to the end of the line, and
           .      "Repeat our last command. This is the same as 'r+'
            Y     "Yank the current line
              pp  "and paste it twice
             L    "At the end of our text

Now, the buffer looks like this:
+---+
|A51|
+---+
+---+

And our cursor is at the first column of the last line.
Vr                 "Change the whole last line to spaces
   x               "Delete a character
    $rv            "And change the last character to a 'v'

Non-competing version: (31 bytes)

I just noticed that the input Programming Puzzles & Code Golf produces the incorrect string PP&CG in the output. The & should be removed

@LuisMendo Aww, darn it! Thanks for pointing that out, I'll fix it sometime today.

@DrGreenEggsandIronMan So, you fixed it, right? [when? will? you? finally? fix? it?]

I'm not getting any output on TIO?

@Downgoat V just recently had a huge update, and unfortunately it borked some things I'm looking into it, but I'm not sure how long it'll take to fix.

@DrGreenEggsandIronMan oh okay :( can you provide a link to a working version/github commit

@Downgoat I'm not sure when the last working commit was. A minor change fixes things though (see the new answer)

16-bit x86 machine code, 72 bytes
In hex:
565789F731C9FCAC84C074143C5A77F73C4173083C3977EF3C3072EBAA41EBE75F5EE81500B07CAA51F3A4AB59E80A00B020F3AAB076AA91AAC351B02BAAB02DF3AAB82B10AB59C3

Parameters: SI = input string, DI - output buffer.
Outputs a NULL-terminated string with lines delimited by newline.
Uses input string as a temporary buffer.
56           push   si
57           push   di
89 f7        mov    di,si    ;Using source string as a buffer
31 c9        xor    cx,cx    ;Counter
fc           cld
_loop:
ac           lodsb
84 c0        test   al,al    ;Test for NULL
74 14        jz     _draw    ;Break
3c 5a        cmp    al,'z'   ;\
77 f7        ja     _loop    ; |
3c 41        cmp    al,'a'    ; \
73 08        jae    _stor    ;  >[A-Z0-9]?
3c 39        cmp    al,'9'   ; /
77 ef        ja     _loop    ; |
3c 30        cmp    al,'0'   ;/
72 eb        jb     _loop
_stor:
aa           stosb           ;Store char in the source buffer
41           inc    cx
eb e7        jmp    _loop
_draw:
5f           pop    di
5e           pop    si
e8 15 00     call   _line    ;Output the first line
b0 7c        mov    al,'|'   ;This proc upon return leaves '\n' in AH
aa           stosb           ;First char of the second line
51           push   cx
f3 a4        rep    movsb    ;Copy CX logo characters from the source buffer
ab           stosw           ;Outputs "|\n", which is still in AX
59           pop    cx
e8 0a 00     call   _line    ;Output the third line
b0 20        mov    al,0x20  ;Space
f3 aa        rep    stosb    ;Output it CX times
b0 76        mov    al,'v'
aa           stosb           ;Output the final 'v'
91           xchg   cx,ax    ;CX == 0
aa           stosb           ;NULL-terminate the string
c3           retn            ;Return to caller
_line:
51           push   cx
b0 2b        mov    al,'+'
aa           stosb
b0 2d        mov    al,'-'
f3 aa        rep    stosb     ;'-'*CX
b8 2b 10     mov    ax,0x102b ;"+\n"
ab           stosw
59           pop    cx
c3           retn

Uhh.. I have not done assembly code for while.

Me too. Started again about a week ago for golfing only

3c 41        cmp    al,a'   shouldn't it be 3c 41        cmp    al,'a'   ?

@rav_kr, sure, thanks fo noticing. Missed a quote while replacing hex codes with characters for readability.

Lua, 145 99 Bytes
Not much to say, manipulating strings is always wordy in lua :). Takes a command-line argument and output via STDOUT
Thanks to @LeakyNun for saving me 45 Bytes !
n=(...):gsub("[^%u%d]","")s="+"..("-"):rep(#n).."+\n"return s.."|"..n.."|\n"..s..(" "):rep(#n).."V"

100 Bytes proposed by @LeakyNun
n=(...):gsub("[^A-Z%d]","")s="+"..("-"):rep(#n).."+\n"return s.."|"..n.."|\n"..s..(" "):rep(#n).."V"

OLD 145 Bytes
g="|"..(...):gsub("%a+",function(w)return w:sub(1,1)end):gsub("%s",'').."|"S="+"..g.rep("-",#g-2).."+"p=print
p(S)p(g)p(S)p(g.rep(" ",#g-2).."v")

Ungolfed
g="|"                            -- g is the second, and starts with a |
  ..(...):gsub("%a+",            -- append the string resulting of the iteration on each word
    function(w)                  -- in the input, applying an anonymous function
      return w:sub(1,1)          -- that return the first character of the word
    end):gsub("%s",'')           -- then remove all spaces
  .."|"                          -- and append a |
S="+"..g.rep("-",#g-2).."+"      -- construct the top and bot of the box
p=print                          -- alias for print
p(S)p(g)p(S)                     -- output the box
p(g.rep(" ",#g-2).."v")          -- output #g-2 spaces (size of the shortened name), then v

Uhh, do you mean output via STDOUT?
But I don't mind because ITS OPPOSITE DAY!!!

@MatthewRoh I meant outputing to the STDIN of your terminal ! (fixed... shame....)

n=(...):gsub("[^A-Z%d]","")s="+"..("-"):rep(#n).."+\n"return s.."|"..n.."|\n"..s..(" "):rep(#n).."V" is 100 bytes

@LeakyNun using the pattern %u we gain some more bytes. Anyway, thanks :) (will update the ungolfed later)

Retina, 43 bytes
[^A-Z\d]

.+
+$.&$*-+¶|$&|¶+$.&$*-+¶$.&$* V

Try it online!
This is the perfect challenge to demonstrate Retina, Martin Ender's golfing language.
This solution is divided into two steps (what we call stages), both stages being a replacement stage.
The first stage:

[^A-Z\d]

This matches the substrings which match [^A-Z\d], which is the characters that are not uppercase and not digits, and then substitute them by nothing, meaning deleting them.
The second stage:
.+
+$.&$*-+¶|$&|¶+$.&$*-+¶$.&$* V

The .+ matches the whole result, and then substitutes it with the second line.
In the second line:

$& refers to the whole match
$.& refers to the length of the whole match
$* means take the previous integer, repeat the next character that many times. Here $.&$*- means to repeat - however long the match is.
¶ refers to a new-line.

Nice, I tried this earlier, but ended up with 54 bytes. An alternative for the first stage is T\dLp`dL_` but it's the same length, unfortunately.

@MartinEnder What were your 54 bytes?

http://retina.tryitonline.net/#code=VGBkTHBgZExfCl58JAp8CiQKwrYkX8K2JF_CtiRfClQyfmB8cGArLWAuKwpyYC5cRwogCi4uJAp2&input=OTkgQm90dGxlcyBvZiBCZWVy

Excel VBA, 375 359 358 bytes:
It works, I give up on trying to make it shorter...
Edit: Switched to case statement from if statements, -16 bytes
Edit2: Got rid of u and replaced with Len(b), -1 byte
Function b(x)
For i = 1 To Len(x)
a = Mid(x, i, 1)
e = Asc(a)
If e > 64 And e < 91 Or e > 47 And e < 58 Then b = b & a
Next i
For Z = 1 To 4
y = ""
Select Case Z
Case 2
y = "|" & b & "|"
Case 4
For i = 1 To Len(b)
y = y & " "
Next i
y = y & "v"
Case Else
y = "+"
For i = 1 To Len(b)
y = y & "-"
Next i
y = y & "+"
End Select
Debug.Print y
Next Z
End Function

Its good though, considering that VBA is sometimes rubbish.

I just do these for the challenge, I know I can't compete with VBA.  Usually end up super confused at the end after changing all the variables from names to single letters.

Yeah ikr So true

Can you remove the whitespace around operators?

They are added automatically by the program, I don't know if that's an option or not.

Laughed at "Got rid of u"

I think you can remove some whitespace. It is automatically added after you paste the golfed code.

I cannot run the code with whitespace removed because the VBA editor adds it automatically so I can't verify that it will run with it missing.

To justify removing whitespace, remove it in a text editor, then paste back into VBA. If VBA handles it correctly, you're good with the shortened version.

I've put it in notepad, removed spaces, pasted back into the VBA editor and spaces are back.  The editor adds them, if you delete them in the editor and click the mouse anywhere, it adds them.  I cannot test the program without them.

Yep. But if the code you start with doesn't have spaces and they are automatically inserted by the VBA editor and then it works, you have tested your space-reduced code.

And do look up the String function.

For Each x in Split([A1]):a=a+IIf(x Like"[a-zA-Z]*",Left(x,1),""):Next:s="+"+String(Len(a),45)+"+":?s:?"|"a"|":?s:?Spc(Len(a))"v - 128 Bytes

C#, 183 177 165 bytes
string h(string s){s=string.Concat(s.Where(n=>n>47&n<58|n>64 &n<91));int m=s.Length;var x=new string('-',m);return$"+{x}+\n|{s}|\n+{x}+\n{new string(' ', m + 1)}v";}

multiplying chars is terrible in C#.
suggestions appreciated
thanks alot to aloisdg for -18 bytes

You can replace | | with |

You can use string interpolation return$"+{x}+\n|{s}|\n+{x}+\n{new string(' ',m+1)}v";}

thats a sweet method!

You can replace string.Join("",  with string.Concat(

You can replace your where lambda with (n=>n>47&n<58|n>64&n<91))

i thought about doing ascii comparisons

You can remove the space after the return

Also I would use a lambda this anonymous function are allowed. s=>{..}; instead of string h(string s){..};

You can remove the space in n>64 &n<91

I added all this edits to the tips for code golfinf in C# thread :)

good job!, lemme add some more edits

@downrep_nation - Can't you shorten m + 1, or is the whitespace significant?

@owacoder He doesnt need it. I wrote it without earlier :)

If you change the Where-lambda to Where(Char.IsLetterOrDigit) you should be able to save a few characters,

You can save 3 bytes by adding using S=System.String; and replacing string with S.

148 bytes by using a regex and eliminating the variable m: string h(string s){s=Regex.Replace(s,"[^A-Z0-9]","");var x=new string('-',s.Length);return$"+{x}+\n|{s}|\n+{x}+\n{new string(' ', s.Length + 1)}v";}

2sable, 36 34 33 32 31 bytes
Presenting 2sable :). Although it has a lot in common with 05AB1E, this one actually auto joins the stack rather than outputting the top of the stack. Code:
žKA-Ã©g'-×'+DŠJDU„
|Â®sX¶®gð×'v

Uses the CP-1252 encoding.

ಠ_ಠ No more golfing or language switches! Leave it where it is now! :P

@DrGreenEggsandIronMan Hahaha, it is still 3 painful bytes away from your answer :P.

Haha, I was celebrating when I saw it 7 bytes longer, and then slowly watched the gap disappear, one by one...

JavaScript (ES6), 99 bytes
(s,t=s.replace(/[^0-9A-Z]/g,``),g=c=>t.replace(/./g,c))=>`${s=`+${g(`-`)}+
`}|${t}|
${s}${g(` `))v`

Haskell, 107 Bytes
This answer is heavily based on the answer by Zylviij and the comments by nimi. I would have added more comments to that answer, but alas, I don't have enough rep.
o n=t++'|':f++"|\n"++t++(f>>" ")++"v"where f=[c|c<-n,any(==c)$['0'..'9']++['A'..'Z']];t='+':(f>>"-")++"+\n"

Additional tricks used:

Replaced intersect by its implementation so the import can be dropped. (Side note: the implementation is nearly verbatim the library one, I couldn't find a shorter version.)
Moved the helper functions into the where clause so functions can use the n parameter internally.
After that, (#) was short enough to be inlined.
Put everything on one line to limit extra whitespace.

Python 3.5, 114 93 112 bytes:
import re;Y=re.findall('[A-Z0-9]',input());I='+'+'-'*len(Y)+'+\n|';print(I+''.join(Y)+I[::-1]+'\n'+' '*len(Y)+'v')

A full program. Basically uses a regular expression to match all occurrences of uppercase letters and numbers, then creates the box of the exact size based on the length of the list of matches, and finally puts the joined list of matches "inside" it.
Try It Online! (Ideone)

It's missing the bottom 'v'.

@CarlesCompany It's fixed, at the cost of 19 more bytes.

Python 3, 121 124 bytes
Fixed stupid mistake
s=''
for i in input():_=ord(i);s+=("",i)[91>_>64or 47<_<58]
x=len(s)
c='+'+"-"*x+'+'
print(c+"\n|"+s+"|\n"+c+"\n"+" "*x+"v")

does not import libraries like other python answer.

Does not work correctly. -1 Notify if you fix.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Fixed. Thank you

Actually, the link was golfing some code, and that's why I put it there.

Java 8, 149 bytes
s->{s=s.replaceAll("[^A-Z0-9]","");String t="+",r;int l=s.length(),i=l;for(;i-->0;t+="-");for(r=(t+="+\n")+"|"+s+"|\n"+t;++i<l;r+=" ");return r+"v";}

Try it online.
Explanation:
s->{                     // Method with String as both parameter and return-type
  s=s.replaceAll("[^A-Z0-9]","");
                         //  Leave only the uppercase letters and digits
  String t="+",          //  Temp-String, starting at "+"
         r;              //  Result-String
  int l=s.length(),      //  Amount of uppercase letters and digits `l`
  i=l;for(;i-->0;t+="-");//  Loop and append `l` amount of "-" to the temp-String
  for(r=(t+="+\n")       //  Append "+" and a new-line to the temp-String
        +"|"+s+"|\n"+t;  //  Set the result to `t`, "|", modified input, "|", new-line, `t`
                         //  all appended to each other
      ++i<l;r+=" ");     //  Loop and append `l` amount of spaces to the result
  return r+"v";}         //  Return the result-String with appended "v"

Perl, 57 bytes
56 bytes code + 1 for -p.
y/a-z //d;$d="-"x y///c;$_="+$d+
|$_|
+$d+
".$"x y///c.v

I originally tried to make this only using regexes, but it was much larger than I'd hoped, so I've used some string repetition instead.
Try it online!

Pyke, 39 bytes
cFDh~u{!Ih(sil\-*\+R\+sj\|i\|++jild*\v+

Try it here!
12 bytes of mini-string creation, 20 bytes of formatting. Joy!

Pyth, 38 37 bytes

Jj*\-lK@jrG1UTz"++"jK"||"JtXJ"-+"" v
Try it online.
Note the newline in the start.

Python 2, 113 bytes
def f(n):c=filter(lambda x:x.isupper()^x.isdigit(),n);L=len(c);h='+'+L*'-'+'+\n';return h+'|'+c+'|\n'+h+' '*L+'v'

Can you use ascii in Python? If yes you can use 47<x<58|64<x<91 :)

@aloisdg Unlike C/C++, Python doesn't use an integral char type - all characters in Python strings are themselves strings, and cannot be directly compared with integers. It would need to be 47<ord(x)<58or 64<ord(x)<91.

[x for x in n if x.isupper()^x.isdigit()] is one byte shorter than filter(lambda x:x.isupper()^x.isdigit(),n)

@LeakyNun: filter will return a string, but the list comprehension will return a list, which won't be usable in the return value expression.

Why XOR? Can't you use OR instead? XOR is more complex, and thus slower AFAIK. x.isupper()^x.isdigit() -> x.isupper()|x.isdigit()

Jolf, 35 bytes
Ά+,Alγ/x"[^A-Z0-9]"1'+'-'|γS*lγ" 'v

I need a shorter way to remove all but caps & numbers...

C, 171 163
Function f() modifies its input and prints out the result.
l;f(char*n){char*p=n,*s=n,c[99];for(;*n;++n)isupper(*n)+isdigit(*n)?*p++=*n:0;*p=0;memset(c,45,l=strlen(s));c[l]=0;printf("+%s+\n|%s|\n+%s+\n%*.cv\n",c,s,c,l,32);}

Test Program
Requires one parameter, the string to use in the favicon:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    char *input=malloc(strlen(argv[1])+1);
    strcpy(input,argv[1]);
    f(input);
    free(input);
    return 0;
}

Why do you copy the argv element?

Because the function modifies its input. I'm not sure modifying the parameters in place is defined behavior.

never thought about this... according to this SO answer it should be fine: http://stackoverflow.com/a/963504/3700391

Haskell, 161
import Data.List
r=replicate
l=length
f n=intersect n$['0'..'9']++['A'..'Z']
t n='+':(r(l$f n)'-')++"+\n"
o n=(t n)++"|"++(f n)++"|\n"++(t n)++(r(l$f n)' ')++"V"

Usage
o"Stack Overflow"
+--+
|SO|
+--+
  V

o"Area 51"
+---+
|A51|
+---+
   V

You're using replicate, length and f exclusively in this combination, so you can merge them into one function: r=replicate.length.f and call it like r  n '-'.  You can save even more bytes by using an infix operator: (#)=replicate.length.f and n#'-' / n#' '. Additionally replicate.length is  >> (with a singleton string instead of a char), so it's: (#)=(>>).f and n#"-" / n#" ", both without ( ) around it.

... also: no need for the ( ) around t n and f n. "|"++ is '|':. All in all: o n=t n++'|':f n++"|\n"++t n++n#" "++"V".

Bash, 99 74 bytes
s=$(sed s/[^A-Z0-9]//g);a=${s//?/-};echo -e "+$a+\n|$s|\n+$a+\n${s//?/ }v"

Usage: Run the above command, type the site name, press enter and then Ctrl + D (send 'end of file').

MATL, 34 bytes
t1Y24Y2hm)T45&Ya'+|+'!wy&h10M~'v'h

Try it online!
t        % Implicit input. Duplicate
1Y2      % Uppercase letters
4Y2      % Digit characters
h        % Concatenate horizontally: string with uppercase letters and digits
m        % True for input chars that are uppercase letters or digits
)        % Keep only those
T45&Ya   % Pad up and down with character 45, which is '-'. Gives three-row char array
'+|+'!   % Push this string and transpose into a column vector
wy       % Swap, duplicate the second array from the top. This places one copy of the
         % column vector below and one above the three-row char array
&h       % Contatenate all stack arrays horizontally. This gives the box with the text
10M      % Retrieve the string with selected letters
~        % Logical negate. Gives zeros, which will be displayes as spaces
'v'      % Push this character
h        % Concatenate horizontally with the zeros.
         % Implicitly display the box with the text followed by the string containing
         % the zero character repeated and the 'v'

R, 108 bytes
cat(x<-gsub("(.*)","+\\1+\n",gsub(".","-",y<-gsub("[^A-Z0-9]","",s))),"|",y,"|\n",x,gsub("."," ",y),"v",sep="")

Explanation
Going from the inside out (because who doesn't love assigning global variables from inside a regex), assuming s is our input string:
y<-gsub("[^A-Z0-9]","",s) keeps capitals and numbers, assigns the resulting value to y.
gsub(".","-",y<-...) replaces all characters with hyphens in the above.
x<-gsub("(.*)","+\\1+\n",gsub(...)) chucks a + on either end of the row of hyphens, and a newline, and we store that as x.
The rest is pretty straightforward, output in the appropriate order, and use the fact that the number of spaces before the v will be the same as the length of y.

APL, 52 49 bytes
{x⍪2⌽'v'↑⍨≢⍉x←⍉z⍪⍨(z←'+|+')⍪'-','-',⍨⍪⍵/⍨⍵∊⎕D,⎕A}

(down to 49 thanks to the comment).

{x⍪2⌽'v'↑⍨≢⍉x←⍉z⍪⍨(z←'+|+')⍪'-','-',⍨⍪⍵/⍨⍵∊⎕D,⎕A} (You never parenthesize one of the arguents in a reversed argument function when golfing. It always can be in normal order to save a byte.)

CJam, 41
"||"q_'[,65>A,s+--*__"+-"er_@\_,((S*]N*'v

Try it online

Brachylog, 61 bytes
Linked to the repository at Jul 7 to ensure backward compatibility.
lybL:{,."-"}ac:"+"c:"+"rcAw@NNw"|"Bw?wBwNwAwNwL:{," "w}a,"v"w

Non-competing, 53 bytes
lL:"-"rjb:"+"c:"+"rcAw@NNw"|"Bw?wBwNwAwNw" ":Ljbw"v"w

Try it online!

JavaScript (ES6), 119 bytes
h=a=>"+"+"-".repeat(a.length)+"+\n";j=a=>(a=a.replace(/[^A-Z0-9]/g,""),h(a)+"|"+a+"|\n"+h(a)+" ".repeat(a.length)+"v");

J, 52 bytes
'v'(<3 _2)}4{.1":]<@#~2|'/9@Z'&I.[9!:7@'+++++++++|-'

Try it online!
   [9!:7@'+++++++++|-'            Set the box drawing characters.
        '/9@Z'&I.                 Interval index, 1 for numbers, 3 for
                                  uppercase letters.
          ]  #~2|                 Mod 2, and filter
                                  the characters that correspond to 1s.
           <@                     Put them in a box.
           1":                    Convert to a character matrix, so we can do stuff to it.
           4{.                    Add a 4th line filled with spaces
       'v'(<3 _2)}                Insert a “v” at 3,−2

Ruby, 81 bytes (78 + -p flag)
gsub(/[^A-Z\d]/,'')
gsub(/.+/){"+#{k=?-*s=$&.size}+
|#{$&}|
+#{k}+
#{' '*s}v"}

PHP, 112 bytes
<?$s=str_replace('-',' ',$m=ereg_replace('.','-',$n=ereg_replace('[^A-Z0-9]','',$x)));echo"+$m+
|$n|
+$m+
$s",v;

PHP<5.4 with register_globals=1, call php-cgi -f <filename> x="<name>";echo""
add <pre> after echo" for call in web browser <scriptpath>?x=<name>;
for PHP>=5.4: replace $x with $_GET[x] (+6)
or with $argv[1] to call php <filename> "<name>";echo"" (+6)
you may want to add -d error_reporting=0 to cli options

There are times when I love that PHP accepts newlines in constant strings.

str_repeat looked like a buddy here, but costs 3 bytes
<?=(<assignments>)?"<output>".v:0 costs 1 byte
<?=(<assignments>),"
<output>",v; does neither cost nor save, but adds a leading blank line to the output

Common Lisp (Lispworks), 159 bytes bytes
(defun f(s)(labels((p(c l)(dotimes(i l)(format t"~A"c))))(let((l(length s)))#1=(p"+"1)#2=(p"-"l)#3=(format t"+~%")(format t"|~A|~%"s)#1##2##3#(p" "l)(p"v"1))))

ungolfed:
(defun f (s)
  (labels ((p (c l)
             (dotimes (i l)
               (format t "~A" c))))
    (let ((l (length s)))
      #1=(p "+" 1)
      #2=(p "-" l)
      #3=(format t "+~%")
      (format t "|~A|~%" s)
      #1#
      #2#
      #3#
      (p " " l)
      (p "v" 1))))

Usage:
CL-USER 2 > (f "so")
+--+
|so|
+--+
  v
NIL

CL-USER 3 > (f "pcg")
+---+
|pcg|
+---+
   v
NIL

Japt 2.0 -R, 37 36 bytes
Saved 1 byte thanks to Shaggy
r/\W|\a/
'+²¬qUÊî-
[V'|+U+'|V'viUÊî]

Run it online

r/\W|\a/ should save a byte.

SmileBASIC 3, 131 bytes
INPUT N$WHILE""<N$C$=SHIFT(N$)IF@0<C$&&"[">C$||"/"<C$&&":">C$THEN W$=W$+C$
WEND
L=LEN(W$)H$="+"+"-"*L+"+
?H$?"|"+W$+"|
?H$?" "*L+"v

Kotlin, 129 126 bytes
{s:String->val x=s.filter{it in('A'..'Z')+('0'..'9')}
val h="-".repeat(x.length)
"+$h+\n|$x|\n+$h+\n${" ".repeat(x.length)}v"}

Try it online!

C# (Visual C# Interactive Compiler), 128 bytes
x=>{x=Replace(x,"[^A-Z0-9]","");Write("{0}{1}\n{0}{2}","+"+"+\n".PadLeft(x.Length+2,'-'),$"|{x}|","v".PadLeft(x.Length+1,' '));}

Try it online!

source: Stack Exchange

license: 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/

sort: votes


text:
Can Mario go to the end of this map
Create a program that determines, given an input of the path, whether Mario can reach the end, denoted by E, from the start, denoted by S.
A path will look something like this:
S = E
=====

In a path, the various symbols and what they represent are:

=: wall/floor/ceiling. Mario cannot walk through wall , and cannot fall past a floor, or jump past a ceiling (he would hit his head)
  (space): air. Mario can walk through this, and jump through it, and fall through it
S: air, except showing where Mario starts. This will always appear in the left-most column of the input, at ground level.
E: air, except showing where Mario wants to get. This will always appear in the right-most column of the input, at ground level.

The input will have spaces at every place where Mario could walk.
Mario can only move forward; in this example Mario cannot get to the goal
S
===

 ===
   E
====

nor can he in this one
    E
   ==
==
  #==
==
   ==
==
S  ==
======

However, he can reach the space denoted by # (which will not appear in input), because he can jump up to four cells high; Mario is superhuman. As another example of his superhumanity:
S
=
=
=
=
=
= #
= =
=
=
=
=     E
=======

Mario can get to the E by falling the great distance, surviving, and walking calmly to E. Note that he cannot reach the #, because Mario falls straight down.
Mario can jump really high, but not very far forward by comparison.
S   E
== ==
 = =

Mario may attempt to jump the gap, but he will fail, and fall straight in. he cannot reach the end.
Mario can reach the goal in all of these examples:
 E
 =
 =
 =
S=
==

 =
 =   E
S=   =
==   =
 =   =
 =====

S
=

=  E
====

This is code golf, so fewest bytes wins!

This looks similar with MarioLANG.

Is the bounty for a solution in MarioLANG?

In the falling example, you mention that "he cannot reach the #, because Mario falls straight down."  If I'm viewing this correctly, wouldn't he fall straight down onto the #?  Also, are jumps defined as a maximum of 4 spaces up and maximum of 1 space right?

Presumably in your very first picture of a layout, it would be feasible if there were another line of spaces first.

Can Mario jump to the lower of two platforms that start at the same X?

@GuitarPicker I thought that at first aswell but if you look closely you can see there is another column of spaces before the column with the #. As to the second question: I'm not OP but I'm guessing you are right. (that's what I assumed in my solution)

After the bounty ends I may put one up for the first valid answer in MarioLANG.

Thanks, @KarlKastor.  That's exactly what I was missing.

Do you permit leading spaces in input. Can I require being provided with leading spaces?

Is it assumed that the intput is simply a long string with newline characters? Or can we take input as a list of row strings?

In the third example (demonstrating Mario's jump height), E does not appear in the right-most column because the ground level extends one to the right from the rest of the map.

Can we assume a (reasonable) formatting of input desirable for our answers? If not: array of strings or newline-delimited string? trailing new line or not? trailing spaces in every line, lines trimmed, undefined, or free choice? windows, macos, unix linebreaks, or free choice?

@Joffan: an extra blank line in the first example would make it solvable, because Mario could jump over the wall in the middle.

@Joffan: Mario cannot walk through wall , and cannot fall past a floor, or jump past a ceiling

@Titus I'm thinking about Mario jumping into clear air and having a choice of different floors to land on - can he get to the lower one?

@TùxCräftîñg We need some clarification over here. What do you think?

@TùxCräftîñg: another link discussing the same ambiguity in your specification betseg linked.

Mario must jump up n, then walk right; not jump up n-1  then 1 up+1 right in the same move. correct?

@Joffan: Yes, Mario can chose.

Slip, 38 27 25 bytes
S>(`=<<`P{1,5}>`P>`P*)+#E

Requires input to be padded to a rectangle such that there are spaces in every cell Mario needs to traverse (potentially with a leading line full of spaces). Prints either a string representing the valid path (which includes S, E and all the = walked on except the last) or nothing if no path exists.
Test it here.
Explanation
Slip was Sp3000's entry to our 2D pattern matching language design challenge. It's a bit like a 2D-extension of regex where you can give instructions to the engine's cursor when it's allowed or required to make left or right turns. It also has a convenient feature where you can prevent the cursor from advancing, allowing you to match a single position twice in a row (with different patterns).
Slip doesn't have something comparable to lookarounds in regex, but since you can move over any position multiple times, one can just test the condition and then return. We use this to ensure that we only jump when on the ground by moving into the ground tile after each step.
S           Match the starting position S.
>           Turn right, so that the cursor points south.
(           One or more times... each repetition of this group represents
            one step to the right.
  `=          Match a = to ensure we've ended up on ground level before.
  <<          Turn left twice, so that the cursor points north.
  `P{1,5}     Match 1 to 5 non-punctuation characters (in our case, either space,
              S or E, i.e. a non-ground character). This is the jump.
  >           Turn right, so that the cursor points east.
  `P          Match another non-ground character. This is the step to the right.
  >           Turn right, so that the cursor points south.
  `P*         Match zero or more non-ground characters. This is the fall.
)+
#           Do not advance the cursor before the next match.
E           Match E, ensuring that the previous path ended on the exit.

Java 234 230 221 216 208 207 205 179 Bytes
Look, I beat C and python? I have acheived true transcendence among mortals!  All jokes aside, this was  a fun challenge. The following function takes input as an array of column strings each with the same length. If this is against the rules please do let me know. It outputs 1 meaning a successful mario run, and any other value implying a failed mario run.
int m(String[]a){int l=a.length-1,z=a[l].indexOf(69),m=a[0].indexOf(83),i=1,x;a[l]=a[l].replace("E"," ");for(;i<=l;m=x,i++){if(m-(x=a[i].indexOf('='))>3|x<1)return-1;}return m-z;}

Here is the older logic (which is similar to the current version) with example use and output. Plus some comments explaining the logic
/**
 *
 * @author Rohans
 */
public class Mario {

    int m(String[] a) {
//declare variables for the finish the location of mario and the length
        int z, l = a.length - 1, m = a[0].indexOf("S");
        //treat the exit as a space
        z = a[l].indexOf("E");
        a[l] = a[l].replaceAll("E", " ");
        //go through the map
        for (int i = 1, x, r = 1; i <= l; i++) {
            //if mario can safely jump to the next platform (it picks the highest one)
            if (((x = a[i].indexOf("=")) != 0 && (x = a[i].indexOf(" =")) == -1) || m - x > 4) {
                return 0;
            }
            //adjust marios y location
            m = x;
        }
        //make sure mario made it to the end of the level
        return m == z ? 1 : 0;
    }

    public static void MarioTest(String... testCase) {
        System.out.println(new Mario().m(testCase) == 1 ? "Mario made it" : "Mario did not make it");
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        MarioTest("   S=", "=====", "     =", "     =", "=   =", "     E=");

    }

}

Let us continue this discussion in chat.

Does not work if the correct path is below a reachable "="

@KarlKastor, you did get me, but the given test case is correct. The issue is that the op did not spefcify whether there would be multiple ways the mario could go at each step

Well, I assumed there would be because I would always assume the more genral version if additional constrainst aren't specified.

@KarlKastor yeah ur right

Python, 260 239 222 215 209 206 Bytes,
try it on ideone (with test cases)
f=lambda m,y=-1,x=0:f(m,m[0].find("S"))if y<0else y<len(m[0])-1and x<len(m)and m[x][y]!="="and(m[x][y]=="E"or m[x][y+1]=="="and any(f(m,y-i,x+1)for i in range(5)[:(m[x][y::-1]+"=").find("=")])or f(m,y+1,x))

call like: f([' S=', ' E='])
patch notes:
Now, like some of the other solutions, assumes input is an array of coloumn strings, each starting with a " "
Wrapper for old input form: g=lambda x:f(map("".join,zip(*([" "*x.index("\n")]+x.split("\n")))))
Also, I fixed a bug where Mario could jump through blocks above him.
ungolfed version with explanations:
f recursivly calls itself in all directions Mario can move to from y,x. It returns True when it reaches the "E"nd, which then goes back through all the function calls until g finally returns True.
def g(x):
    #create a array of strings which are the rows of the input
    global m
    m=x.split("\n")
    m=[" "*len(m[0])]+m # because Mario can jump over sometimes
    #Mario starts at the S
    return f([i for i,a in enumerate(m) if a[0]=="S"][0],0)

def f(y,x):
    #print y,x
    if y>len(m)-2 or x>=len(m[0]) or y<0: return False #out of bounds
    if m[y][x]=="E":return True #Reached the goal
    if m[y][x]=="=":return False #We got stuck inside a wall
    if m[y+1][x]=="=": #if you have ground under your feet
        for i in range(5): #jump max 4
            if f(y-i,x+1): #go one forward and try to go further from there
                return True
    return f(y+1,x) ##fall down

If jumping doesn´t help, you fall through the ground. Add an else before the final return?

Snails, 41 37 29 bytes
Thanks to feersum for some help with avoiding overlapping paths and for saving 4 bytes.
=\S(^=d=\=u\ ,4(r!\=d.),r),\E

Requires input to be padded to a rectangle such that there are spaces in every cell Mario needs to traverse (potentially with a leading line full of spaces).
Try it online!
Explanation
Snails was feersum's entry to our 2D pattern matching language design challenge. Like Slip it's also similar to regex, but the major difference is that a) this one supports assertions (lookarounds) and b) aside from these assertions, it's not possible to traverse any cell in the grid twice. That makes this problem a bit tricky, since there are cases where Mario needs to fall into a hole and jump back out, e.g.:
S E
= =
===

Apart from these differences, the syntax of the two languages also differs quite a lot.
To circumvent the issue that we can't traverse a cell twice, we always alternate a horizontal step with a vertical step. However, this means that we have need to handle a fall before we step over the ledge. So falls will technically actually go through ground tiles but we'll ensure that they only happen next to open space.
=\S        Ensure that the match starts on an S, without actually matching it.
(          This group matches zero or more steps to the right (with a potential
           vertical step after each one).
  ^=         Match a non-ground cell, stepping right (on the first iteration,
             there is no step yet, so this matches the S).
  d=\=       Ensure that there's a ground tile below, so that the step ends on
             a valid position.
  u\ ,4      Match 0 to 4 spaces going up. This the optional jump.
  (          This group matches zero or more steps down, if a fall is valid here.
    r!\=       Ensure that there is no ground-tile right of the current cell.
    d.         Take one step down onto any character.
  ),
  r          Reset the direction to right for the next iteration.
),
\E        Match the exit.

C, 256 236 213 197 bytes
20 bytes saved by "This will always appear in the left-most column of the input"
23 bytes saved thanks to @RohanJhunjhunwala's column-based system
Try it on ideone, with test cases...

k,y,x,h;f(v,l)char**v;{h=strlen(*v);x=strcspn(*v,"S");while(y<l&x<h)if(v[y][x]==69)return 0;else if(v[y][x+1]^61)x++;else{if(v[y+1][x]==61)while(k<4)if(v[y+1][x-++k]^61){x-=k;break;}y++;}return 1;}

Usage:
$ ./mario "S=" " =" " =" " =" "E="
main(c,v)char**v;{printf("%s",f(v+1,c-1)==0?"true":"false");}

Ungolfed with explanation:
k,y,x,h; //omitting int for saving 4 bytes, global variables initialize as 0 by default
f(v,l)char**v;{ //saving 2 bytes
    h=strlen(v[0]); //get height of map
    x=strcspn(v[0],"S"); //where is start point?
    while(y<l&&x<h) //while not out of bounds
        if(v[y][x]==69)return 0; //if we hit end return 0 (69 is ASCII E)
        else if(v[y][x+1]!=61)x++; //we fall one block if there isn't floor underneath us (61 is ASCII =)
        else{
            if(v[y+1][x]==61) //if there is a wall in front of us
                while(k<4) //start counting
                    if(v[y+1][x-++k]!=61){ //if found a way
                        x-=k; //go to there
                        break; //we don't want to jump multiple times
                    }
            y++; //finally, walk one block forwards
        }
    return 1; //if out of bounds
}

Ideone say that there is a runtime error

Oh, I didn't see that.

Wait, you are coding on mobile ಠ_ಠ

Ye, I spilled coke on my laptop :P

(Not to be mean to betseg, just to ensure fairness) @TùxCräftîñg: Is this solution compliant with your challenge because it takes a array of Strings (already split on "\n") and also has as input the length and width of the map (not part of the input in your challenge)?

@KarlKastor I added one which doesn't get height & length.

@TùxCräftîñg no more runtime errors! Yay!

this throws a runtime error if there is a lower path possible than the solution path

@KarlKastor strange, it looks like this on my phone.

@betseg either way, it should've said "ye"

@KarlKastor, question says "E: air, except showing where Mario wants to get. This will always appear in the right-most column of the input, at ground level.", so my program doesn't know that end is up in the air

In my test case the E is above a "=". OP didn't specify wether E is at the upper- or lowermost possible position. (or does ground level mean the lowermost? then the third test case would be invalid) The Java solution always takes the uppermost possible path, your solution always takes the lowermost path. At least one of them must be false. Most likely both, I can make a map with two dead ends where both of you will get stuck.

Below 200! Also resolved the bug with second test case.

Grime, 46 bytes (non-competing)
A=\E|[S ]&<\ {,-4}/0/./* \ /*/A/\=/./*>
n`\S&A

I have updated Grime several times after this challenge was posted, so this answer is not eligible for winning.
Some of the changes are so new that I haven't been able to get them into TIO, but once I do, you can try out the program.
In any case, my repository contains a version that handles this code correctly.
The program prints 1 if Mario can reach the goal, and 0 if not.
The input has to contain spaces in all places Mario needs to visit.
For general inputs, I have the following 57-byte solution:
A=\E|[ \bS]&<[ \b]{,-4}/0/[]/* [ \b]/*/A/\=/[]/*>
nb`\S&A

Explanation
The high-level explanation is that the nonterminal A, defined on the first line, matches a 1×1 sub-rectangle of the input where Mario can reach the goal.
A is defined as either the literal E (Mario is already at the goal), or as a 1×1 pattern that's on the left column of some 2×n rectangle containing a valid Mario jump to another match of A on the right column.
The second line counts the number of matches of A that also contain the start character S, and prints that.
Here's a break-down of the code:
A=\E|[ S]&<\ {,-4}/0/./* \ /*/A/\=/./*>
A=                                       Define A as
  \E|                                    a literal E, or
     [ S]&                               a literal space or S
          <                           >  contained in a larger rectangle
                                         that this bracketed expression matches.
           \ {,-4}/0/./*                 Left half of the bracketed expression:
           \ {,-4}                        Rectangle of spaces with height 0-4,
                  /                       below that
                   0                      the 1x1 rectangle we're currently matching,
                    /.                    below that any 1x1 rectangles
                      /*                  stacked any number of times vertically.
                         \ /*/A/\=/./*   Right half of the bracketed expression:
                         \ /*             Spaces stacked vertically,
                             /A           below that another match of A,
                               /\=        below that a literal =,
                                  /./*    below that 1x1 rectangles stacked vertically.

The idea is that the \ {,-4} part on the left matches the space through which Mario jumps upward, and the \ /* part on the right matches the space trough which he then falls down.
We require that he lands on a match of A (since we want to reach the goal) that's on top of a =.
The vertical stacks below both columns will simply guarantee that the columns have the same height, so we can concatenate them (which is what the single space in the middle does).
Here's an ASCII art diagram of an example jump, broken into the aforementioned rectangles, and with spaces replaced by *s:
Left column:     Right column:   +---+---+
a = \ {,-4}      d = \ /*        | * | * |
b = 0            e = A           +   +   + d
c = ./*          f = \=          | * | * |
                 g = ./*       a +   +---+
                                 | * | * | e
                                 +   +---+
                                 | * | = | f
                                 +---+---+
                               b | S | = |
                                 +---+   | g
                               c | = | * |
                                 +---+---+

On the second line, the option n triggers counting of all matches, instead of finding the first match.
In the general solution, the spaces can also be special out-of-input characters, and option b causes the input to be padded with out-of-input characters.
I hope all of this makes sense!

PHP, 399 338 284 265 251 bytes
<?function w($m,$p){$w=strpos($m,"
")+1;if($p>strlen($m)|($p%$w)>$w-2|$p<0|'='==$m[$p])return 0;if('E'==$m[$p])die(1);if('='!=$m[$p+$w])return w($m,$p+$w);else for(;$z<5&'='!=$m[$q=$p-$w*$z];$z++)if(w($m,$q+1))die(1);}die(w($m=$argv[1],strpos($m,S)));

expects input as command line argument with unix style line breaks and trailing spaces in every line, returns exit code 1 for success, 0 for failure
breakdown to function
function w($m,$p) // function walk
{
    $w=strpos($m,"\n")+1;
    if($p<0|$p>strlen($m)|($p%$w)>$w-2  // too high / too low / too far right
        | '='==$m[$p]                   // or inside a wall
    )return 0;
    if('E'==$m[$p])return 1;            // Exit found
    if('='!=$m[$p+$w])return w($m,$p+$w); // no wall below: fall down
    else for($z=0;$z<5                  // else: jump
        & '='!=$m[$q=$p-$w*$z]          // do not jump through walls
        ;$z++)
        if(w($m,$q+1))                  // try to walk on from there
            return 1;
    // no success, return failure (NULL)
}
function m($i){$argv=[__FILE__,$i];
    return w($m=$argv[1],strpos($m,S));     // walk through map starting at position of S
}

tests (on function m)
$cases=[
    // examples
    "S = E\n=====",0,
    "S   \n=== \n    \n ===\n   E\n====",0,
    "    E \n   == \n==    \n   == \n==    \n   == \n==    \nS  == \n======",0,
    "S      \n=      \n=      \n=      \n=      \n=      \n=      \n= =    \n=      \n=      \n=      \n=     E\n=======",1,
    "S   E\n== ==\n = = ",0,
    " E\n =\n =\n =\nS=\n==",1,
    "      \n =    \n =   E\nS=   =\n==   =\n =   =\n =====",1,
    "S   \n=   \n    \n    \n    \n    \n    \n    \n=  E\n====",1,
    // additional cases
    "S \n= \n=E",1,
    " == \n == \n    \nS==E\n==  ",1
];
echo'<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';
while($cases)
{
    $m=array_shift($cases);
    $e=array_shift($cases);
    $y=m($m);
    $w=strpos($m,"\n");
    echo"<tr><td><div style=background-color:yellow;width:",$w*8,"px><pre>$m</pre></div>width=$w</td>
        <td>$y</td><td>$e</td><td>",$e-$y?'N':'Y',"</td></tr>";
}
echo'</table>';

to whoever: Will let you please let me know why you downvoted this?

Ruby, 153 147 bytes
Sorry, Java... your spot as best non-golf lang for the job is being taken over!
Input is a list of column strings, prepended with a single space in the style of how the Slip and Snails solutions require their inputs to be padded with a rectangle of empty space.
Try it online!
f=->m,j=0,s=p{c,n=m[j,2]
s||=c=~/S/
e=c=~/E/
s+=1 while(k=c[s+1])&&k!=?=
s==e||(0..4).any?{|i|k&&s>=i&&c[s-i,i]!~/=/&&n&&n[s-i]!=?=&&f[m,j+1,s-i]}}

nooooo.... but u did "borrow" my method of columnar strings

Well I mean, all the cool kids were doing it already. Might craft a row-based solution later, doing a "quick fix" to modify rows into columns to keep my current code loses to your Java by 10 bytes, but an actual solution might be shorter regardless

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


text:
Normal sentences
Write a program or function which, given an input string and a standard deviation σ, outputs that string along the normal distribution curve with mean 0 and standard deviation σ.
Normal distribution curve
The y coordinate of each character c is:

where σ is given as input, and where x is the x axis coordinate of c.

The character in the center of the string has x = 0. If the string's length is even, either of the two middle characters can be chosen as the center.
Characters are separated by steps of 0.1 (e.g. the character to the left of the center one has x = -0.1, the one to the right of the middle one has x = 0.1, etc.).

Printing the string

Lines, like characters, are separated by steps of 0.1.
Each character is printed on the line with the y value that is closest to its own y value (if the value is precisely in between the values of two lines, choose the one with the biggest value (just like how round usually returns 1.0 for 0.5)).
For example, if the y coordinate of the center value (i.e. the maximum value) is 0.78 and the y coordinate of the first character is 0.2, then there will 9 lines: the center character being printed on line 0 and the first character being printed on line 8.

Inputs and outputs

You may take both inputs (the string and σ) as program arguments, through STDIN, function arguments or anything similar in your language.
The string will only contain printable ASCII characters. The string can be empty.
σ > 0.
You may print the output to STDOUT, in a file, or return it from a function (as long as it is a string and not say a list of strings for each line).
A trailing new line is acceptable.
Trailing spaces are acceptable as long as they don't make the line exceed the last line in length (so no trailing space is acceptable on the last line).

Test cases
σ    String

0.5  Hello, World!

     , W
   lo   or
  l       l
 e         d
H           !

0.5  This is a perfectly normal sentence

                tly
              ec    n
             f       o
            r         r
           e           m
          p             a
        a                l
      s                    se
This i                       ntence

1.5  Programming Puzzles & Code Golf is a question and answer site for programming puzzle enthusiasts and code golfers.

                                                d answer site for p
                                      uestion an                   rogramming
                      Code Golf is a q                                        puzzle enthusia
Programming Puzzles &                                                                        sts and code golfers.

0.3  .....................

          .
         . .

        .   .

       .     .

      .       .

     .         .
    .           .
   .             .
...               ...

Scoring
This is code-golf,
                 nsw
                a   er
              t
             s         i
            e           n
           t
         or               by
       sh                   te
so the                        s wins.

Related. Related.

Related.

I think the last test case should have 3 dots in the top row, not 1.

@addison I don't have my reference implementation on this computer but I don't know why Mego get's a different result. The result he obtains with his code seems very "blocky". Ignore that test case for the moment I guess.

@Fatalize I think I see the discrepancy - my solution isn't printing out the blank lines. I'll work on fixing that after I get a byte to eat.

Is only one trailing newline acceptable, or can there be multiples?

@Mego Only one is acceptable.

@Fatalize I have just realised that my answer is not rounding in exactly the way that you specify (i.e. up for x.x5). Both SciPy's around (which I am using) and Python's builtin round use round half to even, not round half up. Is this OK?

@TheBikingViking I'll let that pass, that's fine.

Python 3 with SciPy, 239 233 bytes
from scipy import stats,around,arange
def f(s,t):
 l=len(t);p=[];y=around(stats.norm.pdf((arange(l)-l//2)*.1,scale=s),1)*10
 for i in range(l):p+=[[' ']*(max(y)-y[i])];p[i]+=[t[i]]+[' ']*(y[i]-y[0])
 for j in zip(*p):print(*j,sep='')

A function that takes input via argument of standard deviation s and string t, and prints the result to STDOUT.
How it works
from scipy import stats,around,arange  Import the statistics, rounding and range functions
                                       from SciPy
def f(s,t):                            Function with input standard deviation s and string
                                       t
l=len(t);p=[]                          Define the much-used length of t as l and initialise
                                       the print values list p
arange(l)                              Generate a list of integer x values in [0,l)...
...-l//2*.1                            ...and scale such that 0 is at the middle character
                                       and the x-step is 0.1
stats.norm.pdf(...,scale=s)            Generate a list containing the y values for each x
                                       value by calling the normal probability
                                       density function scaled with s...
y=around(...,1)                        ...round all values to 1 decimal place...
...*10                                 ...and multiply by 10 to give the vertical index of
                                       each character
for i in range(l):...                  For all characters in t...
p+=[[' ']*(max(y)-y[i])]               ..add the number of lines below the character as
                                       spaces...
p[i]+=[t[i]]+[' ']*(y[i]-y[0])         ...add the character and the number of lines above
                                       the character as spaces

This leaves p containing a list for each desired output line, but transposed.

for j in zip(*p):...                   For every output line in the transpose of p...
print(*j,sep='')                       ...print the output line

Try it on Ideone

Ruby: 273 254 Bytes
->n,s{j,o,g,r,l=-(n.size/2),[],0,{}
n.gsub(/./){(r[((2*Math::PI)**-0.5*10*Math.exp(-(j/1e1)**2/2/s/s)/s).round]||="")<<$&
j+=1}
r.sort.map{|y, c|o<<(l ?$/*(y-l-1):"")+(" "*g)+(c[0,(h=c.size)/2])+(" "*(n.size-g*2-h))+(c[h/2,h])
g+=h/2
l=y}
puts o.reverse}

A huge thanks to Kevin Lau for saving 18 bytes!

Lambdas don't need parens: ->n,s{... is fine. You don't need brackets when assigning multiple variables: o,g,r,l=[],0,{} works just fine. $/ can be used in place of ?\n. Order of operations means you don't have to put all your multiplies on line 5 in parens. puts automatically unfolds arrays and separates them with newlines when printing. n.gsub(/./){... beats out n.each_char{... by a bit because you can take out the |c| and put $& where any mention of c was. Make your hash values strings (start with ||="" not ||=[]) and you can change c[...]*"" to c[...]


text:
Truncate consecutive character runs to n length
The challenge
Given an input string, and an integer n - truncate any runs of consecutive characters to a maximum of n length. The characters can be anything, including special characters. The function should be case sensitive, and n can range from 0 to infinity.
Example inputs/outputs:
f("aaaaaaabbbccCCCcc", 2) //"aabbccCCcc"
f("aaabbbc", 1) //"abc"
f("abcdefg", 0) //""
f("aaaaaaabccccccccCCCCCC@", 4) //"aaaabccccCCCC@"

Scoring
The scoring is based on the number of bytes used.
Thus
function f(s,n){return s.replace(new RegExp("(.)\\1{"+n+",}","g"),function(x){return x.substr(0, n);});}

would be 104 points.
Happy golfing!
Edit: removed language restriction, but I still would love to see javascript answers

Why don't allow ES6 ?

I'd recommend losing the language requirement. Javascript is one of the most common languages here. Self answering with what you got would probably invite people to help you golf, or try to beat you with another approach. Further, if you get enough reputation you can add a bounty to the question with a specific language in mind. If that doesn't sit well with you, you could modify this question into a [tag:tips] question and try to ask for specific golfing help.

Removed language restriction and changed scoring rules as a result. I would still love to see javascript entries, but I guess I can live with some 4-5 character golf languages.

Welcome to Programming Puzzles & Code Golf! Code golf challenges are scored by length in bytes by default. While scoring by length in characters is possible, you're bound to get some answers like this one.

Oh, god. Changed to byte scoring.

C, 81 78
Modifies the incoming string.
c,a;f(p,n)char*p;{char*s=p;for(;*p;s+=c<n)*s=*p++,a^*s?c=0:++c,a=*s;c=a=*s=0;}

Test Program
Requires two parameters, the first is the string to truncate, the second is the length limit.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    char *input=malloc(strlen(argv[1])+1);
    strcpy(input,argv[1]);
    f(input,atoi(argv[2]));
    printf("%s\n",input);
    free(input);
    return 0;
}

Explanation:
c,a;                 //declare two global integers, initialized to zero.
                     //c is the run length, a is the previous character
f(char*p,int n){...} //define function f to truncate input
char*s=p;            //copy p to s; p is source, s is destination
for(;*p              //while there is a source character
;s+=c<n)             //increment copied pointer if run is under the limit
*s=*p++,             //copy from source to destination, increment source
a^*s?c=0:++c,        //if previous character != current then run=0 else increment run
a=*s;                //previous character = current source character
c=a=*s=0;            //after loop, terminate destination string with NUL and reset c and a.

This works because the source pointer will always be equal to or greater than the destination pointer, so we can write over the string as we parse it.

This is amazing, can you explain it?

@TestSubject06 - Added an explanation.

Does this work with the n=0 case? I can't get it to compile to test over here.

Yes, it does. I added a test program so you can compile.

Awesome, couldn't find any counter examples. Short and it works!

Save two more bytes: f(p,n)char*p;{/**/}

Python 2, 52 bytes
lambda s,n:reduce(lambda r,c:r+c*(r[-n:]!=c*n),s,'')

Written out as a program (54 bytes):
s,n=input();r=''
for c in s:r+=c*(r[-n:]!=c*n)
print r

Iterates through the input string s, appending each character to the output string r unless that last n characters of r are that character.
I though this would fail n==0 because r[-0:] is not the last 0 characters (empty string), but the entire string. But, it works because the string remains empty, so its keeps matching the 0-character string.
A recursive lambda gave 56 because of the repetition
f=lambda s,n:s and s[:f(s[1:],n)[:n]!=s[0]*n]+f(s[1:],n)

An alternate strategy to keep a counter i of repeats of the last character also turned out longer than just checking the last n characters directly.

Haskell, 36 bytes
import Data.List
(.group).(=<<).take

Point-free version of \n s -> concatMap (take n) (group s).

Javascript ES6, 60 54 55 43 bytes
-12 bytes thanks to @TestSubject06 and @Downgoat
(s,n)=>s.replace(/(.)\1*/g,x=>x.slice(0,n))

Example runs:
f("aaaaaaabbbccCCCcc"      , 2) -> "aabbccCCcc"
f("aaabbbc"                , 1) -> "abc"
f("abcdefg"                , 0) -> ""
f("aaaaaaabccccccccCCCCCC@", 4) -> "aaaabccccCCCC@"
f("a"                      , 1) -> "a"

f("a", 1) -> ""

@TestSubject06 Ah, that'll break it. Fixed.

new one fails on n=0

@TestSubject06 Yea, I just realized .slice(-0) won't return "", fixed for +1 byte.

Since your RegExp isn't dynamically controlled in any way you can save some bytes with RegExp("(.)\1*","g") -> /(.)\1*/g

Convert RegExp("(.)\\1*","g") to /(.)\1*/g

@TestSubject06 @Downgoat Ah, was trying that earlier but mistakenly was doing /(.)\\1*/g instead of /(.)\1*/g and wondering why that wasn't working. Thanks!

I don't see this getting smaller in JS unless we come at it from a completely different angle. Good job @Dendrobium!

I was wondering if there was a way to use something like positive/negative lookback to match only on characters after n in a run, so we can just replace with empty string, but that might end up being a longer regex, even after the bytes from the slice.

Shave one byte by changing (s,n) to s=>n, and the usage becomes f("aaaaaaabbbccCCCcc")(2)

MATL, 9 bytes
Y'i2$X<Y"

Try it Online
Explanation
        % Implicitly grab input as a string
Y'      % Perform run-length encoding. Pushes the values and the run-lengths to the stack
i       % Explicitly grab the second input
2$X<    % Compute the minimum of the run lengths and the max run-length
Y"      % Perform run-length decoding with these new run lengths
        % Implicitly display the result

'@@@@@bbbbbcccddeegffsassss'
3
returned
'@@@bbbcccddeegffsass' which is missing the final 's'

@TestSubject06 Thanks for pointing that out.

CJam, 12 bytes
{e`\af.e<e~}

Try it online!
Explanation
e`   e# Run-length encode the input. Gives a list of pair [length character].
\a   e# Swap with maximum and wrap in an array.
f.e< e# For each run, clamp the run-length to the given maximum.
e~   e# Run-length decode.

Pyth, 16 12 bytes

rm,hS,Qhdedrz8 9
ss<RQmM_Mrz8

Try it online!

Python 2, 56 bytes
import re
lambda s,n:re.sub(r'(.)(\1{%d})\1*'%n,r'\2',s)

gs2, 6 bytes
Encoded in CP437:
╠c╨<ΘΣ

This is an anonymous function (block) that expect a number on top of the stack and a string below it.
     Σ   Wrap previous five bytes in a block:
╠          Pop number into register A.
 c         Group string.
    Θ      Map previous two bytes over each group:
  ╨<         Take the first A bytes.

Try it online. (The code here is lines, dump, read number, [the answer], run-block.)

Perl 6,  38  36 bytes
->$_,$n {S:g/(.)$0**{$n..*}/{$0 x$n}/}
->$_,\n{S:g/(.)$0**{n..*}/{$0 x n}/}
Explanation:
-> $_, \n { # pointy block lambda
  # regex replace ( return without modifying variant )
  # globally
  S:global /
    # a char
    (.)
    # followed by ｢n｣ or more identical chars
    $0 ** { n .. * }
  /{
    # repeat char ｢n｣ times
    $0 x n
  }/
}

Test:
#! /usr/bin/env perl6
use v6.c;
use Test;

my &truncate-char-runs-to = ->$_,\n{S:g/(.)$0**{n..*}/{$0 x n}/}

my @tests = (
  ("aaaaaaabbbccCCCcc", 2) => "aabbccCCcc",
  ("aaabbbc", 1) => "abc",
  ("abcdefg", 0) => "",
  ("aaaaaaabccccccccCCCCCC@", 4) => "aaaabccccCCCC@",
);

plan +@tests;

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is truncate-char-runs-to(|@input), $expected, qq'("@input[0]", @input[1]) => "$expected"';
}

1..4
ok 1 - ("aaaaaaabbbccCCCcc", 2) => "aabbccCCcc"
ok 2 - ("aaabbbc", 1) => "abc"
ok 3 - ("abcdefg", 0) => ""
ok 4 - ("aaaaaaabccccccccCCCCCC@", 4) => "aaaabccccCCCC@"

Javascript ES5, 73
function f(s,n){return s.replace(RegExp("(.)(\\1{"+n+"})\\1*","g"),"$2")}

Re-uses Lynn's regex from her Python answer.

Your code does not handle the case where n is zero, it just returns the whole original string.

Yes, in Firefox, you can drop the braces and return statement, although that syntax is (sadly) deprecated and will be removed (it was actually absent a few versions back, didn't realize they brought it back).

You can also drop the new keyword for -4 bytes.

@TestSubject06 Thanks, I've edited my answer and I believe it passes the test cases now.

Perl 5, 50 bytes
46 bytes code + 3 for -i and 1 for -p
Takes the number to truncate to via -i.
s!(.)\1+!$&=~s/(.{$^I}).+/$1/r!ge

Usage
perl -i4 -pe 's!(.)\1+!$&=~s/(.{$^I}).+/$1/r!ge' <<< 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

Why is -p only one byte?

@someonewithpc when it can be combined with the -e these options only consume 1 byte. If the script has to be run from a file it costs 3 for the space and he flag itself. There's a meta post I'll try and find but I'm on mobile right now.

@someonewithpc http://meta.codegolf.stackexchange.com/questions/273/on-interactive-answers-and-other-special-conditions

Bash 46 bytes
read c;sed -r ":l;s/(.)(\1{$c})(.*)/\2\3/;t l"

Usage: Enter the number of characters to limit, press enter and enter the string. Ctrl + D to exit sed (send EOF).

Java 7, 107 106 bytes
String c(String s,int i){String x="";for(int i=-1;++i<j;)x+="$1";return s.replaceAll("(.)\\1{"+i+",}",x);}

Previous alternative inline for-loop for String concatenation (which is 1 byte more than String s="";for(int i=-1;++i<j;)s+="$1"; unfortunately):
String c(String s,int i){return s.replaceAll("(.)\\1{"+i+",}",new String(new char[i]).replace("\0","$1")));}

Ungolfed & test cases:
Try it here.
class Main {
  static String c(String s, int i){
    String x="";
    for(int j = -1; ++j < i;){
      x += "$1";
    }
    return s.replaceAll("(.)\\1{"+i+",}", x);
  }

  public static void main(String[] a){
    System.out.println(c("aaaaaaabbbccCCCcc", 2));
    System.out.println(c("aaabbbc", 1));
    System.out.println(c("abcdefg", 0));
    System.out.println(c("aaaaaaabccccccccCCCCCC@", 4));
    System.out.println(c("@@@@@bbbbbcccddeegffsassss", 5));
  }
}

Output:
aabbccCCcc
abc

aaaabccccCCCC@
@@@@@bbbbbcccddeegffsassss

Javascript (using external library) (115 bytes)
(s,r)=>_.From(s).Aggregate((c,n)=>{if(c.a!=n){c.c=1;c.a=n}else{c.c++}if(c.c<=r){c.b+=n}return c},{a:"",b:"",c:0}).b

Link to lib: https://github.com/mvegh1/Enumerable
Code explanation: Load the string into library, which internally parses as char array. Apply an accumulator on the sequence, passing in a custom object as a seed value. Property a is the current element, b is the accumulated string, and c is the sequential count of the current element. The accumulator checks if the current iteration value, n, is equal to the last element value, c.a. If not, we reset the count to 1 and set the current element. If the count of the current element is less than or equal to the desired length, we accumulate it to the return string. Finally, we return property b, the accumulated string. Not the golfiest code, but happy I got a solution that works...

J, 31 30 bytes
((<.#@>)#{.@>@])]<;.1~1,2~:/\]

Groups the input string into runs (substrings) of identical characters, and takes the minimum of the length of that run and the max length that was input for truncating the string. Then copies the first character of each run that many times.
Usage
   f =: ((<.#@>)#{.@>@])]<;.1~1,2~:/\]
   2 f 'aaaaaaabbbccCCCcc'
aabbccCCcc
   1 f 'aaabbbc'
abc
   0 f 'abcdefg'

   4 f 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

Explanation
((<.#@>)#{.@>@])]<;.1~1,2~:/\]  Input: k on LHS, s on RHS
                             ]  Get s
                        2~:/\   Test if each pair of consecutive chars are not equal
                      1,        Prepend a 1
                ]               Get s
                 <;.1~          Chop s where a 1 occurs to get the runs in s
    #@>                         Get the length of each run
  <.                            Take the min of the length and k
         {.@>@]                 Get the head of each run
        #                       Copy the head of each run min(k, len(run)) times
                                Return that string as the result

Dyalog APL, 22 20 bytes
(∊⊢↑¨⍨⎕⌊⍴¨)⊢⊂⍨1,2≠/⊢

Prompts for n and takes input string as argument.
( the tacit function ...
    ∊ flatten
    ⊢↑¨⍨ each element of the argument (i.e. each partition) truncated to
    ⎕⌊⍴¨ the minimum of the numeric input and the current length
) [end of tacit function] applied to
⊢⊂⍨ the input partitioned at the ᴛʀᴜᴇs of
1, ᴛʀᴜᴇ prepended to (the first character is not equal to its non-extant predecessor)
2≠/⊢ the pair-wise not-equal of characters in the input

Ruby, 32 bytes
->s,n{s.gsub(/(.)\1*/){$&[0,n]}}

TCC, 7 5 bytes
$~(;)

Input is a string and a number, seperated by space.
Try it online!
       | Printing is implicit
$~     | Limit occurence
  (;   | First part of input
    )  | Second part of input


text:
Interpret Kipple!
Introduction
Kipple is a stack-based, esoteric programming language invented by Rune Berg in March 2003.
Kipple has 27 stacks, 4 operators, and a control structure.
Stacks
The stacks are named a-z and contain 32-bit signed integers. There is also a special stack, @, to make outputting numbers more convenient. When a number is pushed onto @, the ASCII values of that number's digits are in fact pushed instead. (For example, if you push 12 to @, it will push 49 and then 50 to @ instead.)
Input is pushed onto the input stack i before the program is executed. The interpreter will ask for values to store in i before execution. After execution finishes, anything on the output stack o is popped to output as ASCII character . Since this is Kipple's only IO mechanism, interacting with a Kipple program is impossible.
Operators
An operand is either a stack identifier or a signed 32 bit integer.
Push: > or <
Syntax: Operand>StackIndentifier or StackIndentifier<Operand
The Push operator takes the operand to the left and pushes it onto the specified stack. For example, 12>a will push the value 12 onto stack a. a>b will pop the topmost value from stack a and push it onto stack b. Popping an empty stack always returns 0. a<b is equivalent to b>a. a<b>c pops topmost value from b and pushes to both c and a.
Add: +
Syntax: StackIndentifier+Operand
The Add operator pushes the sum of the topmost item on the stack and the operand onto the stack. If the operand is a stack, then the value is popped from it. For example, if the topmost value of stack a is 1, then a+2 will push 3 onto it. If a is empty, then a+2 will push 2 onto it. If the topmost values of stack a and b are 1 and 2, then a+b will pop the value 2 from stack b and push 3 onto stack a.
Subtract: -
Syntax: StackIndentifier-Operand
The Subtract operator works exactly like the Add operator, except that it subtracts instead of adding.
Clear: ?
Syntax: StackIndentifier?
The Clear operator empties the stack if its topmost item is 0.
The interpreter will ignore anything that isn't next to an operator, so the following program would work: a+2 this will be ignored c<i. However, the proper way to add comments is by using the # character. Anything between a # and an end-of-line character is removed before execution. ASCII character #10 is defined as end-of-line in Kipple.
Operands may be shared by two operators, e.g. a>b c>b c? may be written as a>b<c?.
The program 1>a<2 a+a will result in a containing the values [1 4] (from bottom to top) and not [1 3]. Likewise for the - operator.
The Control Structure
There is only one control structure in Kipple: the loop.
Syntax: (StackIndentifier code )
As long as the specified stack is not empty, the code within the matching parentheses will be repeated. Loops may contain other loops. For example, (a a>b) will move all the values of stack a onto stack b, though the order will be reversed. A functionally identical, but more elegant way to do this is (a>b).
Examples
100>@ (@>o)

This will output 100
33>o 100>o 108>o 114>o 111>o 87>o 32>o 111>o 108>o 108>o 101>o 72>o

This will print "Hello World!". When the o stack is being output, it starts to pop characters from top of the stack to bottom.
#prime.k by Jannis Harder
u<200
#change 200

k<2>m
u-2
(u-1 u>t u>z u<t
  (k>e e+0 e>r)
  (e>k)
  m+1
  m>t
  m>z
  m<t
  t<0>z? t?
  1>g
  (r>b
    m+0 m>a
    b+0 b>w
    (a-1
      b+0 b>j
      j?
      1>s
      (j<0>s j?)
      s?
      (s<0 w+0 w>b s?)
      a>t
      a>z
      t>a
      b-1
      b>t
      b>z
      t>b
      z<0>t? z?
    a?)
    b?
    1>p
    (b<0 b? 0>p)
    p?
    (p 0>r? 0>p? 0>g)
  )
  g?
  (g m+0 m>k 0>g?)
u?)
(k>@
  10>o
  (@>o)
)

This is a prime number generator, but I'm not sure how it works.
Rules

You must write a program/function that interprets Kipple. This program/function may get a Kipple program via a source file, or get it via STDIN directly from the user. If STDIN is not available, it must get it from keyboard input, and continue getting input until a specific unprintable character is entered. For example, if your interpreter is written in x86 machine code, it would get the Kipple program character by character from keyboard, and continue to do so until esc (or any other key other that does not emit a printable character) is pressed.
If there is an error, e.g. a syntax error or stack overflow, it must acknowledge it in some way, for example by returning 10 instead of 0 or error messages produced by the interpreter/compiler, BUT NOT PRINTING ERROR MESSAGES.
Any other regular rules for code golf apply for this challenge.
Your code will be tested with some of the examples in Kipple's samples archive

This is a code-golf . Shortest code in bytes will win.
Good Luck!

Note that there is an optional operator in Kipple, ", but it is not a part of the specification and just an extra feature in official interpreter. I haven't mentioned it here so it does not need to be supported in your submission.
If you have any doubt about any part of specification , you can examine it with official interpreter written in Java . This will download a zip file containing compiled program and source code . It's licensed under the GPL.

Do we have to use 32-bit signed integers or can we go with the host implementation's natural integer type? (The most important cases are probably unsigned 32-bit integers, signed or unsigned 8-bit integers and arbitrary-precision integers.)

well , it was what i found on esotric wiki . yes , because your interpreter may be incompatible with other kipple programs which their mechanism are based on this feature

Can you be more specific about the behavior in the case of errors? So we can return an incorrect answer or emit an error, but we can't print the error?

@Alex A. Yes , because it can be considered as program's output , and you can make a kipple program which can have same output as error message . Also it is "cheaper" (uses less characters) not to have a function/statement that prints an error message .

Because of how the @ stack works, what happens if you run @+5?

@kevin lau - not kenny , it will just push topmost value +5 , like when applyed to other stacks

What whitespace can occur in a source program? How can I ask for input i if I take the source program from stdin?

@orlp the things that come to mind are: 1. Take a file name as the first line of stdin, or 2. Pass the file name as command line. Or, for maximum craziness, pass the entire program as a string into command line? I wonder if that's possible

The spec says there are 29 stacks, but the only stacks I see are the 26 a-z stacks and @. Where are the last two stacks?

@KevinLau-notKenny I believe that's a typo, although my answer uses 28 stacks, I use the same data structure that I use for stacks for my call stack :)

@orlp "i" stack is like the input stack in fish . when the interpreter is excuted and the code is entered , before running the code , it will ask useres to give intial value to "i" stack . user can fill the stack , as much as needed (from bottom to top), and when excuted , program can get that user entered information from "i" stack , and extra values are left on stack.  for example , if program needs 2 inputs and user enters "3 2 1" , "i" stack will be [3 2 1] from bottom to top . then 1 then 2 will be used as input and 3 will be left on stack , though programmer can clear or use "i" stack .

@KevinLau-notKenny , that was an error , there are 27 stacks - i've edited the main post .

@orlp as said in specification "The interpreter will ignore anything that isn't next to an operator, so the following program would work:  a+2 this will be ignored c<i " so there can be any type of white space in program .

Not clearly specified 1: the output from o stack is a string made of ascii char codes. It's only in the examples

Not clearly specified 2: input number format. Is -12 a valid language token for the signed integer -12?

Not clearly specified 3: stack underflow ? Popping an empty stack always returns 0

Checking again at https://esolangs.org/wiki/Kipple, this is the right answer: "An operand can either be a stack identifier or a nonnegative integer (0 to 2147483647)."

Just to be double-triple sure, when you say the program shouldn't print error messages, you mean that errors can be thrown, but should not appear on screen, yes?

Also, is the ? always the last operator in a group of commands, or is a?<b possible?

What's the defined behavior for a<b>c? Do they both use the top value of b, or does a take the top value and c take the next one?

@KevinLau-notKenny I've deleted my last comment , sorry , a<b>c pops topmost value from b and pushes to both c and a .

All right, thanks for the tip. You should update your spec to clarify it for other people, just in case. Also, what of my other question, regarding if a?<b is possible?

Not clearly specified 4: a<b>c pops topmost value from b and pushes to both c and a Missing this is a basic flaw (both here and in the original Kipple spec). Basically it's impossible to write a working interpreter based on this specifications - you have to check how the reference java interpreter works. That's why I downvote

@GLASSIC Nope; it pushes the top value of b to a, and the second-to-top value of b to c. It's just like a<bb>c, or, more clearly, a<b c<b. It's just that Operands may be shared by two operators. No, the operand doesn't get a value before being evaluated, thus it will act differently on a<b>c the first and second times.

C, 709 702 bytes
The byte score is with newlines (that can be removed) removed, but for ease of reading I post it here with newlines:
#define R return
#define C ;break;case
c[999]={};*P=c;*S[28];M[99999]={};t;*T;
u(s,v){S[s]+=28;*S[s]=v;
if(s>26){for(t=v/10;t;t/=10)S[s]+=28;T=S[s];do{*T=48+v%10;T-=28;}while(v/=10);}}
o(s){t=S[s]-M>27;S[s]-=28*t;R S[s][28]*t;}
I(s){R s<65?27:s-97;}
O(int*p){if(!isdigit(*p))R o(I(*p));
for(;isdigit(p[-1]);--p);for(t=0;isdigit(*p);t*=10,t+=*p++-48);R t;}

main(i,a){for(i=0;i<28;++i)S[i]=M+i;
for(;~(*++P=getchar()););P=c+1;
for(;;){i=I(P[-1]);switch(*P++){
case 35:for(;*P++!=10;)
C'<':u(i,O(P))
C'>':u(I(*P),O(P-2))
C'+':u(i,*S[i]+O(P))
C'-':u(i,*S[i]-O(P))
C'?':if(!*S[i])S[i]=M+i
C'(':for(i=1,T=P;i;++T)i+=(*T==40)-(*T==41);if(S[I(*P)]-M<28)P=T;else u(26,P-c)
C')':P=c+o(26)-1
C-1:for(;i=o(14);)putchar(i); R 0;}}}

Compile with gcc -w golf.c (-w silences warnings for your sanity).
Supports everything except the i input, as the asker has not responded yet to my inquiry on how to do it if you take the code from stdin. It does not report syntax errors.

i've answered your question about "i" stack in the main post's comments .

btw how it reads kipple programs ? via command arguments? how should i use it ?

@GLASSIC It expects the program on stdin.

Until when ? How to start excution ?

@GLASSIC Just pass the program on stdin. E.g. ./a.out < prime.k.

Do you have an online link where we can test? It's not working for me on repl.it

@KevinLau-notKenny https://ideone.com/FOy9kp

626 bytes

Ruby, 718 bytes (currently noncompeting)
i'm very tired
File is loaded as a command line argument, and input is sent through STDIN. Alternatively, pipe the file into STDIN if you don't need input in your i register.
Because of some confusion regarding the spec, the current version is not handling a<b>c properly, and therefore is noncompeting until it is fixed.
a<b>c is fixed now. However, it still returns the wrong result when running the primes function, so it still remains as a noncompeting answer.
(f=$<.read.gsub(/#.*?\n|\s[^+-<>#()?]*\s/m,' ').tr ?@,?`
t=Array.new(27){[]}
t[9]=STDIN.read.bytes
k=s=2**32-1
r=->c{c=c[0];c[0]==?(?(s[c[1..-2]]while[]!=t[c[1].ord-96]):(c=c.sub(/^(.)<(\D)>(.)/){$1+"<#{t[$2.ord-96].pop||0}>"+$3}.sub(/(\d+|.)(\W)(\d+|.)?/){_,x,y,z=*$~
a=x.ord-96
b=(z||?|).ord-96
q=->i,j=z{j[/\d/]?j.to_i: (t[i]||[]).pop||0}
l=t[a]
y<?-?(x==z ?l[-1]*=2:l<<(l.pop||0)+q[b]
l[-1]-=k while l[-1]>k/2):y<?.?(x==z ?l[-1]=0:l<<(l.pop||0)-q[b]
l[-1]+=k while l[-1]<-k/2-1):y<?>?t[a]+=a<1?q[b].to_s.bytes: [q[b]]:y<???
(t[b]+=b<1?q[a,x].to_s.bytes: [q[a,x]]): l[-1]==0?t[a]=[]:0
z||x}while c !~/^(\d+|.)$/)}
s=->c{(z=c.scan(/(\((\g<1>|\s)+\)|[^()\s]+)/m)).map &r}
s[f]
$><<t[15].reverse.map(&:chr)*'')rescue 0

+1 anyway. Did you try the fibonacci program?

@edc65 Fibbonacci sequence program prints the wrong thing as well: 0 1 1 2 4 8 16... I wonder if it's a spec error

No, the Fibonacci program is crap, for instance the line a+0 is nonsense

i guess the problem about prime numbers is that it doesn't handle nested control structures , but i don't know much about ruby , i doubt my guess's correct.

This program should handle nested sets of parens properly because of the recursive regex match on /(\((\g<1>|\s)+\)|[^()\s]+)/m that it uses to split on tokens and groups of tokens. (Test it on regex101). It's probably an error in the rest of my parsing, but I don't know where.

@GLASSIC sudden bounty? May I ask why? Assuming you were the one to award it

Bounty ??? No . i have not done any thing other than editing the post - Ah ...  i hate touch screen devices ...

Someone just gave me a bounty though, don't know why