[Question]
  [
Each day you put up a new word on a [marquee sign with movable letters](https://i0.wp.com/thecachevenue.com/wp-content/uploads/2017/10/marquee_sign_1.jpg?fit=800%2C800&ssl=1), buying just the letters you need to write it. You re-use letters you've bought for earlier words whenever possible. Given the words you want to write each day in order, output the letters you buy each day.
> 
> **Example**
> 
> 
> 
> ```
> Input:  ['ONE', 'TWO', 'THREE', 'SEVENTEEN']
> Output: ['ENO', 'TW', 'EHR', 'EENSV']
> 
> ```
> 
> **Day 1:** You start with no letters, so to write `ONE`, you buy all its
>  letters `E`, `N`, `O`.  
> 
> **Day 2:** The next day, you want to put up `TWO`
>  (taking down the `ONE`). You already have an `O` from `ONE`, so you
>  buy an additional `TW`.  
> 
> **Day 3:** At this point, you have `ENOWT`. To write 
>  `THREE`, you need `EHR`. Note that you need to buy a second `E` in
>  addition to the one you have.  
> 
> **Day 4:** To write `SEVENTEEN`, you need 4
>  `E`'s total of which you already have two (not three!), so you buy two more.
>  You also have the `T` and one of the `N`'s, so you buy the remaining letters:
>  `EENSV`.
> 
> 
> We've output letters sorted alphabetically in this example, but you may
>  output them in any order.
> 
> 
> 
**Input:** A non-empty list of non-empty strings of letters `A-Z`. You may use lowercase if you prefer. Lists of characters are fine for strings.
**Output:** Output or print the additional letters you need to buy each day. The letters for a day may be output in any order, but the days must come in the right order. 
The letters from each day should be separated from other days so you can tell where a day ends. A trailing and/or leading separator is fine, both within a day or between days. Note that a day may have no letters bought, which should be reflected in the output (a space or empty line is OK, even for the last day).
**Test cases**
```
['ONE', 'TWO', 'THREE', 'SEVENTEEN']
['ENO', 'TW', 'EHR', 'EENSV']
['ONE', 'TWO', 'ONE', 'THREE']
['ENO', 'TW', '', 'EHR']
['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']
['ABC', 'A', 'B', 'C', '']
['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']
['HORST', 'GLNO', 'OO', 'OOO', '', '']
```
Here are all the inputs and outputs as separate lists:
```
[['ONE', 'TWO', 'THREE', 'SEVENTEEN'], ['ONE', 'TWO', 'ONE', 'THREE'], ['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC'], ['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']]
[['ENO', 'TW', 'EHR', 'EENSV'], ['ENO', 'TW', '', 'EHR'], ['ABC', 'A', 'B', 'C', ''], ['HORST', 'GLNO', 'OO', 'OOO', '', '']]
```
And as space-separated strings (the trailing spaces in the outputs matter):
```
ONE TWO THREE SEVENTEEN
ONE TWO ONE THREE
ABC AABC ABBC ABCC AABBCC
SHORT LOONG LOOOONG LOOOOOOONG SHORT LOOONG
ENO TW EHR EENSV
ENO TW  EHR
ABC A B C 
HORST GLNO OO OOO  
```
**Leaderboards**
```
var QUESTION_ID=183544,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
## Haskell, ~~54~~ 49 bytes
```
import Data.List
g x=zipWith(\\)x$scanl(++)""$g x
```
[Try it online!](https://tio.run/##bYqxCoMwGIR3n@InOCiKb@CgNtTBJqBSB5USStFQtUEzSF8@bcSUFjrd3Xdfz5b7bRiU4qN4zBIOTLIg44u0OljDJxcVl73TNO5qL1c2DY7nuQjZ71ONjE8QwsjE6QKOmPkkIYDOhdoCqBElGPmAyopukeZ42wU@Y1JiTFDr//HM2vTdiOJEs8hkbDIxXLddLlKalxpnlJLjXn7qZ32rGrWtegE "Haskell – Try It Online")
We build the output list by calculating pairwise the list difference (`\\`) of the input list and the cumulative append of the output list (starting with `""`).
```
input list:                ONE       TWO       THREE        SEVENTEEN
cumulative append:         ""   +->  ONE  +->  ONETW   +->  ONETWHRE
list difference (output):  ONE -+    TW  -+    HRE    -+    SVEEN
```
With both `Data.List` and `Data.Function` in scope (e.g. by using the lambdabot environment), this can be shortened to 30 bytes:
```
fix.(.scanl(++)"").zipWith(\\)
```
Edit: -5 bytes thanks to @Sriotchilism O'Zaic.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~72~~ 68 bytes
-4 bytes thanks to Jonathan Allan.
```
p=''
for r in input():
 for x in p:r=r.replace(x,'',1)
 print r;p+=r
```
[Try it online!](https://tio.run/##XY7BasJAEIbv@xRDLqM0EerRkkMMox7KLpilLRQPNt1iUJJlWDE@fZpJTWmFhf@fb78d1l/DoannXdl8OkiBoyjqfIqovhoGhqrujz@HyXShQFAryC845Rk7f9qXbtLGiPHjVIHnqg7AT/4h5a5fpNTlUJ0cWD67/jkEvkrATcQkSUDTmwVLhc2zgqAnOBiudSXIn5T00vkAZFbE3PDPig92@2P3jkYTxoD21Qyx2dIwF/RC2hJp3Kl7aZwGV66zZS4gG3M5Zj5yaWIWG7O1wp6N0etb@Vd/p7@qoN03 "Python 2 – Try It Online")
## Commented
```
l=input()       # the list of words to write
p=''            # p contains all letters we own
for r in l:     # for each word ...
  for x in p:   # for each letter we own ...
    r=r.replace(x,'',1)   # remove one occurence from the current word
  print r       # print the remaining word
  p+=r          # add the remaining chars to p
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
,œ-@Kɗ/
```
[Try it online!](https://tio.run/##y0rNyan8/1/n6GRdB@@T0/X///8frR7s4R8Uoq6joO7j7@/nDmWgMOE8ZKUgoVgA "Jelly – Try It Online")
Output: -separated string.
[Answer]
# [Haskell](https://www.haskell.org/), 44 bytes
```
import Data.List
foldl1(\a x->a++',':(x\\a))
```
[Try it online!](https://tio.run/##RYnNCoJAFEb3PcVFAhVNaBsYqA25sBnQoRYZccEkyT90It9@ciawzTn3u@eJ4@tR11JWTd8NAg4o0EuqUaxKv@zqot5aOcK02aPjmK65s6Y8R9uWDVYt@NBgf7qD1b9FJoak9Urv0w3FaMMargajBPiFAY9TQiAjZ0I5IdRwYUnaKqtnEEYQaIQakZ6zVMxilnJIGKNHxb9/55LnYdzkFw "Haskell – Try It Online")
Output is a string like `ONE,TW,HRE,SVEEN` with commas between days.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 59 bytes
```
a=>a.map(h=>([...t].map(c=>h=h.replace(c,'')),t+=h,h),t='')
```
[Try it online!](https://tio.run/##fYzRCoIwGIXve4ruNmntDSaojLyIDVTqQrwYa7bCnKj0@suNFgXS1Xe@n3P@u3iKSY63Yd735qJsS6wgscAPMUBNYlhjjOfGqySxJhqPauiEVFAiAKIIzTuikV5IFrXS9JPpFO7MFbawBpxRgLagOnOPvKDeS3qirKKUgSaKNv9Hwfx2rZ6kmSskgWlgFu4urS3LnBeV6xw5Z4d3@Ikf@6660/LOvgA "JavaScript (Node.js) – Try It Online")
Quite straightforward solution. For each word `h`, remove letters we already have.
Here is an explained version of that code:
```
f = list => {
  // the string that accumulates all the letters already bought
  let accu = '';
  // for every word in the list
  return list.map( word => {
    // for every letter already bought 
    [...accu]
      // remove the letter from the word
      .map(char => {
        return word = word.replace(char,'')
      });
    // add not bought letters to accumulator
    accu += word;
    // the reduced word (without already bought letters) should be added to result map
    // this represents the letters to buy today
    return word
  }, accu)
}
console.log(f(['ONE', 'TWO', 'THREE', 'SEVENTEEN']))
console.log(f(['ONE', 'TWO', 'ONE', 'THREE']))
console.log(f(['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']))
console.log(f(['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']))
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~44~~ 40 bytes
*-4 bytes thanks to Matthew Jensen*
```
{$!=@;.map:{kxxv $!=.comb∖($⊎=$!):}}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJZm@79aRdHWwVovN7HAqjq7oqJMAcjXS87PTXrUMU1D5VFXn62KoqZVbe1/a67ixEqFNIVodX8/V3UdBfWQcH8w5RHkCuYHu4a5@oW4uvqpx@JSC@OBtSCpcnRyBok7wmgnGO0MEwexkDQEe/j7B4WA5Hz8/f3coQwUJpwHVAtXChKKtf4PAA "Perl 6 – Try It Online")
Outputs as a list of lists of characters.
### Explanation
```
{                                  } # Anonymous codeblock
 $!=@;                               # Initialise $! to an empty list
      .map:{                      }  # Map each item in the input to
                    .comb            # The string split to characters
                                     # In a Bag
                         ∖           # Set minus
                          ($⊎=$!)    # The accumulated Bag of results
                 $!=                 # And save the result for the next item
            kxxv                 : # Then decompose the Bag into a list
```
[Answer]
# [J](http://jsoftware.com/), 29 bytes
*-29 bytes thanks to FrownyFrog!*
```
(],a.<@#~0>.-&(1#.a.=/;))/@|.
```
[Try it online!](https://tio.run/##bY9Ba4NAEIXv/opHA65CsiZXTUKibJNDUFBpT6XYzQRtU211Q3Mo@et23UIDobDzZubNfAz72t9xdsDCB8MYU/g6JhxRurvvnadxweer0WW65BPbmY14wRde4Lre6pv3rmXFIccXoWtahZdGlVAlgc4fJBXtUdQ6pDoVR7TUnY6qgyGquqv2NOxWrcbO1I3RVbUkNO2eWlRdzRQKDX2eqpbeqVaWJUuSbwsOZ@LbvuP5Fypk6eLg2s484M8z1156lkWybGBW9XdEnCB/hNimECLOHljAkMRCe9rfpkIgEw8izvWQ/UsOKAtwpUweyJv9dRhhjRARhhumMxIaiUyr0w21TdIsx2anjyXDS2DwTPs5dkkSbwa95t/yb6wb1v8A "J – Try It Online")
# Original Post
## [J](http://jsoftware.com/), 58 bytes
```
[:}.@>[:(],<@(/:~@({.@>@-.&(((e.<@#[){:)\));))&.>/<@a:,~|.
```
[Try it online!](https://tio.run/##bU1fa4MwHHz3UxwbmAQ0bq/RSqpk9UESUGkfbBlDLGV72Afon6/ufslghTJI7nJ3Oe5zeZLsiJUCQ4IXKLqpRN21b8uorlKXo@KHpNA8UzfNz2ToVMac81kW@nkUZyX2QuRCxLLMCv2hkttFLiKKptM8fa0keKpwFDEvcvn@KuIyi6J5On0j5LRqrMOwg2k6GGP7LcsZnDXkkd90xqA3W2MHCtm/TV9lOe6twL758H9d1VijQg2/EVSAKkAdJNFDq3FdP2DT0pjzxyHUe/IHtM7Zjcc7/z7/YhJs@QE "J – Try It Online")
*Thanks to ngn for help improving the "subtract letters while respecting repetition part".*
Not a great fit for J, but an illuminating exercise.
Let's begin by constructing a helper verb `wo` ("without") that removes all
chacters in one string from another, while respecting repetitions. 
```
wo=.{.@>@-.&(((e. <@# [) {:)\)
```
There is a fun idea here: We make each repeated instance of a character unique,
by repeating it the required number of times. Thus if our original
string is `ABBA` it becomes:
```
┌─┬─┬──┬──┐
│A│B│BB│AA│
└─┴─┴──┴──┘
```
A third `A` would become `AAA` and so on. This is accomplished by the phrase
`((e. <@# [) {:)\`, which takes each prefix `\`, looks at the final element
`{:` of it, and constructs a mask of all elements in that prefix that match
`e.` that final element, and then filters and boxes just those elements `<@#`. 
With our inputs both "unique-ified" we can now safely use normal set minus `-.`
while still respecting repetition.
We then open each result and take only the first element to "undo" our repetitions: `{.@>`
Plugging this helper verb in, our overall solution (which simply inlines it) becomes:
```
[: }.@> [: (] , <@(/:~@wo ;))&.>/ <@a: ,~ |.
```
Essentially, all we do here is setup our problem as a single reduction. We
start be reversing the input `|.` and appending to it `,~` an ace `a:`, or empty box,
which will be the initial value of our final result, like so:
```
┌─────────┬─────┬───┬───┬──┐
│SEVENTEEN│THREE│TWO│ONE│┌┐│
│         │     │   │   ││││
│         │     │   │   │└┘│
└─────────┴─────┴───┴───┴──┘
```
We stick the following verb between each element to effect the reduction:
```
(] , <@(/:~@wo ;))/
```
This says: take the right input `]` (ie, our result) and append to it `,` the
left input (this is `ONE` on the first iteration, `TWO` on the 2nd, etc)
without `wo` the raze of `;` the right input (ie, without any previous letters
so far used), but before appending sort it `/:~` and box it again `<@`.
At the end of all this we'll have the result we want, a list of boxes, but all inside
one big additional box, and still with the empty box at the front. Thus we open 
to remove the outer box and kill the first element: `}.@>`.
[Answer]
# JavaScript (ES6), ~~66~~ 65 bytes
```
a=>a.map(b=s=>[...s].filter(c=>x==(x=x.replace(c))?b+=c:0,x=b+0))
```
[Try it online!](https://tio.run/##fYxNC4IwHMbvfYpubljDc/A3VEYewoFKHcTDXDMMc@Ik/PbWJKNAOj0v/J7nxh9ci65q@22jLnIsYeTgcnLnLSpAg5sRQnROyqruZYcEuAMAGmAgnWxrLiQSGO8LG8TO2QxQ2A7Go1CNVrUktbqiEmUWi6i1WVvpmU0SxnTKCT3RKKU0snKMV/9Hc5q2S7jnBwbwZvVnDebeuKVlErI4NcyRsejwNj/2k75RU73uxic "JavaScript (Node.js) – Try It Online")
### Commented
\$b\$ is a string holding all available letters (and also some invalid characters, but this is irrelevant to the algorithm). For each new word, we create a copy of \$b\$ in \$x\$. Each letter \$c\$ of a word is either *used* by removing it from \$x\$ or *bought* by appending it to \$b\$. Only bought letters are returned.
```
a =>                      // a[] = input
  a.map(b =               // initialize b to the callback function of this map()
                          // it will be coerced to a string that does not contain
                          // any letter in uppercase
    s =>                  // for each entry s in a[]:
    [...s].filter(c =>    //   for each character c in s:
      x == (              //     check whether x is changed when
        x = x.replace(c)  //     c is replaced with 'undefined'
      ) ?                 //     if so:
        b += c            //       append c to b and keep c
      :                   //     else:
        0,                //       discard c
      x = b + 0           //     coerce b to a string and save it in x
    )                     //   end of filter()
  )                       // end of map()
```
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~177~~ 170 bytes
-5 bytes thanks to @anatolyg's tip, -2 bytes to small things I noticed.
```
#import<random>
#define v std::vector<std::string>
v a(v p){std::vector<int>o(91),b;int j=-1;for(auto i:p){b=o;p[++j]="";for(int c:i)--b[c]<0?p[j]+=c,++o[c]:0;}return p;}
```
Explanation
`#import<random>` adds both `<string>` and `<vector>` for half the bytes.
First creates a 91-element vector of 0s (only indices 65-90 are used to store letter occurences), and another vector of the same type but not set to a value. Iterates through each element of the input (the days): gets the currently owned letters, gets the letters that are needed for the day, overrides the input at the index with the needed amount and updates the owned letters. Returns the overridden input.
[Try it online!](https://tio.run/##XZAxb8IwEIVn8itOZkkUR4KxdkLVIVInkAqCATEY2yAjsC3jRK1Qfjs93A6lk@987z1/Z@l9dZTyfh@bi3ch1kFY5S6zbKz0wVgNPVyjYqzXMrpQp/oag7HHWdaDyHvwxe2vwtg4c/nLtKB7jjWcmmrKDy7koosODEP5vnHcb8vytGsISbOHUDJTVNV@K3f15NVvT7uykbQsHV6wCR@Cjl2w4PmAqFaeO6WhNg5ZtEDc7BFxEcbmBdyyUQ8RGriRxbwlFMhqs0jH@0eb@mW7buertp2TgWejhC9dF6GugbzJ2IkzAwCCM6SDH3QlvhguHIv0wLMJZ8lLk2f4F5kabdU5adpPjz@lFQOEo7DaUEAsCss18lDyZMCw370nPBvu3w "C++ (gcc) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 123 bytes
```
a=>{var b="";for(dynamic i=0,e,f;i<a.Count;b+=a[i++]=f)foreach(var c in((e,f)=(b.ToList(),"")).f+a[i])f+=e.Remove(c)?"":c;}
```
[Try it online!](https://tio.run/##bZBBa4QwEIXv/grJKUErPTfG4kroFkSLK93D4iGmSZvDRtB0SxF/u01Wy0rpJfPeyzcJM3y444OaU25Up@PnXA0mHkyv9HuSSDIzkowX1vstAQDLrodv35qdFfcVuQ9FKLGKWZR1n9rgNiDspIKgIRJZUjD@AV2rZTWElkUEtlHduS8gCgFAKJKBbWmQDIiIKnHuLgJy9AjAA8fTjD3XbsRgBp/4WnydGm/0/EWNoCwoCEF9LN25r6hzB/pKi5rSAkzh/@Sqr/yWSXeZzdO17NaSraETW/qwL6vaXuVlWTwtdat@zQZzgX1hwt52N244u55lSHSd7sXu3kAXIGytvMk/N8deGZErLaC10/wD "C# (Visual C# Interactive Compiler) – Try It Online")
Anonymous function that outputs by modifying an input array.
```
// a: input array of strings
a=>{
  // b: cumulative letters
  var b="";
  for(
    // i: loop index of string
    // e: copy of cumulative letters for manipulation
    // f: characters missing from current string
    dynamic i=0,e,f;
    // iterate over each string in a
    i<a.Count;
    // add missing letters of the day to
    // cumulative missing letters and
    // update array for output
    b+=a[i++]=f
  )
    // iterate current string with character c
    foreach(var c in
      // tuplized variable assignment
      // e=b.ToList()
      //   set e to a copy of the cumulative letters
      // f=""
      //   initially there are no letters needed for the day
      ((e,f)=
      (b.ToList(),"")).f+a[i]
    )
      // conditionally add c to missing letters for the day
      f+=e.Remove(c)?"":c;
}
```
[Answer]
# R, ~~119 112 106~~ 103 bytes
-7 bytes from aliasing the two longer function names and now taking user input from `scan()`  
-6 bytes to only call `strsplit()` once at the beginning  
-3 bytes to get rid of the aliasing again and assign two variables in one call
(Also edited the byte count which was erroneously low earlier)
```
a=scan(,'');b=a=strsplit(a,'');for(i in 2:length(a))b[[i]]=vecsets::vsetdiff(a[[i]],unlist(b[1:i-1]));b
```
This is my very first PPCG submission of any kind! So I have no idea what I'm doing both in terms of golfing and in terms of posting etiquette. The output is a list of vectors which may or may not meet the terms of the challenge. :-P
As for the code itself, it takes user input via `scan()` and compares each new day's letters to the cumulatively owned letters, as in other solutions. If there are shorter alternatives to `unlist` and `strsplit` for converting strings into vectors of individual characters that would be cool to know. I also used the `vsetdiff` function in Carl Withoft's `vecsets` package to get the set difference of the letters needed for the next day and the current letters owned. 
[Answer]
# [Python 2](https://docs.python.org/2/), ~~102~~ 100 bytes
```
from collections import*
c=Counter
l=c()
for x in map(c,input()):y=x-l;l+=y;print list(y.elements())
```
[Try it online!](https://tio.run/##XZC7asMwFIZ3PcXBi@3WydDRQUNiRDMYCxKTDMGDqyhUoBuyAvbTu5GIS9Ppv@jjHI7s5L@N/pgrc@U4SZL55owCZqTkzAujBxDKGuffEMOVuWvPHZKYZTm6GQcjCA2qtxkrhLZ3n@V5OeFxJTfyHU8b64T2IMXgs2nNJVdc@@HBzI9FKA6ow4DLJaUNSQtI2zONsj@QmI/kRJqWkCbtCvhPLSnC8X27q0KzXXS3aLX0wUX0uKeHNpQ1pc3n07zY3/QXDVXXlQjiuYBB9urr2pdQI@AjZxD@EUE8fP4B "Python 2 – Try It Online")
-2 bytes, thanks to Embodiment of Ignorance
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 71 bytes
```
$args|%{$w=$_;$p|% t*y|%{$w=$w-replace"^(.*?)$_(.*)",'$1$2'};$w;$p+=$w}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyWxKL24RrVapdxWJd5apaBGVaFEqxIqUK5blFqQk5icqhSnoadlr6kSD6Q0lXTUVQxVjNRrrVXKgTq0gepq////r@7o5KwOJKGUE5RyhgqCGAA "PowerShell – Try It Online")
Takes input words `$args` and iterates over them. Each iteration we set the current word `$w`, then loop over our `$p`ool of already-purchased letters. Each inner loop, we perform a regex `-replace` on our current `$w`ord, so that we're replacing just the first instance of the letter from our `$p`ool. Once we've gone through all letters in the pool, we output what's remaining `$w` (i.e., what we need to purchase), and then tack those letters onto our pool `$p+=$w` for the next word.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~15~~ 14 bytes
```
£Q®X=rZPPÃQ±XX
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=o1GuWD1yWlBQw1GxWFg&input=WyJPTkUiLCJUV08iLCJUSFJFRSIsIlNFVkVOVEVFTiJd)
```
£Q®X=rZPPÃQ±XX     :Implicit input of array
£                  :Map each X
 Q®                :  Map each Z in Q (initially a quotation mark)
   X=              :    Reassign to X
     rZ            :    Replace Z with
       P           :    The empty string
        P          :    With the default global flag disabled
         Ã         :  End map
          Q±X      :  Append X to Q
             X     :  Return X
```
[Answer]
# [Red](http://www.red-lang.org), 75 bytes
```
func[b][a: copy""foreach w b[foreach c a[replace w c""]print w append a w]]
```
[Try it online!](https://tio.run/##ZYvBDoIwEETvfMVm7/wANyCNHEybANFDs4dS2mhioGk0xK@vVKtRuey8mZ3xZgytGSVltgj2Nmk5kFQF6NndEe3sjdInWGCQb9agpDfuorRZc41Izp@n68rKOTONoGAhChYkCs4QsD@KeJuWRdexA@M9YxwJXkPM8xyz/37i52rbLKt6/ZZJqiR1CiNsN10j2h4BcC8E3yX4wY/7rsaIwgM "Red – Try It Online")
[Answer]
# Excel VBA, 127 bytes
```
Function z(w)
z=""
For Each x In w.Cells
v=x.value
For y=1To Len(z)
v=Replace(v,Mid(z,y,1),"",1,1)
Next
z=z&v
Next
End Function
```
Takes input in the form of an excel range.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 118 bytes
```
m(a,r,q,u)char**a,*r,*q,*u;{for(;*a;a++,memcpy(r,q,255))for(memcpy(q,r,255),u=*a;*u;u++)*u=r[*u]-->0?32:(q[*u]++,*u);}
```
[Try it online!](https://tio.run/##VY9Bb8IwDIXv@xU@Jo4rAROXRWWnSJyKtFXboeohRMA4FGggSFPV357ZFRJaTvb3np@dUBxCyLlTniL1lHT48RHRE0bCnjDZYX@OyqK33hjqdl24/CqxLpZLrUV7sJ4DhFEq2cyDyRiNqYwNprYoVrP318Wb6qXjIEzajvl4ukHnjyclhY@HQCD7Abm@N62G4QX4TWzbcHoLJQyz0T5x@Icnzp/hcTMn2HKeflA@FUQI7J1bmDZI21owRgoNl3S7qqfAk2POm8rl@nuT6/WHc/nTfbmqdq76Aw "C (gcc) – Try It Online")
As a little bonus it takes the stock in `r` at the start as an array. Outputs the input null-terminated null-terminated-string list `a` with all pre-owned letters replaced with spaces.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
*-6 thanks to Kevin Cruijssen*
```
ćsvDysSõ.;»
```
[Try it online!](https://tio.run/##yy9OTMpM/f//SHtxmUtlcfDhrXrWh3b//x@tFOzhHxSipKOg5OPv7@cOZaAw4TxkpSChWAA "05AB1E – Try It Online")
[Answer]
# [Swift 4.2/Xcode 10.2](https://developer.apple.com/swift/), ~~244~~ ~~242~~ ~~239~~ 238 bytes
```
a.reduce(([Character:Int](),[String]())){c,l in let b=l.reduce(into:[Character:Int]()){$0[$1,default:0]+=1}.map{($0,max(0,$1-(c.0[$0] ?? 0)))};return(c.0.merging(b){$0+$1},c.1+[b.map{String(Array(repeating:$0.0,count:$0.1))}.joined()])}.1
```
[Try it online!](https://tio.run/##fZBfb4IwFMXf/RQN4aGNlfDvicUZNWQuMZBMsz0QHioUx4LF1JJtIXx21@JwLopP99ybe@75tYfPPBPuMatYAkia5iIvGSmWVAjKDzArOSAeiFaC52wbIzB6PDegBpyKirMjMThNq4RCGM3fCSeJ9HrPTMQQ4W4bIoTqBBcgZ6CgAmzGRefKmSi9KyeqdTPSLZzSjFSF8Mx4OLYaY0f2NdRNvCNf0MS6NYKJIffMGEwmwJQhzcOJSs2NHeVbmQ436tpQtxqcGNYw2rRnTmRwyjn5hpzuKRGy93TTMHFSVkwoacmLxkeZM5pCFEttHZvBQL1A0IOwwBhEWhj4Ggba@i1sy@LFb/uV/@oHa98PtLg1XH2vct/8c@90HA32klDAayP6Q7BvIHRdS9ITbt8Pt3vD7Ytwpw2fzuYqbtrVWVfn3VypHg7nPofTy@FccLgtx2oRvqxV4jIMg6df8U@eu8tVNeqBc@/Dub1wLjr@AA "Swift 4 – Try It Online")
The letters are not arranged in alphabetical order, it is not forbidden by the rules.
[Answer]
# Scala, 68 bytes
```
(c:Seq[String])=>c./:(Seq(""))((a,n)=>a:+n.diff(a./:("")(_+_))).tail
```
[Try it online!](https://scalafiddle.io/sf/IvLuupE/5)
/: is short-hand for foldLeft operator, 
a is aggregation, ultimately returns the result we want, 
n is next element
## Un-golfed
```
def NewLettersPerDay(c: Seq[String]): Seq[String] = {
    c.foldLeft(Seq(""))((agg, next) => {
      val existingLetters = agg.reduce(_+_)
      val newDayLetters = next.diff(existingLetters)
      agg :+ newDayLetters
    }).tail
}
```
[Answer]
# [PHP](https://php.net/), 87 bytes
```
for(;$w=$argv[++$i];print' ')for($b=$a;$l=$w[$$i++];)$b[$l]?$b[$l]--:++$a[$l]&&print$l;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVym1VEovSy6K1tVUyY60LijLzStQV1DVBkipJQDlrlRxblfJoFZVMbe1Ya02VpGiVnFh7CKWrawXUlghiqqmBtarkWP///9/fz/V/SLj//xCPIFfX/8GuYa5@Ia6ufgA "PHP – Try It Online")
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), ~~36~~ 33 bytes
```
*+(){(a;x,a:&0|-/#''='(y;x@:1))}\
```
[Try it online!](https://tio.run/##ZY5PC4JAEMXvfQrZIndLqa67BKksdYhdKLFDBXoxwjCIDitWX932nyh4eTPz9jdvtvDLW9k0OZ7NIaphRoSX4eny4y/Grrt2YUXEBq8Q@l6aN64n5@r3wrkjSPosCEzz7P4gglTkha7f0fsMAWcUEBCfuNLdgarpSBPKYkoZQCPH6RgpktAATeTjdZBge50z2LXrdi0II2kEtoS2RNZUjQnQgAcCJaESRbQhxx0/xHLec862pva7duhhyjDBnakZrv@v1Rxo/g "K (ngn/k) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
ＥθΦι¬⊙…θκ‹№…ιμλ№νλ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUCjUEfBLTOnJLVII1NHwS@/RMMxr1LDuTI5J9U5Ix8sna2po@CTWlys4ZxfCtSEkANqyAXK5QAxRCoPxIEA6///o6PV/f1c1XUU1EPC/cGUR5ArmB/sGubqF@Lq6qceG/tftywnEQA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  Φ                 Map over characters
       θ            Input array
      …             Truncated to length
        κ           Outer index
    ¬               Logical Not
     ⊙              Any element exists where
          №         Count of
              λ     Current letter in
            ι       Outermost word
           …        Truncated to
             μ      Current letter index
         ‹          Is less than
               №    Count of
                 λ  Current letter in
                ν   Innermost word
                    Implicitly print each day's bought letters on their own line
```
[Answer]
## PHP, UTF-8 aware (253 bytes)
```
<?php $p=[];for($i=1;$i<$argc;$i++){$a=$p;$b=[];for($j=0;$j<mb_strlen($s=$argv[$i]);$j++){$k=1;if(isset($a[$c=mb_substr($s,$j,1)]))if($a[$c]){$k=0;$a[$c]--;}if($k){echo $c;if(isset($b[$c]))$b[$c]+=$k;else $b[$c]=$k;}}$p=array_merge($p,$b);echo PHP_EOL;}
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 112 bytes
```
a=>{var b="";for(int i=0;;b+=a[i++])foreach(var z in b)if(a[i].Contains(z))a[i]=a[i].Remove(a[i].IndexOf(z),1);}
```
[Try it online!](https://tio.run/##bZBBa4QwEIXv/oqQk0Fb2nM2givSXRBTXOkelj1EG7tzaAQTtu2Kv90makHYXmbee/MxMFPrh1rDGNcGWrXZZ6DNRpsO1EcUNWwULOqvokMVw5g2beeDMgjYE6VVwMQJguBMbCxFffEdd0OgUEWg8e3w/Ji0yghQ2r8R4gI2pYX8bK9yJvbqXX7zxgLhM6HDSD23xkhtNGJIya/T2es9NKse8zzFIS6P3NVdkTp3SN/SvEzTHA/h/@SiJ37NxNvE5vHStktLltCJNX3Y8aK0o4zz/GXua/VnVpgL7IaBeusfuePcm6YjyXTdq3248V1AqLWm@@mbxQ61MPWlH@6pYwdGZqCkb@0w/gI "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 28 bytes
```
for$i(@h){s/$i//}push@h,/./g
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glU8MhQ7O6WF8lU1@/tqC0OMMhQ0dfTz/9/39/P1eukHB/LjDtEeTq@i@/oCQzP6/4v24BAA "Perl 5 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 52 bytes
```
->l{r="";l.map{|x|r.chars{|c|x[c]&&x[c]=''};r+=x;x}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6nushWSck6Ry83saC6pqKmSC85I7GouLomuaYiOjlWTQ1E2qqr11oXadtWWFfU1v6Pjlb393NV11FQDwn3B1MeQa5gfrBrmKtfiKurn3qsDhe6KhgPrBgs7@jkDBJxhNFOMNoZJg5igZUGe/gHhYAEffz9/dyhDBQmnIesFCQUGwvzW4FCWnRFbO1/AA "Ruby – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
é█üa%┐┤
```
[Run and debug it](https://staxlang.xyz/#p=82db816125bfb4&i=[%22ONE%22+%22TWO%22+%22THREE%22+%22SEVENTEEN%22]%0A[%22ONE%22+%22TWO%22+%22ONE%22+%22THREE%22]%0A[%22ABC%22+%22AABC%22+%22ABBC%22+%22ABCC%22+%22AABBCC%22]%0A[%22SHORT%22+%22LOONG%22+%22LOOOONG%22+%22LOOOOOOONG%22+%22SHORT%22+%22LOOONG%22]&a=1&m=2)
Output is newline separated.
]