text:
2D Inequalities
Objective
Given a grid of numbers, fill in the inequalities.
Assumptions
The number of columns and rows in the grid are equal.
The maximum size of the grid is 12x12.
The grid only consists of integers 0-9.
The output may contain a trailing newline.
The input is exactly as written below, including spaces and newlines.
Example Input
4 2 3 1

6 2 3 1

6 9 2 1

0 2 1 6

Example Output
4>2<3>1
^ " " "
6>2<3>1
" ^ v "
6<9>2>1
v v v ^
0<2>1<6

Example Input (2)
1 2 3 4 5

5 4 3 2 1

0 0 0 3 2

3 2 0 0 0

2 1 3 1 5

Example Output (2)
1<2<3<4<5
^ ^ " v v
5>4>3>2>1
v v v ^ ^
0=0=0<3>2
^ ^ " v v
3>2>0=0=0
v v ^ ^ ^
2>1<3>1<5

Example Input (3)
8

Example Output (3)
8

Example Input (4)
0 0 0 0 0 0 0 0 0 0 0 0

0 1 1 1 1 1 1 1 1 1 1 0

0 1 2 3 4 5 6 7 8 9 1 0

0 1 3 9 8 7 6 5 4 8 1 0

0 1 4 8 9 8 7 6 5 7 1 0

0 1 5 7 8 9 9 7 6 6 1 0

0 1 6 6 7 9 9 8 7 5 1 0

0 1 7 5 6 7 8 9 8 4 1 0

0 1 8 4 5 6 7 8 9 3 1 0

0 1 9 8 7 6 5 4 3 2 1 0

0 1 1 1 1 1 1 1 1 1 1 0

0 0 0 0 0 0 0 0 0 0 0 0

Example Output (4)
0=0=0=0=0=0=0=0=0=0=0=0
" ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ "
0<1=1=1=1=1=1=1=1=1=1>0
" " ^ ^ ^ ^ ^ ^ ^ ^ " "
0<1<2<3<4<5<6<7<8<9>1>0
" " ^ ^ ^ ^ " v v v " "
0<1<3<9>8>7>6>5>4<8>1>0
" " ^ v ^ ^ ^ ^ ^ v " "
0<1<4<8<9>8>7>6>5<7>1>0
" " ^ v v ^ ^ ^ ^ v " "
0<1<5<7<8<9=9>7>6=6>1>0
" " ^ v v " " ^ ^ v " "
0<1<6=6<7<9=9>8>7>5>1>0
" " ^ v v v v ^ ^ v " "
0<1<7>5<6<7<8<9>8>4>1>0
" " ^ v v v v v ^ v " "
0<1<8>4<5<6<7<8<9>3>1>0
" " ^ ^ ^ " v v v v " "
0<1<9>8>7>6>5>4>3>2>1>0
" " v v v v v v v v " "
0<1=1=1=1=1=1=1=1=1=1>0
" v v v v v v v v v v "
0=0=0=0=0=0=0=0=0=0=0=0

In Ex. 2 rows and columns aren't equal.

Will there be 2-digit numbers?

@Vɪʜᴀɴ The grid only consists of integers 0-9.

@geokaval Oh, you're right. I'll edit that now.

@Dennis ohh, I thought that said characters 0-9

@Dennis Yes, it should be 6=6. I've fixed the error.

I assume there are no trailing spaces on the numbered lines of the input. Are there any spaces on the blank lines? If I press the edit button I find that there are 23 spaces on each blank line for example 4, zero for all other examples. But the rendered page removes them all, at least when I copy it into a text editor to check..

@steveverrill There are no spaces on the blank lines.

Pyth, 46 bytes
juCms.iJ-d\ m.x@H._-FsMk\ .:J2Gc2"=><\"v^"%2.z

Try it online: Demonstration

CJam, 52 bytes
qN%::~_z_2{{_1>.-W<:g}%\z}*@@..{'=+}.{N@"\"v^"f=S*N}

Try it online in the CJam interpreter.
Thanks to @CroCo for pointing out a bug in revision 3.
Thanks to @Pyrrha for pointing out a bug in revision 6.
How it works
qN%        e# Read all input and split it at runs of linefeeds.
::~        e# Evaluate each character separately.
           e# This turns non-empty lines into arrays of integers.
_z_        e# Copy, transpose rows and columns, and copy again.
2{         e# Do the following twice:
  {        e#   For each row:
    _1>    e#     Copy the row and remove the copy's first element.
    .-     e#     Perform vectorized subtraction.
    W<     e#     Remove the last element.
           e#     This pushes the array of increments of the row.
    :g     e#     Replace each difference with its sign (-1, 0 or 1).
  }%       e#
  \        e#   Swap the two topmost arrays on the stack.
  z        e#   Transpose rows and columns of the topmost array.
}*         e#
           e# The topmost result has been transposed before and after computing
           e# the increments of its rows. It holds the increments of it columns.
           e# The result below it has been transposed twice (therefore not at
           e# all) before computing the increments of its rows.
@@         e# Rotate the number array and the row increment array on top.
..{        e# For each number and the corresponding increment, push both; then:
  '=+      e#   Add the increment to the character '='.
}          e#
.{         e# For each row of the column increment array and corresponding row
           e# of the last result, push both rows; then:
  N@       e#   Push a linefeed and rotate the column increments on top.
  "\"v^"f= e#   For each, select the appropriate comparison character.
  S*       e#   Join those characters, separated by spaces.
  N        e#   Push another linefeed.
 }         e#

Python 2, 207 197 bytes
f=lambda a:''.join(['=><'[cmp(a[i-1],a[i+1])]if c==' 'else'\n'+' '.join('"v^'[cmp(a[j-a.index('\n')],a[j+2])]for j in range(i,i+a.index('\n'),2))if a[i:i+2]=='\n\n'else c for i,c in enumerate(a)])

This one creates a function f which takes the grid of numbers as a string and returns the corresponding string with filled inequalities.
The function iterates over each character in the string. If the character is a space, it is replaced with the inequality for the numbers on either side. If the character and the next character are newlines, the whole line is replaced with the inequalities for all the numbers above and below.
Here is the output of the function for each of the examples in the question, except the really long one:
>>> print f("""\
... 4 2 3 1
...
... 6 2 3 1
...
... 6 9 2 1""")
4>2<3>1
^ " " "
6>2<3>1
" ^ v "
6<9>2>1
>>> print f("""\
... 1 2 3 4 5
...
... 5 4 3 2 1
...
... 0 0 0 3 2
...
... 3 2 0 0 0
...
... 2 1 3 1 5""")
1<2<3<4<5
^ ^ " v v
5>4>3>2>1
v v v ^ ^
0=0=0<3>2
^ ^ " v v
3>2>0=0=0
v v ^ ^ ^
2>1<3>1<5
>>> print f("8")
8

That's clever, putting the characters in a string then subscripting it. I'll have to use that sometime.

C, 552 408 bytes
This is a mess, but it does work with the test cases (for the solo 8, the input has to be followed by a newline to work properly)
#define P putchar
main(n,z)char**z;{char*t=*++z;n=0;while(*(*z)++!=10)if(**z!=32)n++;char a[n][n];int r=-1,c=0;n--;do*t>32?c?:r++,a[c][r]=*t:*t==10?c=0:c++;while(*++t);r=c=0;do{int j=a[c][r],s=61,k=a[c+1][r];P(j);if (c==n){if(r==n)break;c=0;r++;P(10);for(int t=a[c][r-1],b=a[c][r];c<n+1;t=a[c][r-1],b=a[c][r])s=t>b?118:tk?62:j<k?60:s;P(s);c++;}while(1);}

Here's the expanded version; I'd love to here ways on how I could golf this more effectively. I know that there is much to be improved on here.
#define P putchar
main(n,z)char**z; {
    char *t = *++z;
    n = 0;
    while (*(*z)++!=10)
        if (**z!=32)
            n++;
    char a[n][n];
    int c,r=c=0;
    r = -1,n--;
    do
        *t>32?c?:r++, a[c][r] = *t:*t==10?c=0:c++; //32 is ASCII for space
    while (*++t);
    r=c=0;
    do {
        int j = a[c][r],s=61,k = a[c+1][r];P(j);
        if (c==n)
        {
            if (r==n)break;
            c=0;r++;P(10);
            for (int t=a[c][r-1],b=a[c][r];c<n+1; t = a[c][r-1],b = a[c][r])
                s=t>b?118:tk?62:j<k?60:s;

        P(s);
        c++;
    } while (1);
}

Needs more ternary operator.  E.g.: in your inner-most loop: s=t>b?'v':t(s=s.split`
`).map((r,i)=>r?(w=r).replace(/ /g,(c,j)=>x('<=>',r[j-1]-r[j+1])):w.replace(/\d/g,(c,j)=>x('^"v', c-s[i+1][j]))  ,x=(y,v)=>y[-~(v>0)-(v<0)]).join`
`

// more readeable
u=s=>(
  x=(y,v)=>y[-~(v>0)-(v<0)],
  s=s.split`\n`,
  s.map((r,i)=>r
    ?(w=r).replace(/ /g,(c,j)=>x('<=>',r[j-1]-r[j+1]))
    :w.replace(/\d/g,(c,j)=>x('^"v', c-s[i+1][j]))
  ).join`\n`
)

//TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
 '4 2 3 1\n\n6 2 3 1\n\n6 9 2 1\n\n0 2 1 6'
,'1 2 3 4 5\n\n5 4 3 2 1\n\n0 0 0 3 2\n\n3 2 0 0 0\n\n2 1 3 1 5'
,'8',
,'0 0 0 0 0 0 0 0 0 0 0 0\n\n0 1 1 1 1 1 1 1 1 1 1 0\n\n0 1 2 3 4 5 6 7 8 9 1 0\n\n0 1 3 9 8 7 6 5 4 8 1 0\n\n0 1 4 8 9 8 7 6 5 7 1 0\n\n0 1 5 7 8 9 9 7 6 6 1 0\n\n0 1 6 6 7 9 9 8 7 5 1 0\n\n0 1 7 5 6 7 8 9 8 4 1 0\n\n0 1 8 4 5 6 7 8 9 3 1 0\n\n0 1 9 8 7 6 5 4 3 2 1 0\n\n0 1 1 1 1 1 1 1 1 1 1 0\n\n0 0 0 0 0 0 0 0 0 0 0 0'
].forEach(t=>console.log(t+'\n\n'+f(t)+'\n\n'))

Haskell, 201 bytes
import Data.List
t=transpose
g=mapM_ putStrLn.t.map(h 1).t.map(h 0).lines
h n s@(a:_:b:r)|'/'<a&&a<':'=a:(o n a b):h n(b:r)
 |0<1=s
h n r=r
f=fromEnum
o n a b=l!!n!!(1+signum(f a-f b))
l=["<=>","^\"v"]

g expects a string.


text:
Remove all occurrences of the first letter of a string from the entire string
Given an input string only containing the characters A-Z, a-z, and spaces, remove all occurrences of the uppercase and lowercase versions of the first character of the string (if the first character is A remove all As and as, if the first character is (space) remove all spaces), and print the output.
Example cases:

Testing Testing One Two Three -> esing esing One wo hree
Programming Puzzles and Code Golf -> rogramming uzzles and Code Golf
How much wood would a woodchuck chuck if a woodchuck could chuck wood -> ow muc wood would a woodcuck cuck if a woodcuck could cuck wood
{space}hello world -> helloworld
welcome to WATER WORLD -> elcome to ATER ORLD

This is code-golf, shortest code in bytes wins!
Notes:

Input will always be 2 or more valid characters.
Output will never be an empty string.

Do we need to handle the case where output is the empty string? What if input is the empty string?

@ThomasKwa you may assume output will alway be 2 or more characters

@ThomasKwa and output will never be empty

Pyth, 7 bytes
-zrBhz2

Try it online: Demonstration or Test Suite
Nice. The new bifurcate operator (only 8 days old) helps here to save one char. I think this is the first code, that uses this feature.
Explanation
-zrBhz2   implicit: z = input string
    hz    take the first character of z
  rB  2   B generates a list, containing the original char and the
          result of r.2 applied to the char, which swaps the case
-z        remove these two chars from z and print the result

Neat, didn't know about that. +1

Perl, 13 bytes
#!perl -p
/./,s/$&//gi

Counting the shebang as one, input is taken from stdin.

Sample Usage
$ echo Testing Testing One Two Three | perl remove-first.pl
esing esing One wo hree

$ echo \ Testing Testing One Two Three | perl primo-remove.pl
TestingTestingOneTwoThree

Nice. I was thinking about how Perl would probably do badly because of the need to write substr but of course you came up with a much better way!

Why do you count hashbang as one byte?

@Zereges the shebang line is not necessary, if the script is invoked as perl -p script.pl. Command line options are customarily counted as one byte each, at least on this site.

@primo I see, thanks.

brainfuck, 219 bytes
+[+[>+<+<]>],[<+<+>>-]>[<<[->]>[<]>-]++++[<++++++++>-]<<[[-]----[>-<----]>-<<[>+>+<<-]<,[[>+>>>+>>+>+<<<<<<<-]>>[<<+>>-]<<[>->+<<-]>[[-]+<]>[>]<<[>>+<<-]>>[<-<+>>-]<[[-]+>]>>[<]<<<<[>>>+<<<-]>>>-[>>.<<-]>>>[[-]<]<<<<<,]

(Requires tape that either allows the pointer to go to the negatives or loops to the end if it tries. Also requires , to return 0 at EOF. In my experience, most interpreters meet these requirements by default.)
This actually turned out to be pretty easy! I wouldn't be surprised if it's golfable (I have some idea of where there might be wasted bytes but I'm not super sure if it'll pan out). Still, getting it work wasn't really a challenge at all.
This code treats everything with an ASCII value below 97 as an uppercase character. If the first character is space, it'll try to remove any occurrences of a "lowercase space" (i.e. chr(32+32), i.e. @) from the string. This is okay, because only letters and spaces will ever be present.
With comments:
to make comments shorter: everywhere it says "fc" means "first character"

#################################### GET FC ####################################

+[+[>+<+<]>]        shortest way to get 96
                    any number above 89 and less than 97 would work because this
                    is only for figuring out if the first character is capital

,[<+<+>>-]          create two copies of the first character

### current tape: | fc | fc | 000 | 096 | ###
###      pointer:              ^          ###

########################### FIND MAX(FC MINUS 96; 0) ###########################

>[                  96 times:

  <<                  go to the cell with the first char

  [->]                if not 0: sub one and move right

  ### current tape: | fc | char being worked on | 000 | 096 | ###
  ###      pointer:                           ^ OR ^          ###

  >[<]>               collapse the wavefunction; sync the branches

-]

### current tape: | fc | fc is lowercase ? nonzero : zero | 000 | 000 | ###
###      pointer:                                                  ^    ###

############################# GET BOTH CASES OF FC #############################

++++[<++++++++>-]   get 32 (add to uppercase character to get lowercase)

<<[                 if the character is already lowercase:

  [-]                 clear the lowercase flag

  ----[>-<----]>-     sub 64 from the cell with 32

<]

<[>+>+<<-]          add fc to the 32 or minus 32 to get both cases

### current tape: | 000 | fc | other case of fc | ###
###      pointer:    ^                            ###

###################### LOOP THROUGH REMAINING CHARACTERS #######################

<,[                 for each character:

  [>+>>>+>>+>+<<<<<<<-]
                      make four copies
                      (only 3 are strictly needed; 4th will resync a branch)

  >>                  go to the first case of fc

  [<<+>>-]<<[>->+<<-] subtract one case of fc from one copy

  >[[-]+<]            if the result is nonzero set it to 1

  >[>]<<              go to the other case of fc (and resync branches)

  [>>+<<-]>>[<-<+>>-] subtract other case of fc from other copy

  <[[-]+>]            if the result is nonzero set it to 1

  >>[<]               resync branches using extra copy

  <<<<[>>>+<<<-]>>>   add results together

  -                   subtract 1

   if the character exactly matched either case: 1 plus 0 minus 1 = 0
  if the character exactly matched neither case: 1 plus 1 minus 1 = 1
    if the character exactly matched both cases: impossible

  [                   if the result is 1:

    >>.<<               output character

    -                   set cell to 0 to kill loop

  ]

  >>>[[-]<]           clean up remaining copies

  <<<<<,              get next character; or end loop if done

]

Please don't golf this down too much. c: I worked so hard...

CJam, 8 bytes
q(_32^+-

Try it online in the CJam interpreter.
How it works
q        e# Read all input from STDIN.
 (       e# Shift out the first character.
  _32^   e# Push a copy and XOR its character code with 32.
         e#   For a letter, this swaps its case.
         e#   For a space, this pushes a null byte.
      +  e# Concatenate these two characters.
       - e# Remove all occurrences of both from the input string.

I originally created this challenge to learn CJam, and I never knew about the XOR thing!

I personally find it surprising that any language - with exception to perhaps sed - could beat perl in this challenge.

@primo - You haven't noticed that CJam and/or Pyth pretty much win 99% of these?  Perl did pretty good though, considering it's the only one not specifically designed as a golfing language.

Pyth and CJam's operator overloading is ridiculous. minus(string,string) performing per-character removal is not a core operation in any other language I've encountered.

@Sparr APL has the same built-in. (It's called ~ though.)

Pyth, 8 bytes
-zr*2hz3

Try it online
Uses Pyth's version of python's str.title to convert a string of the first letter twice into the form "<Upper><Lower>". Then it removes each element from the input that is in that string. Spaces work fine because they are unaffected by str.title.

JavaScript (ES6), 38 36 bytes
This does not depend on the flags parameter which is Mozilla-specific.
f=x=>x.replace(RegExp(x[0],'gi'),'')

CoffeeScript, 39 37 bytes
For once it's shorter in JS than CoffeeScript!
f=(x)->x.replace RegExp(x[0],'gi'),''

At least in the browsers I tried, the new is optional, so RegExp(x[0],'gi') is shorter.

MATLAB, 28 bytes
@(S)S(lower(S)~=lower(S(1)))

PHP, 41 bytes
Takes one command-line argument. Short open tags need to be enabled for PHP < 5.4.
<?=str_ireplace($argv[1][0],'',$argv[1]);

You can shorten it by declaring a variable containing $argv[1] : <?=str_ireplace(($a=$argv[1])[0],'',$a);

Minkolang 0.9, 23 33 bytes
No way this will win but eh, it's fun!
" Z"od0c`1c*-$I[odd0c`1c*-2c=?O].

Try it here.
Explanation
" Z"                                 Makes it easier to uppercase
    od                               Take first character of input and duplicate
      0c`1c*-                        Uppercase if needed
             $I[               ]     Loop over the input
                odd                  Take character from input and duplicate twice
                   0c`1c*-           If it's lowercase, uppercase it.
                          0c=?       Check to see if it's equal to first character
                              O      If not, output as character
                                .    Exit

(This might fail in some edge cases, like if the first character is a symbol.)

Perl, 27 bytes
This is a complete program, although it's just based on 2 regexes that could probably copied into a Retina program to save bytes on I/O.
$_=<>;m/(.)/;s/$1//gi;print

Edit: Looks like this has already been beaten with somebody using the -p option.  Oh, and using $& instead of $1.

Even if the entire shebang is counted (i.e. a "complete" program), #!perl -p is still two bytes shorter than $_=<>;print.

@primo I've never used any of the options in my golfs.  I just googled what the -p option does. There's not really any edits that I can make to my answer without just making it identical to yours.

TECO, 15 14 bytes
Editing text?  When in doubt, use the Text Editor and COrrecter!
After much trial-and-error (mostly error), I think this is the shortest generic TECO program that will do the job.
0,1XA<S^EQA$-D>

Or, in human-readable form
0,1XA    ! Read the first character of the string into the text area of !
         ! Q-buffer A.                                                  !
<        ! Loop,                                                        !
S^EQA$   ! searching for the text in Q-buffer A in either lowercase or  !
         ! uppercase,                                                   !
-D       ! and deleting it,                                             !
>        ! until the search fails.                                      !

$ represents the escape key, and ^E represents the sequence CTRL+E.  Depending on the flavor of TECO you're using, it may recognize these ASCII substitutions, or it may not.
According to the manual, some dialects of TECO accept this 13-byte version (using a find-and-delete command instead of separate "find" and "delete" commands) instead:
0,1XA<FD^EQA$>

Pip, 8 bytes
aR-Xa@0x

Takes the string as a command-line argument (will need to be quoted if it contains spaces). Explanation:
          a gets cmdline arg; x is "" (implicit)
    a@0   First character of a
   X      Convert to regex
  -       Make regex case-insensitive
aR     x  Replace all matches of that regex in a with empty string
          Autoprint (implicit)

This solution has the extra bonus of working on strings containing any printable ASCII characters. (The X operator backslash-escapes anything that's not alphanumeric.)

Python, 66 char
a=raw_input()
print a.replace(a[0],'').replace(a[0].swapcase(),'')

Julia, 34 bytes
s->replace(s,Regex(s[1:1],"i"),"")

This creates an unnamed function that accepts a string and returns a string. It constructs a case-insensitive regular expression from the first character in the input and replaces all occurrences of that with an empty string.

Python 2, 43
lambda s:s.translate(None,(s[0]*2).title())

This is somewhat based on my Pyth answer, but it's also related to some comments from ThomasKwa and xnor from here. Mostly posting because I wanted this answer to exist.

Python, 61 bytes (way too many)
lambda x:"".join(map(lambda y:(y.lower()!=x[0].lower())*y,x))

I imagine there is a better way to go about doing this, but I can't seem to find it. Any ideas on removing the "".join(...)?

@ThomasKwa perhaps you should submit that as your own answer; it seems too different from mine to count as my submission.

@ThomasKwa Shorter to do x[0]+x[0].swapcase().

@ThomasKwa Or, stealing from FryAmTheEggman's Pyth solution, (x[0]*2).title().

@xnor yeah, I found that when I read theirs a few hours ago.

lambda x:x.replace(x[0].upper(),'').replace(x[0].lower(),'') - 60 bytes

Mathematica, 47 bytes
StringDelete[#,#~StringTake~1,IgnoreCase->1>0]&

R, 43 bytes
cat(gsub(substr(s,1,1),"",s<-readline(),T))

This is a full program that reads a line from STDIN and writes the modified result to STDOUT.
Ungolfed:
# Read a line from STDIN
s <- readline()

# Replace all occurrences of the first character with an empty
# string, ignoring case
r <- gsub(substr(s, 1, 1), "", s, ignore.case = TRUE)

# Write the result to STDOUT
cat(r)

Ruby, 25 bytes
Anonymous function:
->s{s.gsub /#{s[0]}/i,""}

Full prgram, 29 bytes:
puts gets.gsub /#{$_[0]}/i,""

Ouroboros, 61 bytes
Hey, it's shorter than C++! Ha.
i..91<\64>*32*+m1(
)L!34*.(;Si.1+!24*(Y.@@.@=@.@32-=\@+2*.(yo

In Ouroboros, each line of the program represents a snake with its tail in its mouth. Control flow is accomplished by eating or regurgitating sections of tail, with a shared stack to synchronize between snakes.
Snake 1
i. reads a character from input and duplicates it. .91<\64>*32* pushes 32 if the character was an uppercase letter, 0 otherwise. +ing that to the character converts uppercase letters to lowercase while leaving lowercase letters and spaces unchanged. All this has been taking place on snake 1's stack, so we now push the value to the shared stack (m) for snake 2 to process. Finally, 1( eats the last character of snake 1's tail. Since that's where the instruction pointer is, the snake dies.
Snake 2
) has no effect the first time through. L!34* pushes 34 if the shared stack is empty, 0 otherwise. We then . dup and ( eat that many characters.

If the shared stack was empty, this puts the end of the snake right after the ( we just executed. Therefore, control loops back to the beginning of the line, where ) regurgitates the characters we just ate (having previously pushed an extra copy of 34) and repeat the stack-length test.
If the shared stack was not empty, no characters are eaten, ';' drops the extra 0, and execution continues:

Si switches to the shared stack and inputs another character. .1+!24* pushes 24 if that character was -1 / EOF, 0 otherwise. On EOF, ( swallows 24 characters--including the IP--and the snake dies. Otherwise, execution continues.
Y yanks a copy of the top of the shared stack (the character we just read) to snake 2's own stack for future use. Then .@@.@=@.@32-=\@+2* calculates whether the new character is equal to the first character or to the first character minus 32, pushing 2 if so and 0 if not. We . duplicate and ( eat that many characters:

If the characters matched, we go straight back to the head of the snake, where ( regurgitates the 2 characters we just ate and execution proceeds with the next character.
If not, we yank the character back from snake 2's stack, output it, and then loop.

See it in action

// Define Stack class
function Stack() {
  this.stack = [];
  this.length = 0;
}
Stack.prototype.push = function(item) {
  this.stack.push(item);
  this.length++;
}
Stack.prototype.pop = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack.pop();
    this.length--;
  }
  return result;
}
Stack.prototype.top = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack[this.length - 1];
  }
  return result;
}
Stack.prototype.toString = function() {
    return "" + this.stack;
  }

// Define Snake class
function Snake(code) {
  this.code = code;
  this.length = this.code.length;
  this.ip = 0;
  this.ownStack = new Stack();
  this.currStack = this.ownStack;
  this.alive = true;
  this.wait = 0;
  this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
    if (!this.alive) {
      return null;
    }
    if (this.wait > 0) {
      this.wait--;
      return null;
    }
    var instruction = this.code.charAt(this.ip);
    var output = null;
    if (this.partialString !== null) {
      // We're in the middle of a double-quoted string
      if (instruction == '"') {
        // Close the string and push its character codes in reverse order
        for (var i = this.partialString.length - 1; i >= 0; i--) {
          this.currStack.push(this.partialString.charCodeAt(i));
        }
        this.partialString = null;
      } else {
        this.partialString += instruction;
      }
    } else if (instruction == '"') {
      this.partialString = "";
    } else if ("0" <= instruction && instruction <= "9") {
      if (this.partialNumber !== null) {
        this.partialNumber = this.partialNumber + instruction; // NB: concatenation!
      } else {
        this.partialNumber = instruction;
      }
      next = this.code.charAt((this.ip + 1) % this.length);
      if (next < "0" || "9" < next) {
        // Next instruction is non-numeric, so end number and push it
        this.currStack.push(+this.partialNumber);
        this.partialNumber = null;
      }
    } else if ("a" <= instruction && instruction <= "f") {
      // a-f push numbers 10 through 15
      var value = instruction.charCodeAt(0) - 87;
      this.currStack.push(value);
    } else if (instruction == "$") {
      // Toggle the current stack
      if (this.currStack === this.ownStack) {
        this.currStack = this.program.sharedStack;
      } else {
        this.currStack = this.ownStack;
      }
    } else if (instruction == "s") {
      this.currStack = this.ownStack;
    } else if (instruction == "S") {
      this.currStack = this.program.sharedStack;
    } else if (instruction == "l") {
      this.currStack.push(this.ownStack.length);
    } else if (instruction == "L") {
      this.currStack.push(this.program.sharedStack.length);
    } else if (instruction == ".") {
      var item = this.currStack.pop();
      this.currStack.push(item);
      this.currStack.push(item);
    } else if (instruction == "m") {
      var item = this.ownStack.pop();
      this.program.sharedStack.push(item);
    } else if (instruction == "M") {
      var item = this.program.sharedStack.pop();
      this.ownStack.push(item);
    } else if (instruction == "y") {
      var item = this.ownStack.top();
      this.program.sharedStack.push(item);
    } else if (instruction == "Y") {
      var item = this.program.sharedStack.top();
      this.ownStack.push(item);
    } else if (instruction == "\\") {
      var top = this.currStack.pop();
      var next = this.currStack.pop()
      this.currStack.push(top);
      this.currStack.push(next);
    } else if (instruction == "@") {
      var c = this.currStack.pop();
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(c);
      this.currStack.push(a);
      this.currStack.push(b);
    } else if (instruction == ";") {
      this.currStack.pop();
    } else if (instruction == "+") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a + b);
    } else if (instruction == "-") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a - b);
    } else if (instruction == "*") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a * b);
    } else if (instruction == "/") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a / b);
    } else if (instruction == "%") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a % b);
    } else if (instruction == "_") {
      this.currStack.push(-this.currStack.pop());
    } else if (instruction == "I") {
      var value = this.currStack.pop();
      if (value < 0) {
        this.currStack.push(Math.ceil(value));
      } else {
        this.currStack.push(Math.floor(value));
      }
    } else if (instruction == ">") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a > b));
    } else if (instruction == "<") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a < b));
    } else if (instruction == "=") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a == b));
    } else if (instruction == "!") {
      this.currStack.push(+!this.currStack.pop());
    } else if (instruction == "?") {
      this.currStack.push(Math.random());
    } else if (instruction == "n") {
      output = "" + this.currStack.pop();
    } else if (instruction == "o") {
      output = String.fromCharCode(this.currStack.pop());
    } else if (instruction == "r") {
      var input = this.program.io.getNumber();
      this.currStack.push(input);
    } else if (instruction == "i") {
      var input = this.program.io.getChar();
      this.currStack.push(input);
    } else if (instruction == "(") {
      this.length -= Math.floor(this.currStack.pop());
      this.length = Math.max(this.length, 0);
    } else if (instruction == ")") {
      this.length += Math.floor(this.currStack.pop());
      this.length = Math.min(this.length, this.code.length);
    } else if (instruction == "w") {
      this.wait = this.currStack.pop();
    }
    // Any instruction not covered by the above cases is ignored
    if (this.ip >= this.length) {
      // We've swallowed the IP, so this snake dies
      this.alive = false;
      this.program.snakesLiving--;
    } else {
      // Increment IP and loop if appropriate
      this.ip = (this.ip + 1) % this.length;
    }
    return output;
  }

// Define Program class
function Program(source, speed, io) {
  this.sharedStack = new Stack();
  this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
    var snake = new Snake(snakeCode);
    snake.program = this;
    snake.sharedStack = this.sharedStack;
    return snake;
  }.bind(this));
  this.snakesLiving = this.snakes.length;
  this.io = io;
  this.speed = speed || 10;
  this.halting = false;
}
Program.prototype.run = function() {
  if (this.snakesLiving) {
    this.step();
    this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
  }
}
Program.prototype.step = function() {
  for (var s = 0; s < this.snakes.length; s++) {
    var output = this.snakes[s].step();
    if (output) {
      this.io.print(output);
    }
  }
}
Program.prototype.halt = function() {
  window.clearTimeout(this.timeout);
}
var ioFunctions = {
  print: function(item) {
    var stdout = document.getElementById('stdout');
    stdout.value += "" + item;
  },
  getChar: function() {
    if (inputData) {
      var inputChar = inputData[0];
      inputData = inputData.slice(1);
      return inputChar.charCodeAt(0);
    } else {
      return -1;
    }
  },
  getNumber: function() {
    while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
      inputData = inputData.slice(1);
    }
    if (inputData) {
      var inputNumber = inputData.match(/\d+/)[0];
      inputData = inputData.slice(inputNumber.length);
      return +inputNumber;
    } else {
      return -1;
    }
  }
};
var program = null;
var inputData = null;

function resetProgram() {
  var stdout = document.getElementById('stdout');
  stdout.value = null;
  if (program !== null) {
    program.halt();
  }
  program = null;
  inputData = null;
}

function initProgram() {
  var source = document.getElementById('source'),
    stepsPerSecond = document.getElementById('steps-per-second'),
    stdin = document.getElementById('stdin');
  program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
  inputData = stdin.value;
}

function runBtnClick() {
  if (program === null || program.snakesLiving == 0) {
    resetProgram();
    initProgram();
  } else {
    program.halt();
    var stepsPerSecond = document.getElementById('steps-per-second');
    program.speed = +stepsPerSecond.innerHTML;
  }
  program.run();
}

function stepBtnClick() {
  if (program === null) {
    initProgram();
  } else {
    program.halt();
  }
  program.step();
}
.container {
  width: 100%;
}
.so-box {
  font-family: 'Helvetica Neue', Arial, sans-serif;
  font-weight: bold;
  color: #fff;
  text-align: center;
  padding: .3em .7em;
  font-size: 1em;
  line-height: 1.1;
  border: 1px solid #c47b07;
  -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
  background: #f88912;
  box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
  display: inline-block;
  border-radius: 6px;
  float: left;
  margin-right: 25px;
  cursor: pointer;
}
.option {
  padding: 10px 20px;
  margin-right: 25px;
  float: left;
}
h1 {
  text-align: center;
  font-family: Georgia, 'Times New Roman', serif;
}
a {
  text-decoration: none;
}
input,
textarea {
  box-sizing: border-box;
}
textarea {
  display: block;
  white-space: pre;
  overflow: auto;
  height: 40px;
  width: 100%;
  max-width: 100%;
  min-height: 25px;
}
span[contenteditable] {
  padding: 2px 6px;
  background: #cc7801;
  color: #fff;
}
#stdout-container,
#stdin-container {
  height: auto;
  padding: 6px 0;
}
#reset {
  float: right;
}
#source-display-wrapper {
  display: none;
  width: 100%;
  height: 100%;
  overflow: auto;
  border: 1px solid black;
  box-sizing: border-box;
}
#source-display {
  font-family: monospace;
  white-space: pre;
  padding: 2px;
}
.activeToken {
  background: #f88912;
}
.clearfix:after {
  content: ".";
  display: block;
  height: 0;
  clear: both;
  visibility: hidden;
}
.clearfix {
  display: inline-block;
}
* html .clearfix {
  height: 1%;
}
.clearfix {
  display: block;
}
<!--
Designed and written 2015 by D. Loscutoff
Much of the HTML and CSS was taken from this Befunge interpreter by Ingo Bürk: http://codegolf.stackexchange.com/a/40331/16766
-->
<div class="container">
<textarea id="source" placeholder="Enter your program here" wrap="off">i..96<\64>*32*+m1(
)L!34*.(;Si.1+!24*(Y.@@.@=@.@32-=\@+2*.(yo</textarea>
<div id="source-display-wrapper"><div id="source-display"></div></div></div><div id="stdin-container" class="container">
<textarea id="stdin" placeholder="Input" wrap="off">Testing Testing One Two Three</textarea>
</div><div id="controls-container" class="container clearfix"><input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" /><input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" /><input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" /><input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" /></div><div id="stdout-container" class="container"><textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea></div><div id="options-container" class="container"><div class="option so-box">Steps per Second:
<span id="steps-per-second" contenteditable>1000</span></div></div>

C, 60 bytes
n,c,d;main(){for(;read(0,&c-n,1);n=2)d-c&31&&n&&putchar(d);}
Edit: Fixed a bug which caused a null byte to be printed at the beginning

does it even compile ?

Yes. It compiles on my machine (with warnings) and works. You can also test it on this page: http://golf.shinh.org/check.rb

yes it does; +1

Vim, 30 Keystrokes
Sorry to unearth, but i don't see any Vim answer D:
If<Right>xh@x.<Esc>"xy07|@x2|~0"xd7|@x0x

Explanation:

If<Right>xh@x.<Esc>
Write a (recursive) macro around the first character
Moving left (h) is needed to stay at the left of the next unread character
Adding any character (.) at the end is needed in case the second must be removed
"xy0 Copy the macro in the register x
7| Move to the 7th char
@x Run the macro from x
2|~ Switch the case of the first char (actually at the 2nd position)
0"xd7| Cut the macro in the register x
@x Run the macro from x
0x Remove the place-holder .

:D I always upvote vim!

Zsh*, 21 bytes
<<<${1//(#i)${1:0:1}}

Try it online!
(*) Using setopt extendedglob

TeaScript, 16 bytes
TeaScript is JavaScript with shortened property names.
x.g(x[0],'','i')

Try it online

TeaScript 3 came out and now this is 10 bytes.
xg(x░,u,'i

which compiles to:
xg(x[0],u,'i

which compiles to:
x.g(x[0],u,'i')

where u is preset to ""

TeaScript does not work for me in firefox. Test aht should be es ah, right? Second (friendly) TeaScript does work.

@Zereges weird. I'll use the other version while I see why that's not working

C++, 100 99 98 bytes
#include<ios>
int main(){for(int c,f=getchar();~(c=getchar());)tolower(c)-tolower(f)&&putchar(c);}

Just one more byte to get under 100. getchar() returns -1 when it reads end of stream, so that's why the ~ is in for cycle. (~-1 == 0)
Ungolfed
#include <ios>
int main()
{
    for (int c, f = getchar(); ~(c = getchar()); )
        tolower(c) - tolower(f) && putchar(c);
}

Can't you use &&putchar(c) instead of ?putchar(c):0?

@Neil Thank you, now I am under 100 bytes!

@ThomasKwa Of course I can, thanks.

Can you do f-c&31 as in the C answer?

Haskell, 52 bytes
import Data.Char
t=toUpper
r(h:s)=filter((t h/=).t)s

List comprehension saves 1 byte: r(h:s)=[c|c<-s,t c/=t h].

C, 65 61 bytes
main(c,v)char**v;{for(c=**++v;*++*v;**v-c&31&&putchar(**v));}

Compiles with warnings. Reads string from argv[1]. Online example

You can shorten main(int c,char**v) to main(c,v)char**v;, and (**v-c)%32 to **v-c&31.

TI-BASIC, 164 bytes
For TI-83+/84+ series graphing calculators.
Input Str1
1→X
"sub(Str1,X,1→u
"ABCDEFGHIJKLMNOPQRSTUVWXYZ zyxwvutsrqponmlkjihgfedcba
u+sub(Ans,54-inString(Ans,u),1
For(X,2,length(Str1
If 2<inString(Ans+Str1,u
Ans+u
End
sub(Ans,3,length(Ans)-2

TI-BASIC is clearly the wrong tool for the job.

It doesn't have a command to remove characters, so we need to loop through the string and append characters if they don't match what is to be removed.
It doesn't support empty strings, so we need to start the string with the two letters to be removed, build the output onto the end, and chop the first two characters off.
It doesn't have case-change commands, so we need to hardcode the entire alphabet...

twice...
Did I mention lowercase letters take two bytes each in the TI-BASIC encoding?

I'm not 100% sure, but I spent over six hours on this, and it seems to be the shortest possible solution.
To test this with non-uppercase inputs (or to type it into your calculator), make a different program with the contents AsmPrgmFDCB24DEC9, and run it using Asm([whatever you named it] to enable lowercase typing mode.

Lua, 93 78 Bytes
a=io.read()m=a:sub(1,1):upper()print(({a:gsub("["..m..m:lower().."]","")})[1])

Common Lisp, 77
(princ(let((x(read-char)))(remove-if(lambda(y)(char-equal x y))(read-line))))

Curse these long function names (and parentheses (but I still love them anyway (:3))).

AppleScript, 209 201 bytes
My only consolation is that I beat Brainfuck.
set a to(display dialog""default answer"")'s text returned
set n to a's characters's number
set o to""
repeat n
if not a's character n=a's character 1 then set o to a's character n&o
set n to n-1
end
o
How this works is that I take input through a, get the length of a and mark it as n, and set an output variable o. For every character that I find that does not contain the first character of a (a's character 1), I concatenate it to o. The final line prints o.
Note: This automatically supports all Unicode. c:

My only consolation is that I beat Brainfuck. looks like i'd better get golfing ;)

Retina, 16 bytes
i`(.)(?<=^\1.*)

Save the code with a trailing linefeed and run it with the -s flag.
How it works: the trailing linefeed makes this a replacement stage, such that any matches of the given regex are replaced with an empty string. The i turns on case-insensitive mode which also makes backreferences case-insensitive. Finally, the regex simply matches and captures a single characters and then checks whether the first character in the string is the same (up to case) using a backreference.

Gema, 19 characters
\A?=@set{c;?}
\C$c=

Sample run:
bash-4.3$ gema '\A?=@set{c;?};\C$c=' <<< 'Testing Testing One Two Three'
esing esing One wo hree

bash-4.3$ gema '\A?=@set{c;?};\C$c=' <<< ' Testing Testing One Two Three'
TestingTestingOneTwoThree

Bash, 35 characters
c=${1::1}
echo "${1//[${c^}${c,}]}"

Sample run:
bash-4.3$ bash rm-1st-char.sh 'Testing Testing One Two Three'
esing esing One wo hree

bash-4.3$ bash rm-1st-char.sh ' Testing Testing One Two Three'
TestingTestingOneTwoThree

Vim, 11 keystrokes
x:s/<C-r>-//gi

With a trailing newline
Although there already is a Vim answer, this one uses a different approach.
This deletes the first first character, which automatically gets stored in register -. Then we do a search and replace, replacing the deleted character (<C-r>-) with nothing (ie deleting it). The gi flags are used (global and case-insensitive).

Brainfuck, 72 bytes
,>>,
[
  <<[>+>->+<<<-]
  >>
  [
    >+>>+<
    [>-]
    >[+++[<++++++++>-]>]
    <<-<<-
  ]
  >>[<.>[-]]
  <,
]

Try it online.
Checks whether the differences between the first character and subsequent characters are divisible by 32.

Jelly, 7 6 bytes
żŒsḢ⁸ḟ

Try it online!
1 byte saved thanks to Erik The Outgolfer
How it works
żŒsḢ⁸ḟ - Main link. Argument: s (string) e.g. "ABCabc"

 Œs    - Swap the case                        "abcABC"
ż      - zip with the input                   ["Aa", "Bb", "Cc"]
   Ḣ   - take the first element               "Aa"
     ḟ - Filter those characters from...
    ⁸  -   the input                          "BCbc"

Original
ḟḢ;Œs$$ - Main link. Argument: s (string) e.g. "ABCabc"

 Ḣ      - Generate the first character of s    "A"
   Œs   - Generate the swapped case of ^       "a"
  ;     - Concatenate                          "Aa"
ḟ    $$ - Filter ^ from the input              "BCbc"

Alternatively for 6 bytes: żŒsḢ⁸ḟ

@EriktheOutgolfer oh, nice. Thanks!

05AB1E, 5 bytes
ćDš«м

Try it online!
Newer version than what Adnan used.

Vyxal, 5 bytes
h:N"F

Try it Online!
Look ma, no Unicode!
h     # First character of (implicit) input
   "  # Paired with
 :    # A copy of itself
  N   # With case swapped
    F # Remove those characters from (implicit) input

Arturo, 31 bytes
$[s][l:lower s print l--@->l\0]

Try it
$[s][            ; a function taking an argument s
    l: lower s   ; assign lowercased s to l
    print        ; print
    l --         ; from l, remove...
    @->l\0       ; the first element of l (as a list)
]                ; end function

Japt, 3 bytes
kUÎ

Try it (includes all test cases)
kUÎ     :Implicit input of string U
k       :Case insensitively remove
 UÎ     :First character of U

A 1-byte built-in for “case insensitively remove”? That's wild…

That's a slightly simplified explanation of what it's doing in this solution, @xigoi. To provide a bit more detail: the k method takes a string as an argument and removes all occurrences of the characters in that string from the string it's applied to. By default it does so case insensitively but it can also take a second, optional argument to make it case sensitive.

Raku, 17 bytes
{S:i:g/$(m/./)//}

Try it online!

S:i:g/...// returns a copy of the input string in which the regex between the first two slashes has been Substituted, case-insensitively and globally, with the content between the last two slashes, which is nothing--that is, the matches are deleted.
m/./ matches the first character of the input string, returning a Match object.  Note that unlike many regular expression dialects, a dot matches any character, even a newline.
$(m/./) interpolates that first character into the regex as a plain string pattern.

Nibbles, 6.5 bytes
+%~@%`)/_$`)$

Attempt This Online!
Interestingly, this only works because none of the ASCII codes of the allowed characters are divisible by each other. That's because I'm using % (modulo) to test if two characters are different.

Thunno 2, 6 bytes
hẊoxPo

Attempt This Online!
Thunno 2 J, 8 bytes
ḢçRL'|jḄ

Attempt This Online!
More fun answer using regex.
Explanation
hẊoxPo  # Implicit input
h       # First character of the input
 Ẋ      # Store in x without popping
  o     # Remove this from input
   x    # Push x again
    P   # Swap its case
     o  # Remove this from the string
        # Implicit output

ḢçRL'|jḄ  '# Implicit input
Ḣ          # First character of the input
 ç         # Apply and collect results:
  R        #  Uppercase the character
   L       #  Lowercase the character
    '|j   '# Join the pair by "|"
       Ḅ   # Split the string on this regex
           # Implicit output, joined

Hassium, 57 Bytes
func main(){s=input().toLower()print(s.replace(s[0],""))}

Run online and see expanded here

This will change all uppercase letters into lowercase. E.g, the input HEY should be EY but not ey.

Julia, 40 bytes
t->t[find([(l=lowercase(t))...].!=l[1])]

l=lowercase(t) makes l store the string t reduced to lowercase. [l...] then converts the string into a character array. .!=l[1] compares that array element-wise with the first value of it, returning true if they don't match. find then converts the resulting boolean array into an array containing the true indices, and t[] then returns the desired string.
It feels like Julia should be able to do better than this, but so far I can't see it. It's a lot easier if you don't have to catch both upper- and lower-case instances of the letter.

Ceylon, 93 84
String r(String i)=>String{if(exists f=i[0])for(c in i.rest)if(c.offset(f)%32!=0)c};
This defines a function r which takes and returns a String, solving the task.
Formatted:
String r(String i) =>
        String {
    if (exists f = i[0])
        for (c in i.rest)
            if (c.offset(f) % 32 != 0)
                c };

The function creates and returns a string from an Iterable comprehension, composed of several if- and for-clauses.
The first if makes sure that the string is non-empty (if its empty, the iterable will be empty, thus the returned string too), and at the same time declares the f variable to be used later. (i[0] could have also been written i.first, but this way is shorter.)
While the question says we can be sure the input has always length > 1, the compiler doesn't know this. (A different way of saying this would be to use an assert statement, but this would be even longer.)
The next for clause iterates over the remainder of the string (i.e. the string without its first character). Each item is named c.
The second if does the case-check. It turns out that in ASCII, the upper- and lower case letters have distance 32 from each other, so c.offset(f) % 32 != 0 is a slightly shorter way of writing c.uppercased != f.uppercased. (This would also filter other character, e.g. in the input strings Testing Testing One Two Three4, Programming Puzzles and 0Code0 Golf00, ((((How much wood would (a( woodchuck chuck (if a woodchuck could chuck (wood, @ hello` `world, 7welcome to WATER WORLD7 would also result in the example outputs in the question. But as the input is restricted to [A-Z a-z]+, we don't care.)
The last clause it simply the expression c – which will be included if the if clause's condition is true, and omitted otherwise.
The resulting iterable is passed to the String's class constructor, which iterates over it and creates the string.
As a bonus, here is a version which works for all of unicode:
String r(String i) =>
        String {
    if (exists f = i[0])
        for (c in i.rest)
            if (c.uppercased != f.uppercased)
                c };

After space-removal this is 93 bytes:
String r(String i)=>String{if(exists f=i[0])for(c in i.rest)if(c.uppercased!=f.uppercased)c};
It converts (beside the example phrases) also Übel wütet der Gürtelwürger to bel wtet der Grtelwrger.

Simplex v.0.6, 10 bytes
bC&0/gi//g
b          ~~ takes input as a string
 C  /  //  ~~ match as SiRegex
  &0       ~~ replace the first cell
     gi    ~~ globally, ignoring case,
           ~~ with the empty string
         g ~~ output the result

No regrets about adding a new type of Regular Expression. (SiRegex FTW!)

C(136)
#define t(x)(x+32*(x>>5==2))
char*h(char*a,int b,int*c){char*v=a[b+1]?h(a,b+1,c):0;return(b<=*c)?v:&(a[b]=a[b-(*c+=t(*a)==t(a[b]))]);}

Execution
void main(){

    char a[]="abac";int v=0;
    printf("%s",h((char*)a,0,&v));
    return;
}

Output
bc

the function is recursive which is called from the initial parameters: h(string,0,0) and returns the beginning of the resulting string.

Powershell, 62 60 44 bytes
$args-replace"$($args.substring(0,1))",""

Powershell of all things.
Edit: removed whitespace to save 2 bytes
Edit2: removed type accelerators to save 16 more bytes

Hi and welcome to Programming Puzzles and Code Golf Stack Exchange (PPCG.SE for short)! Just FYI, the standard format of an answer starts with #[Language], [N] bytes as the first line where N is the length (in UTF-8 bytes) of your program. Otherwise, I, along with the rest of the PPCG.SE community wishes you good luck in your golfing adventure!

Thanks for the welcome and the advice.  You barely beat the downvotes.  Gotta love SE.
I've been struggling to use regex instead of .net string handling, thinking it would save me some bytes, however, I can't seem to find a way to capture the first character AND search for it using $string.replace("...","")

Can be further shortened to $argz-replace($argz[0]) (23 bytes).

, 6 chars / 13 bytes (non-competitive)
ïĥ/⏖î⍀

Try it here (Firefox only).
As does happen a lot, I beat everyone in char count but not in byte count :P
Explanation
ï is input, ĥ is replace, /...⍀ transpiles to /.../gi in JS, and ⏖î directly replaces the result of ï[0] in the compiled code.

05AB1E, 7 Bytes
¬DŠ-sš-

Explanation:
¬        # Take the first character of the input
 D       # Duplicate top of the stack
  Š      # Pop a,b,c and push c,a,b
   -     # Remove all occurencies of the first letter
    s    # Swap the two top elements
     š   # Swapcase the top of the stack
      -  # Remove all occurencies of the swapcased letter
         # Implicit: print top of the stack

Uses ISO 8859-1 encoding

¬Dš‚K is 5, AFAICT.

Common Lisp, 47 bytes
(lambda(s)(remove(aref s 0)s :test'char-equal))

J, 17 bytes
#~1-(={.)@tolower

Usage
   f =: #~1-(={.)@tolower
   f 'Testing Testing One Two Three'
esing esing One wo hree
   f 'Programming Puzzles and Code Golf'
rogramming uzzles and Code Golf
   f ' hello world'
helloworld

Rebol, 25 bytes
print replace/all s s/1{}

Alternative function at 28 bytes:
func[s][replace/all s s/1{}]

C#, 101 bytes
void m(string s){Console.Write(s.Replace(char.ToUpper(s[0]),'\0').Replace(char.ToLower(s[0]),'\0'));}

Sadly C# falls short on this one due to not having a case insensitivity option in Replace and not having an empty char literal
I tried using regex but it's more bytes (someone might manage shorter with it though)

Java, 96 bytes.
Java is an unlikely winner, it's pretty verbose even in a golfed form. Here |32 is to force lower-case comparison regardless of the actual value, doesn't affect space.
void m(String s){char[]c=s.toCharArray();for(char a:c)System.out.print((a|32)!=(c[0]|32)?a:"");}

At a slightly higher level of String class it would be more explicit (121 bytes):
void m(String s){String f=s.substring(0,1).toLowerCase();System.out.println(s.replaceAll("["+f+f.toUpperCase()+"]",""));}

Convex, 5 bytes, noncompeting
(_±+-

Try it online!

Uiua SBCS, 6 bytes
▽≠⊢.⌵.

Try it!

Python 3, 55 bytes
lambda s:''.join(c*(c.lower()!=s[0].lower())for c in s)

Try it online!
Outgolfed, but I like the elegance :)

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:
*Language name* is awesome!
Write a program in any language that reads input from stdin and outputs a slightly modified output to stdout. The program should borrow some characters from the input and output as large of a prefix as possible of *language-name* is awesome! followed by a newline and then what's left of the input.

The input does not contain any uppercase characters.
If the first character of the language name is not present in the string, only the newline character should be borrowed.
If there's no newline character in the input, output the input unmodified.
It does not matter which of the available characters you borrow.

I'm using \nas the newline character (0x0a) to save space when writing. The real program should only care about the real newline character, not the \n string.
Example: python.
input: abcdefghijklmnopqrstuvwxyz\n0123456789
output: python\nabcdefgijklmqrsuvwxz0123456789
Since the input does not have any spaces, we cannot continue even though we have enough characters for the next word: is.
Example: C.
input: i don't see anything!
output: i don't see anything!
C was not found in the string, so no modification was possible. Also, no newline character is present.
Example: C++.
input: i don't\nsee anything!
output: \ni don'tsee anything!
C was not found in the string, so no modification was possible.
Example: Obj-C.
input: objectively, clojure is amazing.\nq.e.d.
output: obj\nectively, clojure is amazing.q.e.d.
The input contains enough characters to write obj but the - is missing.
Byte count of your source code minus the byte count of your languages' name, utf-8 encoded (if possible), is your score; lowest wins!

Let's hope someone finds a language with a lot of repetition in the name for a negative score :)

Could you include i don't\nsee anything! as a test case?

Good test case! Added.

How should cases with repeated characters (either in the name or in the input) be handled? Does the order of the left-over characters in the output matter?

Woops! Fixed it. Also clarified that any character may be borrowed, not just the first.

In the last example, there is a '-' in output. Where does it come from?

And, in the last example, where does the 'a' come from, as it's still present 2 times in 'amazing'? Maybe you should check the examples again?

Needless to say, I did not write a solution to this problem myself. I did the examples by hand. Corrected the last one now.

Could you please add a test-case that uses is awesome, and one that contains the necessary letters but not a newline?

Pyth, 37 bytes
.-Jjb.zpef!.-TJ+,kb+Rb._"pyth is awesome!

The source code is 41 bytes long. Try it online.
How it works
  Jjb.z                                      Save all user input in J.
                      ._"pyth is awesome!    Compute all prefixes that string:
                                               ["p", "py", ... ]
                   +Rb                       Append a linefeed to each prefix.
               +,kb                          Concatenate ["", "\n"] with the result.
         f                                   Filter the resulting array; for each T:
           .-TJ                                Perform bagwise difference between T
                                               and J (respects multiplicities).
         !                                     Take the logical NOT.
                                             Keep T if ! returned True, i.e., if J
                                             contains all of T's characters.
        e                                    Retrieve the last, longest match.
       p                                     Print it.
.-J                                          Remove its characters from J.
                                             (implicit) Print the result.

Python, 186 - 6 = 180
import sys
a=sys.stdin.read()
s="python is awesome!"
r=''
if'\n'not in a:print a;exit()
a=a.replace('\n','',1)
for c in s:
 if c in a:a,r=a.replace(c,'',1),r+c
 else:break
print r+'\n'+a

Try it online

It should only borrow characters, so if multiple newlines are present in the input, you only borrow one of them. All the characters should still be there in the output, but not necessarily in the same order.

Python, 146 bytes
import sys
r=sys.stdin.read();y='\npython is awesome!';a=''
for i in y:
    if i in r:a+=i
    else:break
print a[1:]+'\n'+''.join(b for b in r if not b in a)

@Dennis fixed it -_-

Still one newline too many if the input doesn't contain newlines (second example).

Ceylon, 235 - 6 = 229
void a(){variable value i="";variable value r="\nceylon is awesome!";while(exists l=process.readLine()){i=i+"\n"+l;}i=i.rest;for(j->c in r.indexed){if(c in i){i=i.replaceLast(c.string,"");}else{r=r[0:j];break;}}print(r.rest+r[0:1]+i);}
Here is a formatted and commented version:
void a() {
    // our target string, with the \n shuffled to the start.
    variable value r = "\nceylon is awesome!";

    // read the whole input line by line
    // (there doesn't seem a way to do this shorter :-/)
    variable value i = "";
    while (exists l = process.readLine()) {
        i = i + "\n" + l;
    }
    // remove first \n:
    i = i.rest;
    for (j->c in r.indexed) {
        if (c in i) {
            // remove some occurence of c
            i = i.replaceLast(c.string, "");
        } else {
            // stop the loop, and take the part of `r` processed so far.
            r = r[0:j];
            break;
        }
    }
    // reshuffle first \n in r to its end.
    // This will result in the empty string if r is empty, i.e. no \n was found.
    print(r.rest + r[0:1] + i);
}

It uses replaceLast instead of replaceFirst because it is shorter.
Some example inputs and outputs in the same format as in the question:

abcdefghijklmnopqrstuvwxyz\n0123456789 → ceylon\nabdfghijkmpqrstuvwxz0123456789
i don't see anything! → i don't see anything!
i don't\nsee anything! → \ni don't see anything!
objectively, closure is amazing.\nq.e.d. → ceylon is a\nobjectivel, sureiamzng.\q..d.

Jelly, 23 - 5 = 18 bytes
“£İþ¬Ɠ¥ỊḊ»
¢œ-ƤṆ€×¢Ṅœ-@

Try it online!
This uses the Jelly encoding. Insisting on UTf-8 encoding has the same byte count, it just means I need to make a hexdump of the bytes.
How it works
“£İþ¬Ɠ¥ỊḊ» - Helper link. Compressed string "jelly is awesome"

¢œ-ƤṆ€×¢Ṅœ-@ - Main link. Takes S on the left
¢            - Yield "jelly is awesome"
   Ƥ         - Over each prefix of "jelly is awesome":
 œ-          -   For each character in the prefix, remove it exactly once
                  if it is in the input
                  This results in an empty list if the entire prefix is in
                  the input else a non-empty list
     €       - Over each:
    Ṇ        -   Logical NOT. This yields 1 for an empty list, else 0
       ¢     - Yield "jelly is awesome"
      ×      - For each character, keep it if the left argument is 1
        Ṅ    - Print the kept characters with a trailing newline
         œ-@ - Remove exactly one occurrence of each of the kept characters
               from the input and output that

JavaScript (ES6) 90 (100-10)
As a function returning the requested ouput. It's difficult to implement with I/O, as the usual substitute for STDIN is prompt(), that does not accept a newline inside the input string.
As a function with real output (using alert) the byte count is 107

f=s=>alert(([...`
javascript is awesome`].every(c=>(z=s.replace(c,''))!=s&&(s=z,q?o+=c:q=c),q=o=''),o+q+z))

Test running the snippet below in an EcmaScript 6 compliant browser (implementing spread operator and arrow function - I use FireFox)

f=s=>([...`
javascript is awesome`].every(c=>(z=s.replace(c,''))!=s&&(s=z,q?o+=c:q=c),q=o=''),o+q+z)

function test()
{
  O.innerHTML=f(I.value)
}

test()
#I {width: 80%}
<textarea id=I>
objectively, clojure is amazing.
q.e.d.</textarea><button onclick="test()">-></button>

JavaScript (ES7), 101 107 - 10 = 97
It was shorter before, and even worked on all four test cases, but apparently I missed a rule, so....
x=>(i=r=q='',[for(c of`
javascript is awesome`)(y=x.replace(c,''),i||y==x?i=1:(c<' '?q=c:r+=c,x=y))],r+q+x)

Works properly in Firefox 42. This originally started out at 119 bytes, but a trick from @edc65's answer helped to shorten it a great deal. I think there's still some room for improvement. As always, suggestions welcome!

Fails when missing newline in input. Test obj -> job, should be not modified (rule 3)

@edc65 Ah, yes, the test cases only cover 75% of the edge cases. I could even remove is awesome and it would still work properly on all four of them. I'll fix this ASAP.

Perl, 72 - 4 = 68 bytes
Includes 2 switches.
perl -0pe 'for$c("\nperl is awesome!"=~/./gs){s/$c//?$p.=$c:last}s/^/$p\n/;s/\n//'

Explanation: For every character in the string "\nperl is awesome", remove the corresponding character from the input string ($_) till we find a character not present in $_. The matching characters are stored in $p which is prefixed to $_ which is then printed.
The -0 switch reads in the complete input rather than line-by-line and the -p switch makes reading input and print the output implicit.

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


text:
Have you learned your fib-abc?
I don't like numbers, but I do like the Fibonacci sequence. I'm sure we could work something out.
Please read one integer n from STDIN and output the nth Fibonacci number in base 26 (abcdefghijklmnopqrstuvwxyz instead of 0123456789) to STDOUT.
The first Fibonacci number is 0. The second one is 1. The nth fibonacci number is the sum of the n-2nd and n-1st Fibonacci numbers.
First 32 fib-abc numbers:
fib(0) = a
fib(1) = b
fib(2) = b
fib(3) = c
fib(4) = d
fib(5) = f
fib(6) = i
fib(7) = n
fib(8) = v
fib(9) = bi
fib(10) = cd
fib(11) = dl
fib(12) = fo
fib(13) = iz
fib(14) = on
fib(15) = xm
fib(16) = blz
fib(17) = cjl
fib(18) = dvk
fib(19) = gev
fib(20) = kaf
fib(21) = qfa
fib(22) = baff
fib(23) = bqkf
fib(24) = cqpk
fib(25) = egzp
fib(26) = gxoz
fib(27) = leoo
fib(28) = scdn
fib(29) = bdgsb
fib(30) = bvivo
fib(31) = cypnp

This is code golf, so shortest code in bytes wins!

@l0b0 you'd still call it base 26 because the choice of characters to represent the digits is entirely arbitrary and the common hexadecimal digits are just a convention.

It's still base26. What characters you use is arbitrary, and here we use a-z (in alphabetical order).

Right, it's a different base-26 notation from the conventional, but it's still a base-26 notation.

Why use them nasty numbers for the input?

Name suggestion: Fibona-b-c

Technically it's fib-abB, and not abC, (or abBc is fine), but other than that, +1.

CJam, 18 bytes
UXri{_@+}*;26b'af+

Try it online in the CJam interpreter.
How it works
UX    e# Push 0 and 1.
ri{   e# Read an integer and execute the loop that many times.
  _   e#   Push a copy the topmost integer.
  @   e#   Rotate the bottom-most integer on top of the stack.
  +   e#   Pop the two topmost integers and push their sum.
}*    e#
;     e# Discard the topmost integer from the stack.
26b   e# Convert the remaining integer to base 26.
'af+  e# Add the character 'a' to each base-26 digit.

TeaScript, 34 bytes  37   51   54
TeaScript is JavaScript for golfing. It also brings ES2015 features to the average browser.
F(x)b(26)l(#C(lc()+(l<'a'?49:10)))

Try it online
Explanation
          // x is the input
F(x)      // Fibonacci from input
.b(26)    // To Base-26 string but with 0-9, a-p
          // instead of a-z, to fix this...
.l(#      // Loops through each char
   C(          // Charcode from...
       l.c()+  // Charcode from char
       (l<'a'? // If number
           49  // Add 49 to char code
          :10  // Else add 10
       )
   )
)

*This answer is non-competing

Nice golf-y version of JS! I designed my own version about a month ago, but haven't yet started an interpreter. Without a Fibonacci built-in or implicit input, this same program would be 48 bytes long. However, if I were to create a built-in and add implicit input, it'd be 34. Perhaps I should start work on an interpreter. ;)

Ooh, that's a lot better. One of the tricks in my language that may apply here is making all variables uppercase (including Math, Date, etc.) and all methods lowercase, which removes the need for periods. This is just a suggestion; it may not be the best idea for this language, but I'll let you decide. (Love the name, BTW.)

@ETHproductions interesting idea. I'll see if I can implement it for some cases, but as of now, I'm implementing most features through a simple find-replace method, making it difficult to implement the more complex semantics.

Mathematica, 67 61 bytes
Print[""<>Alphabet[][[Fibonacci@Input[]~IntegerDigits~26+1]]]

Calculates f(1000000) in about 51 milliseconds.

Ah, didn't see that there was a Mathematica answer already! Mine used IntegerString to format the digits: IntegerString[Fibonacci@#~IntegerDigits~26+10,36]<>""&

I deleted it; using Input[] and Print[] for a fair comparison, my solution would be 66 bytes long. But Alphabet[] is a 10.1 feature, so I thought I'll leave it as a comment.

@user5254 I first used FromLetterNumber before seeing that it internally used Alphabet with Part and used that, except with a list of indices.

Simplex v.0.6, 35 bytes
Sometimes I sigh and think, "Is this even worth submitting? It doesn't win, so why bother?" In response, I think, "Heck. It was fun. Besides, this is really fancied-up brainf*** anyhow. Not too shabby."
5_*Ij1~SRpRi@T[Uj&ERp]pSR5_Vj26@pWo
5_                                  ~~ sqrt(5)
  *                                 ~~ copy to next byte, move right
   I                                ~~ increment [sqrt(5),sqrt(5)+1]
    j1                              ~~ insert a new cell and set it to one
                                    ~~ [sqrt(5),1,sqrt(5)+1]
      ~                             ~~ switch the previous with the current byte
                                    ~~ [1,sqrt(5),sqrt(5)+1]
       S                            ~~ perform subtraction [1-sqrt(5),0,sqrt(5)+1]
        Rp                          ~~ remove next cell [1-sqrt(5),sqrt(5)+1]
          Ri@                       ~~ take numeric input (n) into register
             T[      ]              ~~ applies the following to every cell
               U                    ~~ halves the current cell
                j&                  ~~ dumps and restores the value to the register
                  ERp               ~~ raises cell to the nth power, remove cell made
                      p             ~~ remove last cell
                       S            ~~ subtract the two values
                        R5_         ~~ goes right and sets sqrt(5)
                           V        ~~ divides the prev. two cells
                            j       ~~ inserts new cell
                             26@    ~~ puts 26 into the register
                                p   ~~ removes cell
                                 Wo ~~ converts the current to base 26 and outputs as number

Oh, and, as an aside, the W command interprets base 26 as the lowercase alphabet, base 52 as the upper and lowercase alphabet, and base 64 is essentially JavaScripts btoa function.

Pyth, 17 bytes
s@LGjhu,eGsGQU2lG

Try it online.

Awesome, I can verify that this works

Minkolang 0.9, 40 bytes
10n[0c+r]$x'26'r(d0c%1G0c:d$)xrx("a"+O).

Try it here.
Explanation
10n[0c+r]                                   Calculates f(n) where n is taken from input
         $x'26'r                            Dumps the addend I don't need and pushes a 26
                (d0c%1G0c:d$)               Base-encodes f(n) in base 26
                             xrx            Dumps the 0, reverses, dumps the 26
                                ("a"+O).    Outputs the letters

Really nice! Works great for huge inputs!

Python 2.7, 82 bytes
a=0
b=1
s=''
exec"a,b=b,a+b;"*input()
while a:s=chr(a%26+97)+s;a/=26
print s or'a'

Whispers v3, 111 bytes
> Input
> fₙ
>> ≺1
>> 2ᶠ1
>> 4ⁿ3
> 26
>> 5⊥6
> 97
>> 8+R
>> Each 9 7
>> 'R
>> Each 11 10
>> Output 12

Try it on repl.it!
Needs to be run as python3 whispers\ v3.py fibabc.wisp < input.txt 2> /dev/null with input given on the first line of input.txt.
I think the first and last lines can be removed as per the consensus here, but I'm not sure.
8 bytes shorter than hardcoding the alphabet: Try it on repl.it!

You can say that line 12 is your main function and avoid the need for line 13, but you can't simply get rid of the Input line. You would need to restructure your program to use R/L instead of Input to make it into a function taking input via arguments (but I think doing that would make the code longer). I will try to clarify this in the meta post

Haskell, 114 chars.
It is unexpectedly long. Any help welcome. Previously found a bug for fib(0)
f=scanl(+)0$1:f
k 0=[]
k x=k(x`div`26)++[toEnum$97+x`mod`26]
l 0=0
l x=k x
main=interact$l.(f!!).read.head.lines

f is infinite list of fibonacci. toEnum is same with chr, except that former doesn't need to import Data.Char.

Jelly, 8 bytes
ÆḞṃØaṙ1¤

Try it online!
How it works
ÆḞṃØaṙ1¤ - Main link. Takes an integer N on the left
ÆḞ       - Take the Nth Fibonacci number
       ¤ - Group the previous links into a nilad:
   Øa    -   "abc...xyz"
     ṙ1  -   Rotate once; "bcd...yza"
  ṃ      - Base decompress; Convert to base 26 then index into the string

JavaScript (V8), 94 bytes
x=>(f=n=>n>1?f(n-1)+f(n-2):1)(x)[S="toString"](26).replace(/./g,l=>(parseInt(l,26)+10)[S](36))

Try it online!
Uses recursion to find factorial, and some toString, replace, and parseInt magic to convert to letters.

Zsh, 68 bytes
<<<A;{for ((a=1;b+=a;a+=b))<<<$[[##26]a]<<<$[[##26]b]}|tr 0-9A-P A-Z

Try it online!
Pure fibonacci code stolen from here.

05AB1E, 6 bytes
If a list of characters is fine as output, the J can be removed.
ÅfAÅвJ

Try it online!
Åf      # get the nth Fibonacci number
  A     # push the lowercase alphabet
   Åв   # convert the Fibonacci number to this custom base
     J  # join the list of digits into a string

Why does someone always find my ideas first... :P

Ruby, 67 bytes
a,b=0,1
gets.to_i.times{a,b=b,a+b}
puts a.to_s(26).tr"0-9a-p","a-z"

Matlab, 133 bytes
n=input('');if n<2,y=n;else
f=0;g=1;for k=2:n
h=f+g;f=g;g=h;end
y=fix(mod(g./26.^(fix(log(g)/log(26)):-1:0),26));end
disp(char(y+97))

Ruby, 125 bytes
Not gonna win any time soon, but it was fun & my first code golf :')
def f(n);n<3?(n>0?1:0):f(n-1)+f(n-2);end
def a(s);s.bytes.map{|n|n<58?n+49:n+10}.pack("C*");end
puts a(f(gets.to_i).to_s(26))

First line is a function to compute fibonacci, second converts from Ruby's built-in base 26 encoding (0-9 then a-p) into a-z encoding, third gets a line from STDIN and runs it through both.


text:
Solving less-than inequalities with positive integers
Write a program or function that takes in a nonempty list of mathematical inequalities that use the less than operator (<). Each line in the list will have the form
[variable] < [variable]

where a [variable] may be any nonempty string of lowercase a-z characters. As in normal math and programming, variables with the same name are identical.
If a positive integer can be assigned to each variable such that all the inequalities are satisfied, then print or return a list of the variables with such an assignment. Each line in this list should have the form
[variable] = [positive integer]

and all variables must occur exactly once in any order.
Note that there may be many possible positive integer solutions to the set of inequalities. Any one of them is valid output.
If there are no solutions to the inequalities, then either don't output anything or output a falsy value (it's up to you).
The shortest code in bytes wins.
Examples
If the input were
mouse < cat
mouse < dog

then all of these would be valid outputs:
mouse = 1
cat = 2
dog = 2
mouse = 37
cat = 194
dog = 204
mouse = 2
cat = 2000000004
dog = 3
If the input were
rickon < bran
bran < arya
arya < sansa
sansa < robb
robb < rickon

then no assignment is possible because it boils down to rickon < rickon, so there either is no output or a falsy output.
More examples with solutions:
x < y

x = 90
y = 91

---

p < q
p < q

p = 1
q = 2

---

q < p
q < p

p = 2
q = 1

---

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyzz

abcdefghijklmnopqrstuvwxyz = 123456789
abcdefghijklmnopqrstuvwxyzz = 1234567890

---

pot < spot
pot < spot
pot < spots

pot = 5
spot = 7
spots = 6

---

d < a
d < b
d < c
d < e

d = 1
a = 4
b = 4
c = 5
e = 4

---

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

aaaa = 4
aa = 2
aaaaa = 5
a = 1
aaa = 3

---

frog < toad
frog < toaster
toad < llama
llama < hippo
raccoon < science
science < toast
toaster < toad
tuna < salmon
hippo < science
toasted < toast

raccoon = 1
frog = 2
toaster = 3
toasted = 4
toad = 5
llama = 6
hippo = 7
science = 8
toast = 9
tuna = 10
salmon = 11

More examples with no solutions: (separated by empty lines)
z < z

ps < ps
ps < ps

q < p
p < q

p < q
q < p

a < b
b < c
c < a

d < a
d < b
d < c
d < d

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyz

bolero < minuet
minuet < bolero

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
aaaaa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

g < c
a < g
b < a
c < a

g < b
a < g
b < a
c < a

g < b
a < g
b < a
c < b

g < c
a < g
b < a
c < b

geobits < geoborts
geobrits < geoborts
geology < geobits
geoborts < geology

Very closely related

Any limits on runtime?

@Vɪʜᴀɴ No lmits.

How do we know when input ends? Is there empty line or something?

@Yes. You can assume there's a trailing newline.

Pyth, 39 bytes
V>1f.A<MxMLTN.pS{s=Nm%2cd).zVNjd[H\==hZ

Try it online: Demonstration
Brute-forces through all possible permutations (and interpret them as sortings), check if they match the inequalities, and assign them the values 1, 2, ...., n.
Explanation
f.A<MxMLTN.pS{s=Nm%2cd).z
                 m     .z  map each input line d to:
                    cd)       split d by spaces
                  %2          and remove the second element
               =N          save this list of pairs to N
              s            combine these pairs to a big list of variable names
             {             set (remove duplicates)
          .pS              generate all permutations
f                          filter for permutations T, which satisfy:
     xMLTN                    replace each variable in N by their index in T
 .A<M                         check if each pair is ascending

V>1...VNjd[H\==hZ          implicit: Z = 0
 >1                        remove all but the last filtered permutation (if any)
V                          for each permutation N in ^ (runs zero times or once):
      VN                      for each variable H in N:
          [                      generate a list containing:
           H                        H
            \=                      "="
              =hZ                   Z incremented by 1 (and update Z)
        jd                       join this list by spaces and print

CJam (53 52 49 bytes)
qS-N/'<f/:A:|e!{A{1$1$&=!},!*},:ee{()" = "\N}f%1<

Online demo
This brute-forces all permutations of the distinct tokens, filtering for those assignments of the numbers 0 to n-1 which obey all of the constraints, and then formats them, incrementing the numbers, and presents the first one. This is certain to find a solution if there is one, because it's essentially a topological sort.
Thanks to Reto Koradi for 3 chars and Martin Büttner for 1.

@RetoKoradi, doh! Indeed.

Mathematica, 83 bytes
Quiet@Check[Equal@@@FindInstance[Join[#,#>0&/@(v=Sequence@@@#)],v,Integers][[1]],]&

Takes input as a list of inequalities. Either outputs a list of assignments or Null if it is impossible.


text:
Calculate the bounded cumulative sum of a vector
The cumulative sum of a vector is calculated by simply taking the sum of all previous elements. For instance:
vec =     [1  1  1 -1 -1 -1 -1 -1  1  1  1  1 -1]
cum_vec = [1  2  3  2  1  0 -1 -2 -1  0  1  2  1]

Now, impose an upper and a lower limit, meaning that you stop increasing the cumulative sum if it's at the upper limit, and stop decreasing the cumulative sum if it's at the lower limit. A simple example:
upper_lim = 2
lower_lim = -1
vec =     [1  1  1 -1 -1 -1 -1 -1  1  1  1  1 -1]
cum_vec = [1  2  2  1  0 -1 -1 -1  0  1  2  2  1]

The input vector consists of integers, not necessarily only 1 and -1, both positive and negative. Assume that upper_lim >= lower_lim. If the first element of the vector is outside the boundary, jump directly to the boundary (see last example).
Write a function that takes a vector of integers as input, and two integers that represent the upper and lower limits. Output the bounded cumulative vector, as defined above. The input can be as either function arguments or from STDIN.
Standard code golf rules apply.
Examples:
upper_lim = 6
lower_lim = -2
vec =     [1  4  3 -10  3  2  2  5 -4]
cum_vec = [1  5  6  -2  1  3  5  6  2]

upper_lim = 100
lower_lim = -100
vec =     [1  1  1  1  1  1]
cum_vec = [1  2  3  4  5  6]

upper_lim = 5
lower_lim = 0
vec =     [10 -4 -3  2]
cum_vec = [5   1  0  2]

upper_lim = 0
lower_lim = 0
vec =     [3  5 -2  1]
cum_vec = [0  0  0  0]

upper_lim = 10
lower_lim = 5
vec =     [1  4  6]
cum_vec = [5  9 10]
           |
           Note, jumped to 5, because 5 is the lower bound.

Pyth, 14 bytes
t.u@S+Q+NY1vwZ

Try it online: Demonstration or Test Suite
Explanation
t.u@S+Q+NY1vwZ  implicit: Q = first input list [upper_lim, lower_lim]
 .u        vwZ  for each number Y in the next input list, update N = 0 with:
       +NY         N + Y
     +Q            append this to Q
    S              sort this list
   @      1        take the middle element
                .u returns a list with all intermediate values of N
t                  remove the first value, print the rest

CJam, 16 15 bytes
l~f{\T++$1=:T}`

Try it online
This takes the list as first argument, and the pair of upper/lower limit as a second 2-element list. Example input:
[1 4 3 -10 3 2 2 5 -4] [6 -2]

The latest version saves 1 byte by sorting the 3 values, and taking the middle value, instead of using a max and min operation. This was also used in Jakube's solution, as well as suggested by Martin.
Explanation:
l~    Get and parse input. This leaves the value and bounds lists on the stack.
f{    Apply block with value (the bounds list).
  \     Swap new value to top.
  T     Get previous value from variable T (which is default initialized to 0).
  +     Add new value and previous value.
  +     Append new value to bounds list, producing a 3 value list.
  $     Sort it...
  1=    And take the middle value.
  :T    Store in variable T for next iteration.
}     End of apply loop.
`     Convert list to string.

JavaScript (ES6), 43 bytes
(l,u,v,p=0)=>v.map(c=>p=(p+=c)<l?l:p>u?u:p)

Defines an anonymous function that takes input in the format lower bound, upper bound, vector (as JS Array). I don't know if it could be any shorter, but I'll try. Suggestions welcome!

Haskell, 37 bytes
u#l=tail.scanl(((min u.max l).).(+))0

Usage example: 6 # (-2) $ [1,4,3,-10,3,2,2,5,-4] -> [1,5,6,-2,1,3,5,6,2].
Start the sum with 0 to fix initial values out of bounds. Take the tail to remove it from the final result.

R, 61 bytes
function(x,l,u,s=0)sapply(x,function(i)s<<-min(u,max(l,s+i)))

sapply is the function to apply a function to every element of a vector (here x) but it is usually done in a context where all the evaluations are independent and without side-effect. Here, however, I use the <<- operator to make an assignment in the parent/calling environment of sapply so that the cumulative sum s can be stored outside the iterative evaluations. This is very bad practice...

Julia, 44 42 38 bytes
f(x,l,u,s=0)=[s=clamp(s+i,l,u)for i=x]

This creates a function f that accepts an array and two integers and returns an array.
Ungolfed:
function f(v::Array, u::Int, l::Int, s::Int = 0)
    # The parameter s is the cumulative sum, which begins
    # at 0

    # For each element i of v, define s to be s+i if
    # l ≤ s+i ≤ u, l if s+i < l, or u if s+i > u
    x = [s = clamp(s + i, l, u) for i = v]

    return x
end

Saved 2 bytes by using ETHproductions' idea of including the cumulative sum as a function parameter and 1 bytes thanks to Glen O.

Mathematica, 46 bytes
Rest@FoldList[{a,b}Min[a+b,#2]~Max~#3,0,#]&

The funny character is U+F4A1 for \[Function]. If the first element can be assumed to be in the range, I could save 7 bytes.

Python 2, 67 Bytes
lambda u,l,v:reduce(lambda x,y:x+[max(min(x[-1]+y,u),l)],v,[0])[1:]

Minkolang 0.9, 30 bytes
0I3-[2g+d0c`,3&x0cd1c`3&x1cdN]

This, as a function, assumes the stack has been pre-initialized to high, low, vector. The full program is below (37 bytes) and takes input as high, low, vector.
(n$I$)0I4-[2g+d0c`,3&x0cd1c`3&x1cdN].

Try it here.
Explanation
(n$I$)                                   Read in integers from input until empty
      0                                  Initialize cumulative sum
       I4-[                        ]     Loop over vector
           2g+                           Get the next partial sum
              d0c`,3&x0c                 If too high, replace with high
                        d1c`3&x1cd       If too low, replace with low
                                  N      Output as integer
                                    .    Stop

APL, 29 27 18 bytes
As Dennis pointed out in chat, \ (expand) works from left to right, but applies the function being expanded with from right to left. So we can't just do 1↓(⎕⌈⎕⌊+)\0,⎕. We work around this by taking the ,\ of the array, and then processing each subarray separately using / (fold).
1↓(⎕⌈⎕⌊+)/¨⌽¨,\0,⎕

Input in the order array, upper bound, lower bound.

C 98 bytes
It's long, but it works

#define P printf(
void c(*v,n,u,l,s,c){P"[");while(c++<n)s+=*v++,s=s<u?s>l?s:l:u,P"%d ",s);P"]");}

Usage example
#define P printf(
void c(*v,n,u,l,s,c) {
    P"[");
    while(c++<n)
        s+=*v++,s=s<u?s>l?s:l:u,P"%d ",s);
    P"]");
}

int main() {
    int vec[9] = {1, 4, 3, -10, 3, 2, 2, 5, -4};
    int upper = 6, lower = -2, count = 9;
    c(vec, count, upper, lower, 0, 0);
}

The output would be
[1 5 6 -2 1 3 5 6 2 ]

K (oK), 12 bytes
{0(x&y|+)\z}

Try it online!
Similar to lirtosiast's APL answer, but with some simplifications. Uses 0 as the seed for a scan over z.

Jelly, 9 bytes
Ż+«⁴»⁵ʋ\Ḋ

Try it online!
We can remove the first and last bytes if not for the [1, 4, 6] test case. This is a full program which takes the arguments on the command line in the order vec upper_limit lower_limit
How it works
Ż+«⁴»⁵ʋ\Ḋ - Main link. Takes a list V on the left
            And integers U and L on the command line
Ż         - Prepend a 0 to V
      ʋ   - Group the previous 4 links together into a dyad f(x, y):
 +        -   x + y
   ⁴      -   U
  «       -   min(x+y, U)
     ⁵    -   V
    »     -   max(min(x+y, U), L)
       \  - Cumulative reduce V by f(x, y)
        Ḋ - Remove the leading 0

Japt, 11 bytes
å@VwWmX+Y}T

Try it