Counting icons for Innovation splays
CJam, 44 37 36 bytes

Thanks to Sp3000 for reminding me that I'm overcomplicating things and saving 7 bytes.

rci7%"3&gt;0&lt;2&lt;1&gt;"2/=6,slS%{W$~+}*fe=p;


Test it here.

Explanation

Some observations:


We always want to count the entire first card.
All splays will result in either a prefix or a suffix of the icons removed. ! removes all of them (which is either a prefix or a suffix of four characters), &lt; removes the first three characters, &gt; removes the last two characters, ^ removes the first character.


So all we need is a short way to map the splay mode to the correct truncation:

rci   e# Read the splay mode and convert to its character code.
7%    e# Take modulo 7. This maps "&lt;!&gt;^" to [4 5 6 3], respectively. Modulo 4 those are
      e# are all distinct (namely [0 1 2 3], respectively).
"3&gt;0&lt;2&lt;1&gt;"
      e# Push this string.
2/    e# Split it into chunks of 2, ["3&gt;" "0&lt;" "2&lt;" "1&gt;"]. Each chunk is CJam code which
      e# performs one of the truncations.
=     e# Select the correct snippet. This works, because array indexing is cyclic in CJam.
6,s   e# Push the string "012345".
lS%   e# Read the remainder of the input and split into space-separated tokens.
{     e# Now we're abusing the fold operation to apply our snippet to every card except
      e# the first, while also combining them all back into a single string.
  W%  e#   Copy the bottom of the stack (the truncation snippet).
  ~   e#   Evaluate it.
  +   e#   Append it the string we're building.
}*
fe=   e# For each character in "012345", count the occurrences in our new string.
p     e# Pretty-print the array.
;     e# Discard the truncation snippet which was still at the bottom of the stack.


We can notice that the truncation snippets actually have a lot of structure. Each splay mode maps to one number in [0 1 2 3] (specifically, in order "!^&gt;&lt;"), and two of them have &gt; and two have &lt;. I was hoping to find two hashes which magically produce these parts separately, as that would save a bunch of bytes, but so far I wasn't able to find anything. I can map "!^&gt;&lt;" to numbers of alternating parity with 31% (to select the correct character from "&lt;&gt;"), but I haven't found anything which neatly maps them [0 1 2 3] in that order. (Except the naive solution of "!^&gt;&lt;"# which unfortunately doesn't save any bytes.)

Also note that it's actually a bit more flexible. ! can also be implemented as n&gt; for any n &gt; 3 (discarding everything as a prefix). Unfortunately, I haven't been able to find any simple function for such a map either.