text:
Shifty Eyes Shifting I's
Shifty-eyes ASCII guys like to shift ASCII Ii's:
>_> <_< >_< <_>

Given a string of shifty-guys, spaced apart or separate lines, shift the Ii's side to side, left the wall and right the skies:
Ii

The shortest shifter wins the prize.
Say What?
Write a program or function that takes in a string of an arbitrary list of these four ASCII emoticons, either space or newline separated (with an optional trailing newline):
>_>
<_<
>_<
<_>

For example, the input might be
>_> >_> <_>

or
>_>
>_>
<_>

(The method you support is up to you.)

Each emoticon performs a different action on the I and i characters, which always start like this:
Ii

>_> shifts I to the right by one, if possible, and then shifts i to the right by one.
<_< shifts I to the left by one, if possible, and then shifts i to the left by one, if possible.
>_< shifts I to the right by one, if possible, and then shifts i to the left by one, if possible.
<_> shifts I to the left by one, if possible, and then shifts i to the right by one.

I cannot be shifted left if it is at the left edge of the line (as it is initially), and cannot be shifted right if i is directly to its right (as it is initially).
i cannot be shifted left if I is directly to its left (as it is initially), but can always be shifted right.
Note that with these rules, I will always remain to the left of i, and I is attempted to be shifted before i for all emoticons.
Your program or function needs to print or return a string of the final Ii line after applying all the shifts in the order given, using spaces ( ) or periods (.) for empty space. Trailing spaces or periods and a single trailing newline are optionally allowed in the output. Don't mix spaces and periods.

For example, the input
>_>
>_>
<_>

has output
I...i

because the shifts apply like
start  |Ii
>_>    |I.i
>_>    |.I.i
<_>    |I...i

The shortest code in bytes wins. Tiebreaker is higher voted answer.
Test Cases
#[id number]
[space separated input]
[output]

Using . for clarity.
#0
[empty string]
Ii

#1
>_>
I.i

#2
<_<
Ii

#3
>_<
Ii

#4
<_>
I.i

#5
>_> >_>
.I.i

#6
>_> <_<
Ii

#7
>_> >_<
.Ii

#8
>_> <_>
I..i

#9
<_< >_>
I.i

#10
<_< <_<
Ii

#11
<_< >_<
Ii

#12
<_< <_>
I.i

#13
>_< >_>
I.i

#14
>_< <_<
Ii

#15
>_< >_<
Ii

#16
>_< <_>
I.i

#17
<_> >_>
.I.i

#18
<_> <_<
Ii

#19
<_> >_<
.Ii

#20
<_> <_>
I..i

#21
>_> >_> <_>
I...i

#22
<_> >_> >_> >_> <_> <_<
.I...i

#23
<_> >_> >_> >_> <_> <_< >_< <_< >_<
..Ii

#24
>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<
...I.....i

So the dots are optional, spaces can be there instead?

Are trailing spaces allowed in the output?

Can the input be a 2D char array, with each shifty guy on a line?

@RikerW - Yes. mbomb - Yes,  that's mentioned. Don - No.

Watch Shifty Eyes become an esoteric language...

You wrote "Note that with these rules, I is always shifted first". Now I get it but it's not so clear, as I cannot move at all until i is moved

@Helka You should put "Given a string of shifty-guy... and right the skies" in verse form :-)

@edc65 Clarified a bit.

CJam, 33 bytes
0Xq2%{'=-_3$+[2$W]-,*@+}/S*'i+'It

Uses the same algorithm as my Python answer, except with 0-indexing. Essentially:

Only look at the arrows in the input, converting < to -1 and > to 1
Only apply an update if it doesn't move us to position -1 and doesn't move us to the position of the other char
Since the arrows alternate between applying to I and applying to i, we alternate which position we update after each arrow

Thanks to @MartinBüttner for golfing the output step, taking off 5 bytes.
Try it online | Test suite
0X                 Initialise the two positions a = 0, b = 1
q2%                Read input and take every second char, leaving just the arrows

{ ... }/           For each arrow in the input...
  '=-              Subtract '=, leaving -1 for '< and 1 for '>
  _3$+             Duplicate and add a. Stack looks like [a b diff a+diff]
  [2$W]-           Perform setwise subtraction, [a+diff] - [b -1]
                   The result is empty list if a+diff is either b or -1, else [a+diff]
  ,                Length, yielding 0 or 1 respectively
                   0 means we don't want to update the char, 1 means we do
  *                Multiply diff by this result
  @+               Add to a. Stack now looks like [b a'] where a' is a updated

                   After the above loop, the stack ends with [(I position) (i position)]

S*                 Create (i position) many spaces
'i+                Stick an 'i at the end - this is the right place due to 0-indexing
'It                Set (I position) to 'I

Perl, 59 56 54 bytes
Includes +1 for -p
Run with the input on STDIN, e.g. perl -p shifty.pl <<< ">_> <_< >_< <_>"
shifty.pl:
s%^|<|(>)%y/iI/Ii/or$_=Ii;$1?s/i |i$/ i/:s/ i/i /%reg

Explanation
The control string alternates instructions for i and I and the rule is the same for both of them if you formulate them as:

< Move left if there is a space to the left
> Move right if there is a space or end of string to the right

So I'm going to swap i and I in the target string at each step so I only need to apply the rule to one letter ever. This is the y/iI/Ii/
I will walk the control string looking for < and > using a substitution which is usually the shortest way in perl to process something character by character. To avoid having to write $var =~ I want the control string in the perl default variable $_. And I also want an easy way to distinguish < from >. All this can be accomplished using
s%<|(>)%  code using $1 to distinguish < from > %eg

The target string I also want to manipulate using substitutions and for the same reason I want that in $_ too. $_ being two things at once seems impossible.
However I can have my cake and eat it too because the $_ inside the body of a substitution does not have to remain the same as the $_ being substituded. Once perl started substituting a string this string will not change even if you change the variable the string originally came from. So you can do something like:
s%<|(>)% change $_ here without disturbing the running substitution %eg

I want to replace the original $_ by the initial "Ii" only the very first time the substitution body gets executed (otherwise I keep resetting the target string). This replacement however also has to happen for an empty control string, so even for the empty control string the body needs to be executed at least once. To make sure the substition runs an extra time at the start of the control string (even for empty control strings) I change the substitution to:
s%^|<|(>)% change $_ here without disturbing the running substitution %eg

I will run the y/iI/Ii/ as the first thing inside the substitution code. While $_ is still the control string this won't yet contain any Ii, so if the transliteration indicates nothing was changed that is my trigger initialize $_:
y/iI/Ii/or$_=Ii

Now I can implement the actual moving of the letters. Since I start with a swap all moves should be done on i, not I. If $1 is set move i to the right:
s/i |i$/ i/

If $1 is not set move i to the left
s/ i/i /

Notice that at the start of the control string when I match ^ $1 will not be set, so it tries to move i to the left on the initial string Ii. This won't work because there is no space there, so the intial string remains undisturbed (this is why I put the () around > instead of <)
Only one problem remains: at the end of the outer substitution $_ is set to result of the outer substitution regardless of what you did to $_ inside the substitution body. So the target string with the proper placement of i and I gets lost. In older perls this would be a fatal flaw. More recent perls however have the r modifier which means "make a copy of the original string, do your substitution on that and return the resulting string (instead of number of matches)". When I use that here the result is that the modified command string gets discarded while the original $_ is not disturbed by perl and left after the substitution. However the disturbing I do on $_ is still done after perl left $_ alone. So at the end $_ will be the proper target string.
The -p option makes sure the original string is in $_ and also prints the final $_.

The initial string is Ii, not iI.

@zyabin101 The extra ^ match means I have to swap them. So the reverse initialization is correct.

LittleLua - 178 Bytes
r()l=sw(I)o=1 D='.'f q=1,#l do i l[q]:s(1,1)=='>'t i z+1~=o t z=z+1 e else i z-1>0 t z=z-1 e e i l[q]:s(3)=='>'t o=o+1 else i o-1~=z t o=o-1 e e e p(D:r(z).."I"..D:r(o-z-1)..'i')

Straight forward implementation.
Ungolfed:
r()                             --call for input
l=sw(I)                         --Split input by spaces
o=1                             --Hold i position (z holds I position)
D='.'                           --Redundant character
f q=1,#l do                     --Foreach table entry
    i l[q]:s(1,1)=='>' t        --If the first eye points right
        i z+1~=o t z=z+1 e      --Verify no collision and move the I
    else
        i z-1>0 t z=z-1 e       --If it points left.. .same...
    e                           --yatta yatta...
    i l[q]:s(3)=='>' t
        o=o+1
    else
        i o-1~=z t o=o-1 e
    e
e
p(D:r(z).."I"..D:r(o-z-1)..'i')--String repeats to print correct characters.

What is LittleLua?
LittleLua is a work in progress to try to level the playing fields between my language of choice for these challenges and esoteric languages that often have extremely powerful built-ins.
LittleLua is a Lua 5.3.6 interpreter with an additional module (LittleLua.Lua), as well as function and module names shrunk. These changes will expand over the next day or two, until I'm happy, but as it stands several of the largest changes between LittleLua and a the standard Lua interpreter are:
Functions and modules are shrunk:
io.read() -> r() (Value stored in built in variable "I")
string -> s
string.sub -> s.s or stringvalue:s
etc.

Built in variables
LittleLua has several built in variables to shrink some tasks:
z=0
o=10
h1="Hello, World!"
h2="Hello, World"
h3="hello, world"
h4=hello, world!"
etc.

Built in Functions
Currently a depressingly small list, but here it is:
d(N) -> Prints NxN identity matrix
sw(str) -> Splits string at spaces and returns table of results
sc(str) -> Splits string at commas and returns table of results
sd(str) -> Removes white space from a string (not including tabs)
ss(str,n) -> Swap N characters from beginning and end of string
sr(str,n) -> Swap N characters from beginning and end of string retaining order
sd(str) -> Split string into array of characters
co(ta) -> Concatenate table with no delimiter
co(ta, delim) -> Concatenate table with delimiter: delim

So is this a Lua golfing Lang?

Yes! Obviously (I hope) a work in progress. I felt I was at a little bit of a disadvantage with other languages being able to take input, sort it, trim it, split it and implicitly return it with a few characters, so I got the source for lua and I've been hacking away for a little bit. This specific version was finished before this challenge started, which is unfortunate. You know what they say, you get the experience right after you need it.

Stupid question -- take, say $, and use that in place of end or e -- non-A-Za-z-word chars don't need spaces around them, right? That'd shave a byte per end / e

Yeah, I was trying to make that work. By simply replacing the token with a non alphanumeric character it throws an error. I haven't dug deep enough to find out why yet though

You should add LittleLua to catalogues. If you have done so already, I'm interested to see the entries. =)

You golfed if to i, saving one byte per use, and end to e, saving two, but you left else alone?  Even in this simple program (5 ifs and 2 elses), you're wasting more bytes on else than you save on if.  (I'm assuming that's a planned improvement?)

Retina, 101 86
$
¶Ii
(`^¶

s`^>(.*)I( )?
$1$2I
s`^<(.*?)( )?I
$1I$2
s`^_>(.*)i
$1 i
s`^_<(.*?) ?i
$1i

Try it online
Saved 15 bytes thanks to daavko!
Takes input separated by newlines and outputs with the eyes separated by spaces.
Explanation:
I will explain stage by stage as usual. All of these stages are in Retina's Replace mode. That means the first line is a regular expression and the second line is a replacement string.
$
¶Ii

Add the initial Ii to the end of the input.

(`^¶

The backtick separates the stage from the options. The option character ( indicates that this stage is the start of a loop of stages to be executed repeatedly in order until a full cycle is completed without changing the input. Since this open parenthesis is never closed, all of the remaining stages are a part of this loop.
The actual stage is very simple, if the first character of the string is a newline then delete it. This is just to help make handling the empty input easier, otherwise it'd be golfier to add it on to the two last stages.
s`^>(.*)I( )?
$1$2I

Here, the option s causes the Regex metacharacter . to match newlines. This stage causes a leading > to match the I followed by an optional space. Then it replaces that match with the stuff after the >, followed by the optional space (so the empty string if the space couldn't be matched), and then the I.
s`^<(.*?)( )?I
$1I$2

This stage is very similar to the previous one, only the optional space is before the I, and the order and eye are reversed.
s`^_>(.*)i
$1 i

The handling of i is actually often simpler, because we don't have to worry about optionally adding or removing as i can always move right. For the i cases we match away the underscore as well as the greater/less than sign, but otherwise do similar logic. This one adds a space before the i.
s`^_<(.*?) ?i
$1i

Again similar to the above, but it deletes the character before the i if that character is a space, otherwise it only removes the emoticon.

You can get it down to 86 with: s\^>(.*)i( |$)?=>s`^>(.)iand its replacement$1$#2$ i=>$1 i, and s`^<(.*?)( )?i=>s`^<(.*?) ?iand its replacement$1i$2=>$1i`.

@mbomb007 Yes, I've tested it for all 24 inputs. No errors found.

@daavko Thanks! I knew I had some stuff lying around from when I copied between the two cases, but I had to leave my computer soon after posting. Edited :)

Javascript (ES6)  176 171 168 155 148 147 142 141 bytes
//v8 - I was sure saving off math was saving a byte, thanks ETF
_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v7 - not checking first char when I can check whole string - changed how I create end string (stolen from edc65)
_=>_.split` `.map(m=>(I=m<'='?I-1||0:M.min(i-1,I+1))+(i=m[2]=='<'?M.max(I+1,i-1):i+1),i=1,I=0,M=Math)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v6 - one more byte
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)+((a=Array(i))[I]='I')&&a.join`.`+'i'

//v5 - not filling array with '.', just joining with . later
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i))[I]='I')&&a.join`.`+'i'

//v4 - realized I didn't need to split >_> on _, just use the 0th and 2nd index
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v3 - saving Math to a var (thanks @Verzio)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v2 - as a single expression! (thanks @Downgoat)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//version 1
_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

Usage
f=_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

f(">_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<")
//"...I.....i"

Degolfed (v6, v7 isn't much different)
//my solution has changed slightly, but not significantly enough to redo the below

_=>                   //take an input
  _.split` `          //split to each command <_<
   .map(              //do something for each command (each command being called m)
     m=>
       (I=            //set I to.... 'I will be the index of the letter I'
         m[0]=='<'?   //is the first char of the command '<'?
           Math.max(0,I-1)   //yes => move I to the left (but don't move past 0)
           :
           Math.min(i-1,I+1)  //no => move I to the right one, but keep it one less than i
       )

       +              //also we need to mess with i
       (i=
        m[2]=='<'?    //is the 3rd char of the command '<'?
          Math.max(I+1,i-1)  //yes => move i to the left, but keep it one right of I
          :
          i+1         //move i to the right (no bounds on how far right i can go)
       )

       ,i=1,I=0       //set I to 0 and i to 1 initially
     )
   +                  //this just lets us chain commands into one expression, not really adding
   (
    (a=Array(i))[I]='I') //create an array of length i (will be one shorter than we really need)
                         //set element I to 'I'

   &&                    //last chained command, we know the array creation will be true
                         //so javascript will just output the next thing as the return for the function
   a.join`.`+'i'         //join the array with '.' (into a string) and append i
                         //i will always be the last element

Instead of using =>{ ... } you could make is a expression and save quite a few bytes

I was creeping up on quitting time at work and wanted to wrap things up :)  I tried to get rid of it, but couldn't quite get it before 4 :P  I'll take another look

Hint: save yourself a byte and just write out Math twice.

MATL, 56 55 50 49 47 bytes
1Hj3\q4ZC"w@1)+lhX>yqhX<w@3)+yQhX>]tZ"105b(73b(

Try it online!
1           % push 1: initial position of 'I'
H           % push 2: initial position of 'i'
j           % take input as a string
4\q         % modulo 3 and subtract 1: this gives -1 for '<', 1 for '>'
4Zc         % arrange blocks of length 4 as columns of 2D array. This pads last
            % block with a zero (because the separating space won't be there).
            % Only first and third and last rows will be used
"           % for each column
  w         %   swap: move position of 'I' to top of stack
  @1)       %   first number (+/-1) of current column: tells where the 'I' moves
  +         %   add
  lhX>      %   max with 1: 'I' cannot move left past position 1
  y         %   duplicate position of 'i'
  qhX<      %   max with that number minus 1: 'I' cannot collide with 'i'
  w         %   swap: move position of 'i' to top of stack
  @3)       %   last number (+/-1) of current column: tells where the 'i' moves
  +         %   add
  y         %   duplicate position of 'I'
  QhX>      %   max with that number plus 1: 'i' cannot collide with 'I'
]           % end for each
t           % duplicate position of 'I'. This is the output string length
Z"          % string with that many spaces
105b(       % set 'i' at its computed position in that string
73b(        % set 'I' at its computed position in that string

the lack of matching parens + braces-- it burNS MY EYES

@tac Haha. At least the quotes "match"

Python, 142 141 134 122 121 bytes
Saved 19 bytes thanks to xnor.
def f(l,I=0,i=1):
    for a,_,b in l.split():I-=[I>0,-(i!=I+1)][a>'='];i-=[i!=I+1,-1][b>'=']
    return'.'*I+'I'+'.'*(i+~I)+'i'

Example:
>>> assert f('<_> >_> >_> >_> <_> <_<') == '.I...i'
>>>

Explanation:
def f(l, I=0, i=1):
    for a, _, b in l.split():
        I-= -(i!=I+1) if a == '>' else I > 0
        i-= -1 if b == '>' else i!=I+1

    return '.'*I + 'I' + '.'*(i-I-1) + 'i'

Your byte count from the paste is 148 - looks like you pasted the code with the extra spaces into the answer.

@Celeo: each line in the function body is indented with 1 tab character. You can verify that by clicking "edit". However, SE renders code with tabs replaced by 4 spaces. It's possible to indent function body with 1 space, instead of 1 tab, though.

Won't i always stay greater than I?

@xnor: can't believe I missed that :( Thanks.

@vaultah I think this lets you simplify the line to a string concatenation of dots, I, dots, i, without any need for lists and joining.

GNU sed, 81 bytes
(including +1 for -r flag)
#!/bin/sed -rf
s!<!s/ I/I /;!g
s!>!s/I / I/;!g
s!_(.{9})!\L\1!g
s!i !i!g
s/.*/echo Ii|sed '&'/e

This creates a new sed program from the input (which you can see by removing the last line), and applies it to the start state Ii.
Explanation

The first two lines convert < and > to 'substitute' commands that shift I left and right respectively.
Then we change the one following _ to work on i rather than I
i is not bounded by any right-hand edge, so don't add or consume space following it
Finally, apply the created command to the input Ii.  s///e always uses /bin/sh as its shell, so I couldn't shorten this to sed '&'<<<Ii as I wanted (that's a Bash redirection syntax).

Test results
$ for i in '' '>_>' '<_<' '>_<' '<_>' '>_> >_>' '>_> <_<' '>_> >_<' '>_> <_>' '<_< >_>' '<_< <_<' '<_< >_<' '<_< <_>' '>_< >_>' '>_< <_<' '>_< >_<' '>_< <_>' '<_> >_>' '<_> <_<' '<_> >_<' '<_> <_>' '>_> >_> <_>' '<_> >_> >_> >_> <_> <_<' '<_> >_> >_> >_> <_> <_< >_< <_< >_<' '>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<'
> do printf '%s => ' "$i"; ./74719.sed <<<"$i" | tr \  .; done | cat -n
     1   => Ii
     2  >_> => I.i
     3  <_< => Ii
     4  >_< => Ii
     5  <_> => I.i
     6  >_> >_> => .I.i
     7  >_> <_< => Ii
     8  >_> >_< => .Ii
     9  >_> <_> => I..i
    10  <_< >_> => I.i
    11  <_< <_< => Ii
    12  <_< >_< => Ii
    13  <_< <_> => I.i
    14  >_< >_> => I.i
    15  >_< <_< => Ii
    16  >_< >_< => Ii
    17  >_< <_> => I.i
    18  <_> >_> => .I.i
    19  <_> <_< => Ii
    20  <_> >_< => .Ii
    21  <_> <_> => I..i
    22  >_> >_> <_> => I...i
    23  <_> >_> >_> >_> <_> <_< => .I...i
    24  <_> >_> >_> >_> <_> <_< >_< <_< >_< => ..Ii
    25  >_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_< => ...I.....i

Retina, 91 86 bytes
I probably didn't take the best approach, so it can probably be golfed more. And no, I did not copy FryAmTheEggman (I know they're really similar in our approaches). I didn't even see his answer until after I posted mine.
$
¶Ii
(`^¶

sr`^<_(.*)( |)I
$1I$2
s`^>_(.*)I( ?)
$1$2I
sr`^<(.*) ?i
$1i
s`^>(.*)i
$1 i

Try it online

You don't need the ( |) at the end of last match line, as there will never be any space after i. Also, again on last match line, you don't need closing bracket for the loop. Unclosed loop is auto-closed at end of file in Retina.

Thanks. I used to have spaces after i and something after that replace. Forgot to change those.

Javascript (ES6) 166 bytes
Using Charlie Wynn's answer, I managed to save 10 bytes by defining Math.max as M and calling M each time his script uses
_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M=Math.max;M(0,I-1):M(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

(I didn't write this golf, Charlie Wynn did here. I merely modified it to make it shorter)

Welcome to PPCG! Here, we make comments on posts that can be improved. Unless you have a (radically) different solution, you would comment a golfing suggestion on the original post.

I would've, but I don't have enough reputation to do that.

It can stay, but people may end up downvoting. Sorry. I think it can stay, but others may not.

You honestly did what you could. +1

I was going to comment on the other answer the changes you did, before seeing your answer. +1 on that! But your code throws SyntaxError: missing : in conditional expression on Firefox. You could fix it with _=>{I=0,i=1,M=Math.max;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):M(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}, which has the same exact size.

I'll approve this if you'll let me steal it for mine :)

I do get a syntax error in chrome though

@Charlie Wynn, go for it :) (It is your code anyway)

JavaScript (ES6), 115 118
Edit: 3 bytes saved thx CharlieWynn
a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

p is the number of spaces before I; q is the number of spaces between I and i. Neither can be negative.
Less golfed
a=>(
  a.split(' ').map( x=> (
    x>'='?q&&(--q,++p):p&&(--p,++q), // try to move I based on 1st char of x
    x[2]>'='?++q:q&&--q // try to move i based on 3rd char of x
  )
  , p=q=0), // starting values of p and q
  '.'.repeat(p)+'I' + '.'.repeat(q) +'i' // return value
)

Test

f=a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

console.log=x=>O.textContent+=x+'\n'

;[['','Ii'],
['>_>','I.i'],
['<_<','Ii'],
['>_<','Ii'],
['<_>','I.i'],
['>_> >_>','.I.i'],
['>_> <_<','Ii'],
['>_> >_<','.Ii'],
['>_> <_>','I..i'],
['<_< >_>','I.i'],
['<_< <_<','Ii'],
['<_< >_<','Ii'],
['<_< <_>','I.i'],
['>_< >_>','I.i'],
['>_< <_<','Ii'],
['>_< >_<','Ii'],
['>_< <_>','I.i'],
['<_> >_>','.I.i'],
['<_> <_<','Ii'],
['<_> >_<','.Ii'],
['<_> <_>','I..i'],
['>_> >_> <_>','I...i'],
['<_> >_> >_> >_> <_> <_<','.I...i'],
['<_> >_> >_> >_> <_> <_< >_< <_< >_<','..Ii'],
['>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<','...I.....i']]
.forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i +' -> '+r + (r==k?' OK':' KO (exp '+k+')'))
})
<pre id=O></pre>

You can save one if you .split .map( instead of .replace(/\S+/,
I really like how you're storing the distance from I to i instead of position of i.  I wanted to change mine to use that but I think it'd just be a mirror of yours.

it saves 2 bytes! thx @CharlieWynn .. or even 3

Retina, 61 58 bytes
3 bytes saved thanks to @FryAmTheEggman.
^
Ii
(`( ?)I(.*i) <|I( ?)(.*i) >
$3I$1$2$4
 ?i_<
i
i_>
 i

Explanation comes a bit later.
Try it online!
Modified code with batch test.

Ah. Putting the I's at the front does make more sense...

Python 2, 96 92 bytes
f=lambda s,I=1,i=2:s and f(s[2:],i,I+cmp(s,'=')*(0<I+cmp(s,'=')!=i))or'%*c'*2%(I,73,i-I,105)

Pretty shifty-looking solution for a shifty challenge. Input like f('>_> <_>'), output like 'I  i'.
Verification program (assuming tests is the multiline test case string):
for test in zip(*[iter(tests.replace("[empty string]", "").splitlines())]*4):
    assert f(test[1]) == test[2].replace('.',' ')

The program reads each arrow one at a time, starting with I=1, i=2 and using 1-based indices. The variable names are a tad misleading since they swap roles - after every char, I becomes i and i becomes I updated. A char is only updated if it would move to neither the position of the other char nor position 0.
For example, for >_> <_> >_< we do:
Char     I (= i from previous iteration)        i
-----------------------------------------------------------------------------------------
         1                                      2
>        2                                      1+1 = 2 would overlap, so remain 1
>        1                                      2+1 = 3
<        3                                      1-1 = 0 is too low, so remain 1
>        1                                      3+1 = 4
>        4                                      1+1 = 2
<        2                                      4-1 = 3

This gives ' Ii' as desired.

Lua, 104 bytes
s='Ii'for v in(...):gmatch'%S_?'do
s=s:gsub(('>i$ i< ii>_I  I<_ II '):match(v..'(..)(%P+)'))end
print(s)

Usage:
$ lua shifter.lua "<_> >_> >_> >_> <_> <_<"
 I   i

Javascript (ES5), 153 125 bytes
takes an input by setting a variable a before running
I=i=0;for(b of a.split(" "))b[0]==">"?i!=I&&I++:I>0&&I--,b[2]==">"?i++:I!=i&&i--;r=Array(i).fill(".");r[I]="I";r.join("")+"i"

Somewhat ungolfed:
I=i=0;
for(b of a.split(" "))
   b[0]==">"
       ? i!=I && I++
       : I>0 && I--,
   b[2]==">"
       ? i++
       : I!=i && i--
;
r=Array(i).fill(".");
r[I]="I";
r.join("")+"i"

Mathematica, 125 bytes
Fold[StringReplace,"Ii",StringCases[#,"<_"|">_"|">"|"<"]/.{"<_"->".I"->"I.",">_"->"I."->".I","<"->".i"->"i",">"->"i"->".i"}]&

Pure function with first argument #. The idea is that each <_, >_, <, and > in the input corresponds to a string replacement rule. "<_"|">_"|">"|"<" is a string pattern that matches any of those four expressions. StringCases[#,"<_"|">_"|">"|"<"] will find all such matches. Then we replace (/.) each "<_" with the string replacement rule ".I"->"I.", each ">_" with the rule "I."->".I", and so forth. Then I want to sequentially apply each replacement rule to the string "Ii", but StringReplace will only look for matches in the parts of the string which have not been replaced, so we left Fold the function StringReplace over the list of replacement rules with starting value "Ii".
Perhaps it would be clearer with an example (here % refers to the previous cell's output):


text:
Generalization of abbreviations
Given an input of a list of words and their abbreviations, output the pattern
by which the abbreviations can be formed.
Let us take the example input of
potato ptao
puzzle pzze

as an example (that is, the abbreviation for potato is ptao, and the
abbreviation for puzzle is pzze).
Consider all possible ways to obtain ptao from potato. One possible way is
to take the first, third, fourth, and sixth letters, which we will refer to as
1346. But since t and o appear multiple times in the word, there are
multiple other possible ways to generate ptao from potato: 1546, 1342,
and 1542.
Similarly, note that pzze can be generated from puzzle with any of 1336,
1346, 1436, 1446. The only pattern that these two abbreviations have in
common is 1346; therefore, that must be the output for this input. If
multiple possible patterns are possible, you may output any, some, or all of
them (at least one).
You may assume that:

Input words and abbreviations contain only lowercase letter.
There is at least one word/abbreviation pair in the input.
It is possible for every abbreviation to be formed from its corresponding
word.
There will always be at least one pattern that forms every abbreviation.
The maximum length of each word is 9 characters.

Input may be taken as any of the following:

2-dimensional array/list/array of tuples/etc. [[word, abbr], [word, abbr],
...]
flat 1-dimensional array/list [word, abbr, word, abbr, ...]
single string, delimited by any single character that is not a lowercase
letter "word abbr word abbr"
hash/associative array/etc. {word => abbr, word => abbr, ...}

In any of these input options, you are also permitted to swap the order of word/abbr (please fully describe the input format in your post).
Output may be given as a single number, a string delimited by non-digits, or an array/list/tuple/etc. of numbers.
Since this is code-golf, the shortest code in bytes will win.
Test cases (remember that you only need to output ≥1 results if multiple
patterns work):
In                                Out
--------------------------------------------------------
potato ptao puzzle pzze         | 1346
aabbcc abc fddeef def           | 246
prgrmming prgmg puzzles pzzlz   | 14353
aaaaa a bbbb b ccc c dd d e e   | 1
aaaaa a bbbb b ccc c            | 1, 2, 3
abcxyz zbcyax                   | 623514
abcxyz acbbacbcbacbbac          | 132213232132213
potato ptao                     | 1346, 1546, 1342, 1542
a aaaaa                         | 11111

Just to make sure I understand, the abbreviation process can reorder letters?

@xnor Correct, as seen in several of the test cases.

Can the 2D array have the other orientation? Each column, not each row, would contain a pair of word/abbrev

@DonMuesli No, it cannot.

Can we use zero-indexing, so print 0235 instead of 1346?

Can we print the output as a list of integers instead of a plain number?

@DenkerAffe No to your first question, yes to your second one (I thought I remembered writing that in the question... :P).

MATL, 29 bytes
!"@Y:!=2#fX:wX:h]N$v1XQtv4#X>

Input is a 2D array in the following format:
{'potato' 'ptao'; 'puzzle' 'pzze'}

Try it online! (the linked code includes some modifications owing to changes in the language since this answer was posted)
!       % take input. Transpose
"       % for each column
  @Y:   %   push column. Unpack the two strings and push them onto the stack
  !     %   transpose second string
  =     %   matrix with all pairwise matchings of characters in word and abbreviation
  2#f   %   find row and col indices of those matchings
  X:    %   transform into column vector
  wX:   %   swap, transform into column vector
  h     %   concat into a two-col matrix
]       % end for
N$v     % concatenate all matrices containing the indices
1       % push 1
XQ      % build matrix adding 1 for each (row,col) index
tv      % concat vertically with itself, so that it has at least two rows.
        % This forces the following function to work on each col.
4#X>    % arg max of each col: position that produces a match in all pairs.
        % If there are several maximizers in each col this gives the first

The code required some involved (and lengthy!) tricks to

Prevent the orientation of vectors produced by find (f) from changing depending on input shape. These are statements X:wX:: force both outputs to be column vectors.
Counteract the "work along first non-singleton dimension" default behaviour of the min (X>) function. These are statements tv: concat a copy of itself to assure at least two rows);

Pyth, 19 bytes
mhh@Fd.TmmxkmbhdedQ

Try it here!
Takes a list in the following format:
[["word","abbr"],["word","abbr"],...]

Alternative 17 bytes solution which outputs the result as list of zero-based indices which are wrapped in an 1-element list:
m@Fd.TmmxkmbhdedQ

Explanation
Example: [["potato", "ptao"],["puzzle", "pzze"]]
First we map every char in the abbrevation to a list of the indices of all occurences in the word which yields
[[[0], [2, 4], [3], [1, 5]], [[0], [2, 3], [2, 3], [5]]]
Then we transpose this list which gives us
[[[0], [0]], [[2, 4], [2, 3]], [[3], [2, 3]], [[1, 5], [5]]]
So the indices of each char of each abbrevation are together in one list.
Then we just have to find one common index in all of those lists which yields:
[[0], [2], [3], [5]]
This is the output of my alternative 17 byte solution above. This then gets transformed into [1,3,4,6].
Code breakdown

mhh@Fd.TmmxkmbhdedQ   # Q = input

m                 Q   # map input with d
        m       ed    # map each abbrevation with k
            mbhd      # map word to char list
         mxk          # map each abbrevation char to a list of indices
      .T              # Transpose
    Fd                # Fold every element
   @                  # and filter on presence
 hh                   # Take first element of the result und and increment it

Couldn't you also delete the dm right before the @?

@Doorknob I can. Thanks for spotting that!

Perl, 46 45 42 bytes
Includes +1 for -p
Give input as sequential words on STDIN, e.g.
perl -p abbrev.pl
prgrmming
prgmg
puzzles
pzzlz

Terminate STDIN with ^D or ^Z or whatever is needed on your system
abbrev.pl:
s#.#${${--$_.$.%2}.=$&}||=-$_#eg;$_ x=eof

Explanation
Consider this input (conceptual layout, not the real way to input for this program):
potatoes     ptao
puzzle       pzze

The program build strings representing the vertical columns of the full strings indexed on a column id
id1    pp     -> 1
id2    ou     -> 2
id3    tz     -> 3
id4    az     -> 4
...

etc. It also does the same for the abbreviations, but using a different id
ID1    pp     -> 1
ID2    tz     -> 3
ID3    az     -> 4
ID4    oe     -> 6

The words are implicitely processed one by one by using the -p option.
The columns strings are constructed using repeated concatenations while each word is walked using s#.# ...code.. #eg, so each column needs a repeatable id. I use minus the column number followed by the line number modulo 2. The column number can be constructed using --$_ which starts out as the current word which due to the use of only a-z is guaranteed to evaluate as 0 in a numeric context. So I get -1, -2, -3, .... I'd really would have liked to use 1, 2, 3, ..., but using $_++ would trigger perl magic string increment instead of a normal numeric counter. I do want to use $_ and not some other variable because any other variable I would have to initialize to zero in every loop which takes too many bytes.
The line number modulo 2 is to make sure the ids for the full word and the ids for the abbreviation don't clash. Notice that I cannot use the full word and the abbreviation on one string to have a column number going over the combined string because the full words don't all have the same length, so the abbeviated word columns wouldn't line up. I also can't put the abbreviated word first (they all have the same length) because I need the count of the first column of the full words to be 1.
I abuse the perl global name space through a non strict reference to construct the column strings as:
${--$_.$.%2}.=$&

Next I map each column string to the first column number that string ever appears in (the mapping already indicated above) by again abusing the perl global namespace (but notice that the names cannot clash so the globals don't interfere with each other):
${${--$_.$.%2}.=$&} ||= -$_

I have to negate $_ because like I explained above I count the columns as -1, -2, -3, .... The ||= make sure only the first appearance of a given column gets a new column number, otherwise the previous column number is preserved and returned as value. This will happen in particular for every abbreviated word since the specification guarantees that there is a column in the full words that will have appeared beforehand. So in the very last abbreviated word each letter will be replaced by the column number in the full word that corresponds with the column for all abbreviated words. So the result of the very last substitution is the final result that is wanted. So print if and only if we are at the end of the input:
$_ x=eof

The column index assignment will also create entries for incomplete columns because the column is not completely constructed yet or some words are shorter and don't reach the full column length. This is not a problem since the columns needed in every abbreviated word are guaranteed to have a corrsponding column from the full words which has the maximum possible length (the number of currently seen pairs) so these extra entries never cause false matches.

Haskell, 74 bytes
import Data.List
foldl1 intersect.map(\(w,a)->mapM(`elemIndices`(' ':w))a)

Input format is a list of pairs of strings, e.g.:
*Main > foldl1 intersect.map(\(w,a)->mapM(`elemIndices`(' ':w))a)  $ [("potato","ptao"),("puzzle","pzze")]
[[1,3,4,6]]

How it works: mapM (same as sequence . map) first turns every pair (w,a) into a list of lists of indices of the letters in the abbreviation (' ': fixes Haskell's native 0-based index to 1-based), e.g. ("potato", "ptao") -> [[1],[3,5],[4],[2,6]] and then into a list of all combinations thereof where the element at position i is drawn from the ith sublist, e.g. [[1,3,4,2],[1,3,4,6],[1,5,4,2],[1,5,4,6]]. foldl1 intersect finds the intersection of all such lists of lists.

ES6, 92 bytes
(w,a)=>[...a[0]].map((_,i)=>[...w[0]].reduce((r,_,j)=>w.some((s,k)=>s[j]!=a[k][i])?r:++j,0))

Accepts input as an array of words and an array of abbreviations. Returns an array of 1-based indices (which costs me 2 bytes dammit). In the case of multiple solutions, the highest indices are returned.

Python 3, 210 bytes
Not an impressive answer seing the topscores here, but this is truly some of the craziest list comprehension I've ever done with Python. The approach is quite straigthforward.
 def r(p):
    z=[[[1+t[0]for t in i[0]if l==t[1]]for l in i[1]]for i in[[list(enumerate(w[0])),w[1]]for w in p]]
    return[list(set.intersection(set(e),*[set(i[z[0].index(e)])for i in z[1:]]))[0]for e in z[0]]

The function expects input always as a string 2-D array like: [[word, abbr],...] and returns a list of integers.
Ps: A detailed explanation coming soon
Ps2: Further golfing suggestions are welcomed!

source: Stack Exchange

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

sort: votes


text:
Code Golf Golf Score
It's Friday... so let's go golfing!  Write code that determines the player's scoring on a hole in a game of golf.  The code can be either a function or entire program. As the genre suggests, shortest code wins.
Input (parameters or stdin, your choice):

An integer representing the hole's par, guaranteed to be between 3 and 6
An integer representing the golfer's score, guaranteed to be between 1 and 64

Output (print to stdout or return, trailing newline allowed but not required, your choice):

if score is 1, output "Hole in one"
if score == par - 4 and par > 5, output "Condor"
if score == par - 3 and par > 4, output "Albatross"
if score == par - 2 and par > 3, output "Eagle"
if score == par - 1, output "Birdie"
if score == par, output "Par"
if score == par + 1, output "Bogey"
if score == par + 2, output "Double Bogey"
if score == par + 3, output "Triple Bogey"
if score > par + 3, output "Haha you loser"

EDIT
Congrats to Dennis on having the shortest answer!

I always wondered what was after triple bogey.

Incidentally the largest par is 7 not 6.

@Joshua I was temporarily confused about why you commented instead of edited your own post. Then it hit me. :P

@RikerW the two Josh's names are as close as their reputation :D

What if  score == 1  and  par == 2  ?

@RickyDemer: Par is not allowed to be less than 3; however if it were you would you would output "Hole in one".

What is the point of the "and par > X" clauses?  Surely the "Hole in one" criteria being checked first would make that step unnecessary?

Can the input be in any order?

@Doorknob input can be in any order.

Jelly, 61 bytes
_«4ị“Ƙḷ“&SẆ@ẓ“&T¡UQ“½⁽Ð'÷ṿɼ“½Œż“¡œM“v⁵“¥⁻c“£Ḋ⁶»
ç“µḣ⁻×⁵ñBƑ»’?

Try it online!
Background
This uses Jelly's static dictionary compression. You can find a compressor here. This way,
“Ƙḷ“&SẆ@ẓ“&T¡UQ“½⁽Ð'÷ṿɼ“½Œż“¡œM“v⁵“¥⁻c“£Ḋ⁶»

and
“Bogey“Double Bogey“Triple Bogey“Haha you loser“Condor“Albatross“Eagle“Birdie“Par”

as well as
“µḣ⁻×⁵ñBƑ»

and
“Hole in one”

are equivalent.
How it works
_«4ị“Ƙḷ“&SẆ@ẓ“&T¡UQ“½⁽Ð'÷ṿɼ“½Œż“¡œM“v⁵“¥⁻c“£Ḋ⁶»  Helper link. Arguments: score, par

_                                                Subtract the par from the score.
 «4                                              Cap the difference at 4.
   ị                                             Index into the list at the right.
    “Ƙḷ“&SẆ@ẓ“&T¡UQ“½⁽Ð'÷ṿɼ“½Œż“¡œM“v⁵“¥⁻c“£Ḋ⁶»  Yield a list of strings.

ç“µḣ⁻×⁵ñBƑ»’?  Main link. Arguments: score, pair

            ?  If...
           ’   the decremented score if non-zero:
ç                Call the helper link on both input arguments.
 “µḣ⁻×⁵ñBƑ»      Else, return “Hole in one”.

Congrats on the shortest answer!

PHP 5.3+, 173 167 166 159 156 151 127 121 bytes
echo[Condor,Albatross,Eagle,Birdie,Par,$b=Bogey,"Double $b","Triple $b","Haha you loser"][min(4+$s-$p,8)]?:"Hole in one";

Notice-free version, 139 137 bytes
echo$s-1?["Condor","Albatross","Eagle","Birdie","Par",$b="Bogey","Double $b","Triple $b","Haha you loser"][min(4+$s-$p,8)]:"Hole in one";

Set $score and $par variables before the echo and you're off.
exploded view
echo [Condor,
      Albatross,
      Eagle,
      Birdie,
      Par,
      $b = Bogey,
      "Double $b",
      "Triple $b",
      "Haha you loser"][ min( 4+$s-$p,8 ) ]
  ?: "Hole in one";

Edits
-6: Not storing the array, just calling it if need be.
-1: Flipping the ternary around.
-7: The lowest $s-$p with $s>1 is -4, so the max() isn't necessary, since 4+$s-$p >= 0.
-3: Array -> explode(), thanks CoolestVeto!
-5: Cheaty string literal undefined constant plus $r[-1] -> false, thanks Ismael Miguel!
-24: Moving from an explode() function to a printf/%s setup, with some tweaks, more thanks to Ismael Miguel for the change of direction.
-6: Swerve, we're back to echo again!

Can you turn it into one string and split by an arbitrary character?

@CoolestVeto As a matter of fact, I can.  Weirdly, it saves fewer bytes than expected, but any bytes are better than no bytes!

You can replace $b="Bogey"; with $b=Bogey; to save 2 bytes. Also, replace your $s-1? ... : ...; with an echo ... ?: ...;. Here's the 151 bytes long version: function g($s,$p){$b=Bogey;echo explode("-","Condor-Albatross-Eagle-Birdie-Par-$b-Double $b-Triple $b-Haha you loser")[min(4+$s-$p,8)]?:"Hole in one";}

Had no idea you could cheat string literals, neat.

Actually, it isn't a string literal anymore. It is an undefined constant. PHP hates those, and pretends that it is a string. Also, notice that the code I've provided won't work on older PHP versions. The ?: operator was introduced on PHP5.3. It provides a default value if the first value is falsey.

Yeah, it's a favorite of mine (?:, that is), I wind up having to double check my environment all the time to make sure it's copacetic.

If you don't like the warning you can use @Bogey, as it will "ignore" the warning. Also, can you try function g($s,$p){printf(explode(0,"Condor0Albatross0Eagle0Birdie0Par0%s0Double %s0Triple %s0Haha you loser")[min(4+$s-$p,8)]?:"Hole in one",Bogey);}? That one is 149 bytes long. I've used printf instead of echo and replaced the separator character with a number. Instead of string interpolation, I've decided to use the %s format, which is, literally, to indicate to replace it with a string.

Here's a (possibly) working and shorter one: printf([Condor,Albatross,Eagle,Birdie,Par,'%s','Double %s','Triple %s','Haha you loser'][min(4+$argv[1]-$argv[2],8)]?:'Hole in one',Bogey);. Basically: Removed the function declaration, removed the explore, removed the quotes, used an array and used $argv. The final code is 139 bytes long.

PHP has implicit string literals for undefined identifiers? ಠ_ಠ what is this, perl?

05AB1E, 91 90 bytes
Code:
-5+U“¥Ê€†€µ“ª"0Bogey"Ð”Condor Albatross²è Birdie Par ÿ‹¶ÿ½¿ÿ”ð¡“Haha€î loser“X0¹1Qm*@0ð:ðÛ

Explanation:
Part 1:
-5+                          # Computes Score - Par + 5
   U                         # Store in X
    “¥Ê€†€µ“ª                # Short for "Hole in one"
             "0Bogey"        # Push this string
                     Ð       # Triplicate

Part 2:
”Condor Albatross²è Birdie Par ÿ‹¶ÿ½¿ÿ”ð¡

This is the same as "Condor Albatross Eagle Birdie Par 0Bogey Double0Bogey Triple0Bogey" using string compression and string interpolation. We then split on spaces, using ð¡.
Part 3:
“Haha€î loser“                # Push "Haha you loser"
              X               # Push X
               0¹1Qm          # Compute 0 ^ (score == 1), this translates 1 to 0 and
                                everything else to 1.
                    *         # Multiply the top two items
                     @        # Get the string from that position
                      0ð:     # Replace zeros with spaces
                         ðÛ   # Trim off leading spaces

Discovered a lot of bugs, uses CP-1252 encoding.
Try it online!

...Whoa. Nicely done.

This code kinda looks like the random Unicode messages that you get when you install a non-English .exe thing (if you have English as your language in Windows things). Looks spectacular, though!

@DerpfacePython Haha, the random unicode messages are partially part of the code and the other part is part of a compressed message.

Vitsy, 131 bytes
D1-)["eno ni eloH"rZ;]r-5+D9/([X9]mZ
"rodnoC"
"ssortablA"
"elgaE"
"eidriB"
"raP"
"yegoB"
4m" elbuoD"
4m" elpirT"
"resol uoy ahaH"
Explanation:
D1-)["eno ni eloH"rZ;]r-5+D9/([X9]mZ
D1-)[                ]      If the second input is 1, do the bracketed stuff.
     "eno ni eloH"rZ;       Output "Hole in one" and quit.
r                           Reverse the stack.
 -                          Subtract the top two items.
  5+                        Add 5 to fix for negative values of score.
    D9/([  ]                If the result of that is greater than 8, do the stuff in brackets.
         X                  Remove the top item.
          9                 Push 9. This forces any items greater than 8 to be 9.
            m               Execute this number line.
             Z              Output everything in the stack.

This works by figuring out what the score is relative to the par, then executing different lines (and gaining different strings) thereof.
Try It Online!
Verbose Mode (for poops and giggles):
duplicate top item;
push 1;
subtract top two;
if (int) top is not 0;
begin recursive area;
toggle double quote;
push 14;
eval(stack);
capture stack as object with next;
 ;
eval(stack);
push input item;
 ;
push 14;
push length of stack;
capture stack as object with next;
push all ints between second to top and top;
toggle double quote;
reverse stack;
output stack as chars;
generic exit;
end recursive area;
reverse stack;
subtract top two;
push 5;
add top two;
duplicate top item;
push 9;
divide top two;
if (int) top is 0;
begin recursive area;
remove top;
push 9;
end recursive area;
goto top method;
output stack as chars;
:toggle double quote;
reverse stack;
capture stack as object with next;
push 13;
eval(stack);
capture stack as object with next;
push cosine of top;
toggle double quote;
:toggle double quote;
push inverse sine of top;
push inverse sine of top;
capture stack as object with next;
reverse stack;
push inverse tangent of top;
push 10;
push 11;
push length of stack;
push inverse cosine of top;
toggle double quote;
:toggle double quote;
push 14;
push length of stack;
g;
push 10;
push e;
toggle double quote;
:toggle double quote;
push 14;
push input item;
push 13;
reverse stack;
push input item;
B;
toggle double quote;
:toggle double quote;
reverse stack;
push 10;
push pi;
toggle double quote;
:toggle double quote;
push number of stacks;
push 14;
g;
capture stack as object with next;
B;
toggle double quote;
:push 4;
goto top method;
toggle double quote;
 ;
push 14;
push length of stack;
push 11;
flatten top two stacks;
capture stack as object with next;
duplicate top item;
toggle double quote;
:push 4;
goto top method;
toggle double quote;
 ;
push 14;
push length of stack;
push whether (int) top item is prime;
push input item;
reverse stack;
push tangent of top;
toggle double quote;
;
;
:toggle double quote;
reverse stack;
push 14;
push inverse sine of top;
capture stack as object with next;
push length of stack;
 ;
flatten top two stacks;
capture stack as object with next;
push number of stacks;
 ;
push 10;
factorize top item;
push 10;
push all ints between second to top and top;
toggle double quote;

"Push 9. This forces any items greater than 8 to be 9." Wat?

@tac This is to force the input that would result in "Haha you loser" to go to the line containing "Haha you loser".

LittleLua - 160 Bytes (non-competitive)
r()P=I B="Bogey"r()Z={"Hole in one","Condor","Albatross","Eagle","Birdie","Par",B,"Double "..B,"Triple "..B,"Haha, you loser"}p(I=='1'a Z[1]or Z[I-P+6]or Z[10])

I'm relatively certain I did  this right.
Accepts two integers, par and player's score.
The version of Little Lua that I used  to make this was uploaded after this challenge was posted, but was not edited afterwards. It's relatively obvious from the code that nothing has been added to simplify this challenge
LittleLua Info:
Once I am satisfied with the built ins and the functionality of Little Lua, source will be available along with an infopage.
LittleLua V0.02

This is non-competitive because the file was uploaded to Dropbox 2 hours after the challenge was posted.

https://github.com is much better at code hosting...

Absolutely, I just havent had a chance to set it up.

JavaScript (ES6), 125 124 bytes
p=>s=>"Hole in one,Condor,Albatross,Eagle,Birdie,Par,Bogey,Double Bogey,Triple Bogey".split`,`[s-1&&s-p+5]||"Haha you loser"

Assign to a variable e.g. f=p=>s=>, then call it like so: f(6)(2) Par first, then score.
May be able to be shortened by combining the "Bogey"s.

An example of combining the bogeys is: ",Double ,Triple ".split\,`[k-1]+"Bogey"wherek=s-p`.

Can I use your approach in my solution?

@zyabin101 that isn't discouraged, as long as it isn't outright plagiarism

@zyabin101 Thanks, I'll see if that makes it any shorter. And yes, feel free to use this approach in your answer.

I'm already using this.

Mouse-2002, 223 207 bytes
Removing comments would likely help...
??s:p:s.1=["Hole in one"]s.p.4-=p.5>["Condor"]s.p.3-=p.4>["Albatross"]s.p.2-=p.3>["Eagle"]s.p.1-=["Birdie"]s.p.=["Par"]s.p.1+=["Bogey"]s.p.2+=["Double Bogey"]s.p.2+=["Double Bogey"]s.p.3+>["Haha you loser"]$

Ungolfed:
? ? s: p:

s. 1 = [
  "Hole in one"
]

~ 1
s. p. 4 - = p. 5 > [
  "Condor"
]

~ 2
s. p. 3 - = p. 4 > [
  "Albatross"
]

~ 3
s. p. 2 - = p. 3 > [
  "Eagle"
]

~ 4
s. p. 1 - = [
  "Birdie"
]

~ 5
s. p. = [
  "Par"
]

~ 6
s. p. 1 + = [
  "Bogey"
]

~ 7
s. p. 2 + = [
  "Double Bogey"
]

~ 8
s. p. 2 + = [
  "Double Bogey"
]

s. p. 3 + > [
  "Haha you loser"
]

$

bash, 150 136 bytes
b=Bogey
(($2<2))&&echo Hole in one||tail -$[$2-$1+5]<<<"Haha you loser
Triple $b
Double $b
$b
Par
Birdie
Eagle
Albatross
Condor"|head -1

Test run:
llama@llama:...code/shell/ppcg74767golfgolf$ for x in {1..11}; do bash golfgolf.sh 6 $x; done
Hole in one
Condor
Albatross
Eagle
Birdie
Par
Bogey
Double Bogey
Triple Bogey
Haha you loser
Haha you loser

Thanks to Dennis for 14 bytes!

Python 2.7, 226 bytes
p,s=input()
b="Bogey"
l={s==1:"Hole in one",5<p==s+4:"Condor",4<p==s+3:"Albatross",3<p==s+2:"Eagle",s==p-1:"Birdie",s==p:"Par",s==p+1:b,s==p+2:"Double "+b,s==p+3:"Triple "+b,s>p+3:"Haha you loser"}
for r in l:
 if r:print l[r]

Hard to come up with a short python code when you're late to the party, best I could think of.

The last two lines should be changed to one: [print r for r in l if r]

Haskell - 131 bytes (counting newline)
1%p="Hole in one"
s%p=lines"Condore\nAlbatros\nEagle\nBirdie\nPar\nBogey\nDouble Bogey\nTriple Bogey\nHaha you loser"!!min(4-p+s)8

lines is the only way I can think of to golf in a list of strings that have to contain spaces with access only to Prelude so stuck with two character delimiters.
Still, Haskell isn't usually this competitive (against general languages at least).

You can import anything you like, not just the builtins

Python 2, 186 179 158 bytes
def c(s,p):a="Bogey";print["Condor","Albatross","Eagle","Birdie","Par",a,"Double "+a,"Triple "+a,"Haha you loser","Hole in one"][([[s-p+4,8][s-p>3],9][s==1])]

EDIT 1: added the missing "hole in one" case...
EDIT 2: golfed out some bytes (thanks to tac)

A lambda would be shorter, also see tips for golfing in Python

you can drop the space between 4 and else

If you modify the algorithm, you can just index a list rather than a dict

you can drop the space between print and {, and if you use a semicolon to put the a= and print on the same line, you can shave a byte of whitespace

Also, Albatross needs two s's

@tac actually "c=lambda x,y:" is longer than "def c(x,y):", thanks for the others suggestions

C, 198 Bytes
main(){char s=8,p=4,m[]="Hole in one.Condor.Albatross.Eagle.Birdie.Par.Bogey.Double Bogey.Triple Bogey.Haha you loser",*t,*x,i=0;for(x=m;t=strtok(x,".");x=0,i++)if((s-1?s-p>3?9:s-p+5:0)==i)puts(t);}

Japt, 97 bytes
`Ho¤  e
CÆBr
AlßNoss
Eag¤
Bir¹e
P
zD½e zTp¤ zHa y lo r`rz"Bogey
" ·g9m´V©V-U+6

Contains a bunch of unprintables. Test it online!
How it works
`Ho¤  e\nCÆBr\nAlßNoss\nEag¤\nBir¹e\nP\nzD½e zTp¤ zHa y lo r`                        rz"Bogey\n" ·  g9m´ V© V-U+6
"Hole in one\nCondor\nAlbatross\nEagle\nBirdie\nPar\nzDouble zTriple zHaha you loser"rz"Bogey\n" qR g9m--V&&V-U+6

              // Implicit: U = par, V = score
"..."         // Take this long, compressed string.
rz"Bogey\n"   // Replace each instance of "z" with "Bogey\n".
qR            // Split at newlines.

--V&&V-U+6    // If V is 1, take 0; otherwise, take V-U+5.
9m            // Take the smaller of this and 9.
g             // Get the item at this index in the previous list of words.
              // Implicit output

Python 2.7.2, 275 bytes
s=int(input())
p=int(input())
a="Bogey"
if s==1:b="Hole in one"
elif p-4==s:b="Condor"
elif p-3==s:b="Albatross"
elif p-2==s:b="Eagle"
elif p-1==s:b="Birdie"
elif p==s:b="Par"
elif p+1==s:b=a
elif p+2==s:b="Double "+a
elif p+3==s:b="Triple "+a
else:b="Haha you loser"
print b

Ungolfed/explained:
score = int(input())
par = int(input)
foo = "Bogey" # a shortcut for 3 of the outputs
if score == 1:
    output = "Hole in one"
elif par - 4 == score:
    output = "Condor"
...
elif par == score:
    output = "Par"
elif par + 1 == score:
    output = foo # See what I mean?
elif par + 2 == score:
    output = "Double " + foo # Huh? Huh?
elif par + 3 == score:
    output = "Triple " + foo # That makes 3.
else:
    output = "Haha you loser"
print output # Make sense?

My second answer, ironically both are in Python. Golfing tips appreciated!

Hint: you don't even need b.

I'm going to edit, just nrn.

Have a look at this.

Also, I thought Python 2 casts your input to int automatically.

Python 2, 302 284 bytes
i=input();j=input()
if j==1:print"Hole in one"
if(j==i-4)&(i>5):print"Condor"
if(j==i-3)&(i>4):print"Albatross"
if(j==i-2)&(i>3):print"Eagle"
if j==i-1:print"Birdie"
if j==i:print"Par"
if j>i:
 k=j-i
 if k<4:
  print["","Double ","Triple "][k-1]+"Bogey"
 else:
  print"Haha you loser"

If leading white space was allowed, that'd be 282 bytes:
i=input();j=input()
if j==1:print"Hole in one"
if(j==i-4)&(i>5):print"Condor"
if(j==i-3)&(i>4):print"Albatross"
if(j==i-2)&(i>3):print"Eagle"
if j==i-1:print"Birdie"
if j==i:print"Par"
if j>i:
 k=j-i
 if k<4:
  print["","Double","Triple"][k-1],"Bogey"
 else:
  print"Haha you loser"

The use of a string array would seriously help you here.

Agreed, this seemed really unoptimized.  Any combination of terms/results would shorten the answer.

Why do you need raw_input()? Can't you just use input()?

@ricdesi I combined the bogeys.

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


text:
The XOROR sequence
Cellular Automata are truly fascinating. The ones that are usually talked about are the binary ones, i.e., the ones representable by a number. However, those, in my opinion, have been done to death. Ternary CAs are more interesting, but we have all of ASCII to consider! What fun could that be!
Instead of deciding a ruleset for each character, I will use a simple deciding rule which I will talk about soon. To decide the next generation, we look at the three "top" cells, much like a cellular automata. Observe an example:
QWERTY
X Y Z

The "top" of Y is WER, being the cells above-and-right, above, and above-and left. Y will be the result of the function I'm about to define, which is a function on three-char strings. The "top" of X is  QW, or a space filling in the non-existent/missing cell.
Now, for the fun function! I call this sequence the XOROR sequence for a reason. Let A be the top-left cell charcode, B be the above cell charcode, and C be the top-right cell charcode. Then, the resulting cell is the character whose charcode is (A XOR B) OR C, that is, (A^B)|C. (If a resulting value is greater than 126, then it is set to (CHARCODE % 127) + 32. Nothing is done if a value is less than 32.) Here is an example of the seed Hello, World!:
S: Hello, World!
0: mmmo/c_ z}~)e
   m = ( )^(H)|(e) = (32^72)|101 = 104|101 = 109 (m)
    m = (H)^(e)|(l) = (72^101)|108 = 45|108 = 109 (m)
    etc.
1: mmo/c_<   +wl
2: mo/c_<c< + |;
3: o/c_<c  ?+  g
4: oc_<c c??4+gg
5: 0_<c c  4+ o
6: _<c ccc4??ooo
7:  c ccc4 ?o o
8: ccccc4w? pooo
9: cccc4w h   o
A: ccc4wc hh ooo
B: cc4wc4kh ooo
C: c4wc4  #ooo o
D: wwc4w4#ooo oo
E: wc4wwc oo oo
F: w4wwc4oo oo o
G: wwwc4   oo oo
H: wwc4w4 oo oo
I: w4wwc4oooo oo
J: wwwc4  oo oo
K: wwc4w4oo oo o
L: wc4wwo  oo oo
M: w4wwo8ooo oo
N: wwwo8  o oo o
O: wwo8w8oooo oo

And we can proceed on for a while hereafter. This modification of the string is called the XOROR sequence.
Objective You are to write a program or function that does one of the following tasks:

Given a string s and a number n >= 0, output the nth string on the XOROR sequence with seed s, with n = 0 being the first transformation of the string.
Given a string s, output (for programs) or generate (for functions/generators) an infinite stream of the XOROR sequence with seed s. You may choose to stop if the sequence repeats, but this is not necessary.

s will always only consist of printable ASCII characters, from space to tilde plus tabs (no newlines.)
This is a code-golf, so the shortest program in bytes wins.

I'm having trouble parsing the sentence "So, whatever function I am about to define on a three-char string, Y will become." Could this be reworded: "Y will be the result of the function I'm about to define, a function on three-char strings."?

All of the os make it look like a zerg rush.

@hYPotenuser Yes! I will do so.

Observation: Since XOR and OR preserve the number of bits and all ASCII is 7 bits, the only case when a CHARCODE is > 126 is if it is 127. Therefor, you can just replace it with a space (32) since 127%127+32==32.

Why is n=0 not the original string?

@Neil I don't know. It was rather arbitrary.

I think for 5 the output is o_<c c  4+ o

@CᴏɴᴏʀO'Bʀɪᴇɴ The example cases are broken from step 0. The final result of (d^!|NULL) should be (69 or E) not (101 or e).

@CᴏɴᴏʀO'Bʀɪᴇɴ The charcode part is ambiguous. Do you do (CHAR%127)+32 on (A^B)|C or on eachindividual cell A, B and C?

@FatalSleep As for you first complaint, I stated that, if no cell is present, the result is a space, so it would rather be (d^!)|(space). As for you second question, you perform (CHAR%127)+32 after the XOROR is performed.

Oh whoops! Thank you for the re-clarification.

@FatalSleep It's truly my pleasure :)

@StewieGriffin I'll pretend as if you didn't say your first reason, and move on to the second. "Better safe than sorry" is the main reason I protected it. (and I think you can edit comments.)

MATL, 33 31 bytes
Q:"32XKhKwh3YCPo2$1Z}Z~Z|127KYX

This works in release 13.1.0 of the language/compiler, which predates the challenge.
The first input is the number, the second is the string.
Try it online!
Q           % take input (number) implicitly and add 1
:"          % repeat that many times
  32XK      %   push 32 (space). Copy to clipboard K.
  h         %   concatenate. Takes input (string) implicitly the first time
  Kwh       %   push space, swap, concatenate
  3YC       %   overlapping blocks of length 3 as columns of 2D array
  P         %   flip upside-down
  o         %   convert to numbers
  2$1Z}     %   separate the three rows and push them
  Z~        %   bitwise XOR (note the rows are in reverse order)
  Z|        %   bitwise OR
  127KYX    %   replace 127 by space using regexprep, which converts to char
            % end loop
            % implicitly display

Mathematica, 133 bytes
FromCharacterCode@Nest[BlockMap[If[#>126,#~Mod~127+32,#]&[BitXor[#,#2]~BitOr~#3]&@@#&,ArrayPad[#,1,32],3,1]&,ToCharacterCode@#,#2+1]&

It would be nice to make a CellularAutomaton[] solution work, but I kept coming up short. Anyone?
Edit: some pretty pictures (click to enlarge)
plotCA[str_, n_] := ArrayPlot[NestList[foo[str],n], ColorFunction -> "Rainbow"]

plotCA["Hello, World!", 60]:

plotCA[bXORnotb, 100]:

plotCA[raven, 100]:

Can't you just give CellularAutomaton your update function? (The actual rule number with 127 valid states would be insane.)

@MartinBüttner You can, but it's a drag trying to account for the behavior at the edges, to get it to be compliant with the spec. BlockMap[] was just shorter.

Java, 193 185 bytes
Because Java.

-8 bytes by switching to looping rather than recursing to make it an anonymous function

Returns the n'th iteration of XOROR on s.
(s,n)->{String o=s;for(;n-->=0;){o="";for(int i=0;i<s.length();i++){char c=(char)((i>1?s.charAt(i-1):' ')^s.charAt(i)|(i<s.length()-1?s.charAt(i+1):' '));o+=c>126?' ':c;}s=o;}return o;}

Readable version:
static BiFunction<String, Integer, String> f = (s,n)->{
    String o=s;
    for(;n-->=0;) {
        o = "";
        for (int i=0;i<s.length();i++) {
            char c=(char)((i>1?s.charAt(i-1):' ')^s.charAt(i)|(i<s.length()-1?s.charAt(i+1):' '));
            o+=c>126?' ':c;
        }
        s=o;
    }
    return o;
};

public static void main(String[]a) {
    System.out.println(f.apply("Hello, World",1));
}

Pretty much a literal implementation of the spec, with a recursive loop to apply the operation n times. Some bytes were saved, however, with my observation that the CHARCODE>126 clause will only ever happen with CHARCODE==127, which results in saving SPACE instead of DEL.
I ran my code over a few arbitrarily chosen strings and found this wonderful cycle:
oook$ok$ok$ok$
ook$ok$ok$ok$o
oo$ok$ok$ok$ok
oook$ok$ok$ok$

This answer looks ok!

http://esolangs.org/wiki/ook!

Haskell, 123 bytes
import Data.Bits
f s=toEnum.a<$>zipWith3(((.|.).).xor)(32:s)s(tail s++[32])
a x|x>126=32|1<2=x
tail.iterate(f.map fromEnum)

This returns an infinite stream of the XOROR sequence. Usage example (print the first 5 elements of the seed "Hello, World!"):
*Main> mapM_ print $ take 5 $ (tail.iterate(f.map fromEnum)) "Hello, World!"
"mmmo/c_ z}~)e"
"mmo/c_<   +wl"
"mo/c_<c< + |;"
"o/c_<c  ?+  g"
"oc_<c c??4+gg"

How it works:
tail.iterate(f.map fromEnum)               -- repeat forever: convert to ASCII
                                           -- value and call f, discard the first
                                           -- element (the seed).

                                           -- one iteration is:
  zipWith3(   )(32:s) s (tail s++[32])     -- zip the elements from the three lists
                                           -- (space:s), s and tail of s ++ space,
                                           -- e.g. s = "Hello!":
                                           --   | Hello|
                                           --   |Hello!|
                                           --   |ello! |
                                           -- (shortest list cuts off)

         ((.|.).).xor                      -- the function to zip with is a
                                           -- point-free version of (x xor y) or z

toEnum.a<$>                                -- adjust every element >126 and convert
                                           -- back to characters

CJam, 38 bytes
lri){2S*\*3ew{)\:^|_'~>{i127%' +}&}%}*

Test it here.
Explanation
l                e# Read string.
ri               e# Read n.
){               e# Run this block n+1 times...
  2S*\*          e#   Wrap in two spaces.
  3ew            e#   Get all (overlapping) substrings of length 3.
  {              e#   Map this block over all those substrings...
    )\           e#     Pull off the third character and put it below the other two.
    :^           e#     Take XOR of the other two.
    |            e#     OR with the third one.
    _'~>         e#     Duplicate and check if it's greater than '~'.
    {i127%' +}&  e#     If so, mod 127, add to space.
  }%
}*

I think you can save a few bytes with lri){2S*\*3ew{)\:^|}%127c' er}* because the chars pre-modulo operation never exceed 127

Perl, 47 bytes
Includes +2 for -lp
Run with the input on STDIN, e.g. perl -lp xoror.pl <<< "Hello, World!" | head -26
xoror.pl:
/./s;$_=$_.chop^" $_"|"$' ";y/\x7f/ /;print;redo

This works as is, but replace the \x7f by the corresponding binary value to get the given score

PHP, 186 bytes (with n) | 177 bytes (infinite)
It turned out that infinite printing is shorter...
// With n
function x($s,$n){while($n-->=0){for($i=0,$r='';$i<strlen($s);$i++){$b=ord($s[$i-1])or$b=32;$a=ord($s[$i+1])or$a=32;$t=($b^ord($s[$i]))|$a;$r.=chr($t>126?($t%127)+32:$t);}$s=$r;}echo$s;}

// Infinite
function i($s){while(true){for($i=0,$r='';$i<strlen($s);$i++){$b=ord($s[$i-1])or$b=32;$a=ord($s[$i+1])or$a=32;$t=($b^ord($s[$i]))|$a;$r.=chr($t>126?($t%127)+32:$t);}echo$s=$r;}}

Ungolfed with n:
function x($s, $n) { // $s - string to process; $n - which string to output
  while ($n-- >= 0) {
    for ($i = 0, $r = ''; $i < strlen($s); $i++) {
      $b = ord($s[$i - 1]) or $b = 32;
      $a = ord($s[$i + 1]) or $a = 32;
      $t = ($b ^ ord($s[$i])) | $a;
      $r .= chr($t > 126 ? ($t % 127) + 32 : $t);
    }
  $s = $r;
  }
  echo $s;
}

Ungolfed infinite:
function x($s) { // $s - string to process
  while (true) {
    for ($i = 0, $r = ''; $i < strlen($s); $i++) {
      $b = ord($s[$i - 1]) or $b = 32;
      $a = ord($s[$i + 1]) or $a = 32;
      $t = ($b ^ ord($s[$i])) | $a;
      $r .= chr($t > 126 ? ($t % 127) + 32 : $t);
    }
    echo $s = $r;
  }
}

It can still be golfed a lot. For instance, function i($s){for(;;$i=0,print$s=$r)for($r='';$i<strlen($s);$r.=chr($t>126?32:$t))$t=((ord($s[$i-1])?:32)^ord($s[$i]))|(ord($s[++$i])?:32);} is 141 bytes long (-36 bytes).

C++
Nth-Sequence (212)
void x(char*s,int l,int n){for (;n-->0;) {char*t=new char[l-1](),w;for(int i=0;i<l-1;i++)t[i]=((w=(((i-1>= 0)?s[i-1]:32)^s[i])|((i+1<l-1)?s[i+1]:32))>126)?((w%127)+32):w;for(int i=0;i<l-1;i++)s[i]=t[i];delete[]t;}}

Un-Golfed
void x(char*s, int l, int n){
    for (;n-- > 0;) {
        char*t=new char[l-1](),w;
        for(int i = 0;i < l-1; i++)
            t[i] = ((w = (((i-1>= 0) ? s[i-1] : 32)^s[i]) | ((i+1 < l-1) ? s[i+1] : 32)) > 126) ? ((w % 127) + 32) : w;

        for(int i = 0; i < l-1; i++)
            s[i] = t[i];
        delete[]t;
    }
}

Nth-Sequence using pointer syntax instead of array syntax to make this all the more confusing: (231)
void x(char*s,int l,int n){for(int x=0;x++<n;) {char*t=new char[l-1](),w;for(int i=0;i<l-1; i++)*(t+i)=((w=(((i-1>= 0)?*(s+i-1):32)^*(s+i))|((i+1<l-1)?*(s+i+1):32))>126)?((w%127)+32):w;for(int i=0;i<l-1;i++)*(s+i)=*(t+i);delete[]t;}}

Un-Golfed
void x(char* s, int l, int n){
    for (;n-- > 0;) {
        char*t = new char[l-1](),w;
        for(int i = 0; i < l-1; i++)
            *(t+i) = ((w = (((i-1>= 0) ? *(s+i-1) : 32)^ *(s+i)) | ((i+1<l-1) ? *(s+i+1) : 32)) > 126) ? ((w%127)+32) : w;

        for(int i = 0;i < l-1; i++)
            s[i] = t[i];
        delete[]t;
    }
}

Debug Function (For Fun)
void d(char* seed, int len, int nth) {
    for (int n = 0; n++ < nth;) {
        char* tout = new char[len - 1]();
        for (int i = 0; i < len - 1; i++) {
            char x, y, z;
            x = ((--i >= 0) ? seed[i] : 32);
            y = seed[++i];
            z = ((++i < len - 1) ? seed[i] : 32);
            char w = (x ^ y) | z;
            tout[--i] = (w > 126) ? ((w % 127) + 32) : w;

            cout << "[" << x << " " << y << " " << z << "] " << w << endl;
        }

        for (int i = 0; i < len - 1; i++)
            seed[i] = tout[i];
        delete[] tout;
        cout << endl;
    }
}

Pretty sure the results say you must output the result, not simply return it.

I wrote a C++ version from scratch, compared to yours and then merged them, and got this, at 158 bytes: http://coliru.stacked-crooked.com/a/838c29e5d496d2a6

@MooingDuck Nice! Could probably reduce it further with implicit int by the compiler via moving to C.

of course, go ahead! You already wrote half of that code

JAVA
240/280 Bytes
The popular Java version at the time I wrote this claimed to be 185 bytes, but there are two significant fudge points. First, the measurement is presumably only for the function, not for the complete working source. Maybe not such a problem. Second, it uses BiFunction without either an import or a fully qualified name. Adding the required bits to run it as-is (then minimizing it, fairly) brought it to 348 bytes. Adding only the fully qualified name of the BiFunction class brings it to 248 bytes.
In contrast, I believe mine is 240 bytes when playing by the same rules (no class, no actual output, just the meat). The full runnable class is 280 bytes, and looks like this (unminified):
class z{
  public static void main(String[] s){
    int L=s[0].length();
    for(int G=Integer.valueOf(s[1]);G-->0;){
      s[1]="";
      for(int N=0;N<L;N++){
        char C=(char)((N>0?s[0].charAt(N-1):' ')^(s[0].charAt(N))|(N<L-1?s[0].charAt(N+1):' '));
        s[1]+=C>126?' ':C;
      }
      System.out.println(s[1]);
      s[0] =s[1];
    }
  }
}

Or, minified:
void m(String[] s){int L=s[0].length();for(int G=Integer.valueOf(s[1]);G-->0;){s[1]="";for(int N=0;N<L;N++){char C=(char)((N>0?s[0].charAt(N-1):' ')^(s[0].charAt(N))|(N<L-1?s[0].charAt(N+1):' '));s[1]+=C>126?' ':C;}s[0]=s[1];}return s[0];}

Swift: 273 Characters
Wow, Swift is worse than Java! (All those APIs with long names! :P)
func c(s:String,n:Int=0-1){var a=[UInt8](s.utf8);for i in 0...(n>=0 ?n:Int.max-1){var z="";for i in 0..<a.count{let A=i-1<0 ?32:a[i-1],B=a[i],C=i+1<a.count ?a[i+1]:32;var r=A^B|C;r=r<32 ?32:r>126 ?32:r;z+=String(UnicodeScalar(r))};if n<0||i==n{print(z)};a=[UInt8](z.utf8)}}

Ungolfed:
func cellularAutoma(s: String,n: Int = -1)
{
    var array = [UInt8](s.utf8)
    for i in 0...(n >= 0 ? n : Int.max - 1)
    {
        var iteration = ""
        for i in 0..<array.count
        {
            let A = i - 1 < 0 ? 32 : array[i - 1], B = array[i], C = i + 1 < array.count ? array[i + 1] : 32
            var r = A ^ B | C
            r = r < 32 ? 32 : r > 126 ? 32 : r
            iteration += String(UnicodeScalar(r))
        }
        if n < 0 || i == n
        {
            print(iteration)
        }
        array=[UInt8](iteration.utf8)
    }
}

Thanks to @CAD97 for mentioning that (A^B)|C can only be greater than 126 when it's 127.
I also realized that you don't need parenthesis around A^B|C because XORing is done before ORing, so that saved me a few bytes.

Vyxal, 23 bytes
(ðpǏ3lƛC÷∇꘍⋎:₇⇩>[32];C∑

Try it Online!
(                       # N times..
 ðpǏ                    # Enclose in spaces
    3l                  # Get overlapping substrings of length 3
      ƛ             ;   # Map...
       C÷               # Iterate out charcodes
         ∇꘍⋎            # XOROR
            :₇⇩>[  ]    # If greater than 126
                 32     # Push 32
                     C∑ # Stringify and concatenate

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


text:
Cycles in run-length encoding
Consider some binary sequence, using 1 and 2, e.g.:
1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 1 ...

Let's write down the run lengths of that:
1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 1 ...
_  _  ____  ____  _  _  _  ____
1, 1, 2,    2,    1, 1, 1, 2,   ...

In this case we happen to get another binary sequence. Of course, that's not guaranteed (e.g. if we repeated the process, the third run would be 3), but let's assume we do.
Now the question is, can we find a sequence such that applying this type of run-length encoding multiple times gives us back the original sequence? For a cycle-length of 1 (i.e. a fixed point of this transformation), we find the Oldenburger-Kolakoski sequence (OEIS entry A0000002):
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, ...

(There is actually another solution: we can also omit the leading 1.)
What about a cycle of length-2? That's also possible! The following two sequences are each others' list of run lengths:
1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, ...
2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, ...

(These are OEIS entries A025142 and A025143. This is the only solution.)
Can we find a cycle of length 3? Sure, here each sequence is the run-length encoding of the next (and the third one is the run-length encoding of the first):
1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, ...
1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, ...
2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, ...

In this case there is one other solution. It turns out that we can find such a cycle for every cycle length. In fact, the number of distinct cycles of length n is given by OEIS entry A001037 (this is not counting the arbitrary choice of which sequence in a cycle is considered the first).
Fun fact: As unlikely as it seems, this challenge was inspired by studying the complex map f(z) = z - 1/z. Whoever figures out what that map has to do with this challenge gets a cookie.
The Challenge
Given a cycle length k > 0 and a sequence length n > 0, output the first n terms of k distinct (infinite) binary sequences that form a cycle under the above run-length transformation. If multiple cycles exist, you may output any one of them. It's up to you which sequence in the cycle to start with, and which direction the cycle goes (so you can either output them such that each sequence describes the next, or such that each sequence describes the previous one, cyclically).
You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.
Output may be in any convenient, unambiguous, nested list format, such that the the outer dimension is k and the inner dimension is n.
Standard code-golf rules apply.
Additional examples
Here are some examples. But as I said, the solutions are not unique, so your own solutions might differ and still be correct. Maybe these will help you come up with a solution though. Each example is k n followed by the sequences, such that each line describes the next (cyclically):
4 20
1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2
2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1
2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1
1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1

5 6
2, 2, 1, 2, 2, 1
1, 1, 2, 2, 1, 2
2, 1, 2, 2, 1, 1
1, 1, 2, 1, 1, 2
2, 1, 2, 2, 1, 2

8 20
2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2
1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1
2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2
2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2
1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1
2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2
1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1
2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1

13 50
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2
2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1
1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1
1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1
1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1
1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 2
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1
1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1

Note that not all of the lines in the last two outputs differ, although they would eventually if n was large enough.
Related Questions

Generate a Kolakoski sequence

Can we output a list of generators?

@CatsAreFluffy Nope, sorry. (Maybe next time...)

CJam (41 bytes)
{Ma*{1:Bm<{1+ee{(1&B^)+}%e~A<0:B;}%}@:A*}

This is an anonymous function which takes input on the stack in the order n k and leaves output on the stack. Online demo
The basic idea is to start with a Lyndon word column [2 1 1 1 ...] and iteratively extend right on the basis that knowing the initial element of each row and the alternation we can run-length decode and get more elements.

Haskell, 72 bytes
~(a:b)?c=c:[c|a>1]++b?(3-c)
k!n=take k$take n<$>last(k!n)?2:map(?1)(k!n)

Demo:
*Main> 4!20
[[2,1,1,2,2,1,2,2,1,2,1,1,2,1,1,2,2,1,2,1],[1,1,2,1,2,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1],[1,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2],[1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,1,2,2]]

Nice work, finally! :) Would you mind adding an explanation for those who don't Haskell? :)

@MartinEnder Explained here.

APL (Dyalog Unicode), 35 bytes
{(⍺↑¨⊣{⍵/(≢⍵)⍴⍺,3-⍺}¨¯1⌽⊢)⍣≡⍨1+⍵↑1}

Try it online!
An anonymous dfn whose left argument is n and right is k.
Almost direct translation of Anders Kaseorg's Haskell answer (adapted to the finite and strict nature of APL arrays), with a bit of hint from Peter Taylor's idea:

The basic idea is to start with a Lyndon word column [2 1 1 1 ...] and iteratively extend right on the basis that knowing the initial element of each row and the alternation we can run-length decode and get more elements.

How it works
{(⍺↑¨⊣{⍵/(≢⍵)⍴⍺,3-⍺}¨¯1⌽⊢)⍣≡⍨1+⍵↑1}  ⍝ left argument(⍺)←n, right(⍵)←k
                             1+⍵↑1   ⍝ u←[2, 1, ..., 1] of length k
                            ⍨        ⍝ Run the following with both sides being u:
 (                       )⍣≡         ⍝  Repeat until fixpoint:
                                     ⍝  (left: u, right: intermediate result v)
                     ¯1⌽⊢            ⍝   Rotate v down once
     ⊣{            }¨                ⍝   Zip with left side u: (left elem u_i, right elem v_i)
              ⍺,3-⍺                  ⍝    Make a 2-elem array [u_i, 3-u_i] which is [1 2] or [2 1]
         (≢⍵)⍴                       ⍝    Cycle the above to the length of v_i
       ⍵/                            ⍝    Duplicate each element of above v_i times e.g. 1 1 2/2 1 2 → 2 1 2 2
       ⍵/(≢⍵)⍴⍺,3-⍺                  ⍝    Run-length decode v_i with alternating 1 and 2's, starting with u_i
  ⍺↑¨                                ⍝   Extend or truncate each row to length n

Comparison with Anders' Haskell version
Anders' Haskell code (parenthesized for clarity) works like this:
~(a:b)?c=(c:[c|a>1])++(b?(3-c))
  (c:[c|a>1])  -- Two copies of c if head of x > 1, one copy otherwise
  ++(b?(3-c))  -- Run-length decode the rest with alternating 1 and 2

k!n=take k$take n<$>((last(k!n))?2):(map(?1)(k!n))
  take k$         -- take first k rows
  take n<$>       -- take first n elements from each row
  ((last(k!n))?2) -- run-length decode the last row with starting value 2
  :(map(?1)(k!n)) -- run-length decode the other rows with starting value 1

In one iteration, this is equivalent to "prepend the k-th row, run-length decode each row, and then discard the last row". We can simplify it to "rotate once and run-length decode", which I implemented as ¯1⌽.
For the run-length decoding function, I simply used the APL primitive /, while the Haskell version uses infinite lists to implement it.

05AB1E, 22 bytes
YΔ´12¹иćRšvyÞsÅΓI∍Dˆ]¯

Try it online!