[Question]
  [
A [marquee](https://en.wikipedia.org/wiki/Marquee_(structure)) is a low-tech board that allows customizable letters. For example, here is a marquee:
```
SALE ON SNEAKERS
```
However, someone might come along and vandalize it by removing letters to send a different message:
```
S     N    AKE
```
Given two non-empty string inputs, an original message and a new message, determine whether the new message can be created by removing characters from the original message. Spaces left by removal can be compressed, as above, or left in, as in `the` becoming `t e` by removing the `h`. Both messages will only contain letters and spaces, case is up to you.
# Test Cases
```
"the", "the" -> true
"the", "t e" -> true
"the", "te" -> true
"te", "t e" -> false
"then i walked", "the" -> true
"then i walked", "niald" -> true
"abcde", "abj" -> false
"a b c d e", "abcde" -> true
"y today", "yt" -> true
"sale on sneakers", "snake" -> true
"today", "toad" -> false
"today", "tyy" -> false
"the sale on sneakers", "t e snake" -> true
"this is a sign", "th s i  a s  n" -> true
"the sale on sneakers", "the salon sneakers" -> true
"the sale on sneakers", "the sal  on sneakers" -> true
"a   b   c", "abc" -> true
"a   bc", "a  b  c" -> false
"a   b   c", "a       c" -> true
"a   b   c", "a        c" -> false
"the", " the" -> false
"the", " h " -> true
"the", "h" -> true
```
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
{|∧Ṣ}ᵐ⊇
```
[Try it online!](https://tio.run/##jZBBTsMwEEWv8uV1YcEB4CBVFxPbbUItR4qNIit0U6S2sOIMbNiy6aK9TXKRYMcphLQCLEueeX/87ZmkIJ46lS9u2qpkuLoFK@@qZvPRrJ/q/a7ZvTNbPMhr9hjCOSnj41V9fF7V@9e2CrQ@vIWkedm27XTKbCrZBN0xm@A7xyg/pWeqRoaS1FKKsc9PRWekRNQo4aLzoeS@J0jAIdDTIHfcweaCXKDORmRISeQaRktaysIEzWgf9u@e6m1OYoyc@/ocLvn4vjD0SjMDvwkmW@jYHjxBIID@wyzyIf1PPXB2gwA/H4D30xnQiDqZXypGXL9pQZx9Ag "Brachylog – Try It Online")
I should not be surprised to learn that it's considerably faster if I put the `⊇` at the end. Takes the original marquee through the input and the target through the output.
```
{   }ᵐ     The input variable, with each element
 |         possibly
  ∧Ṣ       replaced by a space,
      ⊇    has the output variable as a subsequence.
```
Can also go the other way around, for another two bytes: [`{|Ṣ∧l₁}ᵐ⊆`](https://tio.run/##jZAxTsMwFIav8stzYeAAcJCqw4ttmlDLkeKgyEo7UKSoMDFwAhZWlg5wm/giwY5TCGkFRJby3ve9/LGdFMRTq/LlRVdXDGeXYNVV7Zpn17y57X2737ndKyuLW3nO1qG8JmV8vWk/Hjbt/qmr1@37ixfKbe8CcI9N183nrEwlm6F/LWb47jHpD@2R1chQkVpJMc35aXRGSkRHCRd9DiU3A0ECDoGBBt1zizIXZAO1ZUSGlESuYbSklSxMcEb7cvjvYb7MSUyRtV@bw6kcfy6Ms9LMwC@CyZY6Hg@eIBBA/xEW@Zj@Zx44@oIAfz8AH25nRCPqNT81jPj85oJcfAI)
[Answer]
# [J](http://jsoftware.com/), 25 bytes
```
rxin~[:,'.*',"#:rplc&' .'
```
[Try it online!](https://tio.run/##dZA/C8IwEMX3foqHgkGpoa6FToKTk6vTtUnpn5BIG9AsfvVYWyq1tMOR4/3eveNS@Q1nOZIYDCEixF0dOc6368U3r1K/73HI@IGFm23cPFS2Y@DM74NAZoXBCQmYLSRDPrxLMpblUY16dc2rUeJJqpZiZcfMoEtSYppMaSaGcEqr6SwhRQaBEX5tE@xgjSDXQ2enpCUlYTRaLamWTdtbWt31fxf9pq0hsUKcm12DxfDuWzAs8B8 "J – Try It Online")
*Note: TIO link not working because it's an older version of J, but this works locally for me on J901*
* `rxin~ ...` The whole verb is dyadic J hook, asking if the right argument, after being transformed by the `...` phrase, is a regex match in the left argument.
* `rplc&' .'` The transformation of the right arg (the leftover marquee letters) first replaces all spaces with a `.`, since a space has to match something.
* `[:,'.*',"#:` This phrase simply inserts `.*` between each of the letters, so that we match "removed and collapsed letters" too. It works by zipping `,.` the string `'.*'` with each character of the right arg, and then flattening the result `[:,`.
[Answer]
# [Python 3.8](https://docs.python.org/3.8/), ~~50~~ 46 bytes
```
lambda a,b:''in[b:=b[b[:1]in' '+c:]for c in a]
```
[Try it online!](https://tio.run/##jVHdToMwGL3nKU52U4jTZPHGkOCLzF18/UHqukJo58LTYwtz0omJpEnb85d@h27wTWufX7p@rKu30dCJSwJtecmYtnteVnzP9@XuoC0DexDloW57CGgLOoyXRhuFXZmFe7dFe/Ydqng@@7x4cp3RPmd4fAUrshAKHlj1SSYPkoBc9fNWgfn@rFiGrtfW53UeDUUkoqAYN75Rmy2mLWZGdXYDsQYmWKKrybhZaKFxIXNUcjU8pa0mIxcC4kJOucQ/lrkURhWQuHJR9GMa4FtJQ6QGv8AdhTJbC2cVHVXvosDZcFy@6NvpW5LJJDdiGO4mxFpwKAK/whvtEBbB6Xc714GAICKATZtZj53xJfpvE7BuIyDUCYhrmffUjE8akf6EpQ/zJ/4MRqKYMr4A "Python 3.8 – Try It Online")
The code is simply a modification of [@xnor's answer](https://codegolf.stackexchange.com/a/180287/88546) to a similar challenge: [Is string X a subsequence of string Y?](https://codegolf.stackexchange.com/q/5529/88546)
[Answer]
# [Scala](http://www.scala-lang.org/), 54 bytes
```
_./:(Set(""))(for(p<-_;c=_;q<-Seq(""," ",c))yield p+q)
```
[Try it online!](https://tio.run/##jZPNbtswEITvfoqBTiQsq/ckMtAeChRoTj72x1hRlM2EIWWSbiMEeXaXlGxHSlWghAAtZnY/iqulF6TpZKsHKQLuSRnI5yBN7fGxbfGyAH6RRnODTXDK7FCuR9Ena7Ukg/K0LT7csI0MLMs4Z411rL1bbW9Fub093K028hCNPEOWC847JXWNdnngpyyusJdZjv6F1RrBHeXiKmJOnGiTvIa0HxINFH6TfpT1LHxqG0W6HiVQJeqeS9XDmEuoIFDj7KWkt6IOwdbUJasLI92TlrAG3kh6lM6nBG9iOP6iS2WwVE9OcjW67t0JMQeOjcBf8L3yiA/Bq50Z2oGoICmAmXZmHjvoY/W/i4D5MgJiOwFxbuZ7a9D7HDH9CeM6DEv8E4xJRs@IQ1f4Vqs4rd9Nxos4rpLEHi@xHeX6PPJO7uQzSqQRZd9@Zj@WPPEuYYJd4ohz56qNfZLsq/KBUY4qh@M8MnpW0ShTf1bOh3sKYv/FMM@LJ2rZtvDHaufssfX8urnvt8YSDSPOqmS08doFbVhvRmjSyHvpwkh6Xbye/gA "Scala – Try It Online") (The output says `true` when a test passes, it prints `false` and throws an exception otherwise).
Times out for the later inputs, but appears to work otherwise.
Input is curried. First it takes the original message, and returns a `Set[String]` containing possible messages. However, the `Set` also acts like a `String => Boolean`, so it accepts the new message as its second input.
```
_./:(        //Fold over original message
  Set("")    //Accumulator will eventually hold all possible messages
)(           //Cartesian-product-ish for comprehension
  for(
    p <- _   //For every possible message p already in the accumulator
    c = _    //Current character
    q <- Seq( //Sequence of possible cases:
      "",     //Delete the character, don't keep a space
      " ",    //Delete the character, leave a space
      c       //Keep the character
    )
  ) yield p + q //Add each case q to p
)
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~26~~ 23 bytes
```
FreeQ[#|" "|___?h&/@#]&
```
[Try it online!](https://tio.run/##jZBfa8MgFMXf@ykOEcIGLYO9bwsM9rzRxxDCjdrFNTUQhSH989Uzo9mWZqVMRLy/czx63ZGt5Y6s4tRvHvqXTsq3nB0SJIeyLJ/q9C5jRdq/dkrbnK0ebzY5K3J2X6S3WfZcU0fcys4E12nNSZ/2i33iM5NlWI/L3xLn5Xc11zQUPqnZSjHLOBO0okZEiSouhhCqPkaAChwCEQ5iwA62FeQ8dDYSQ41Eq2G0pK1vw0tG@9145ei2LYkZce7nVbgQ4tvBNKhWBn4SjHrXoSt4gAEA@npUxFP4Dzvw5wAB/lsAHj9lAgMJIr9gRRxXpEFbHPsv "Wolfram Language (Mathematica) – Try It Online")
Input two lists of characters, curried, as `f[original][new]`. Returns `False` if the target can be reached, and `True` if it cannot.
Quite slow.
Normally `___` matches any sequence of zero or more elements. When subject to `?` ([`PatternTest`](https://reference.wolfram.com/language/ref/PatternTest.html)), it only matches if the test yields `True` for all elements of the sequence; since the test `h` is undefined, this only occurs when the sequence is empty.
```
                  /@#   (* if each letter of the original message*)
      #|" "|___?h&      (*  is still present, changed to a space, or missing *)
FreeQ[               ]& (* check that this does not describe the new message *)
```
[Answer]
# [Haskell](https://www.haskell.org/), 43 bytes
```
(a:b)!(c:d)=b!([c|a/=c,c>' ']++d)
_!y=y==[]
```
[Try it online!](https://tio.run/##lZNfa4MwFMXf@ymOZVClg70Xssd9gr2VUm7@MDOzOEzGCPS7Oxe1wy5pNxGUe373Hj1Xa3KNMqbvS9rxqijFTlaMF@VenOiBiXvxuMHmsN3KanUsAguM7Q/9G2nLZLvCe6etxx3WvlZrFNOVMTx3Hyol47qcVpe9T2TcRbOFxieZRskbD3EBWk1GplDiQo6uxF@TrgQOAYmZivzvQQG@lRQiFHyKcGQUWgtnFTWqcxF1drhPvsN5mm9JpvP4QULIJYak7RAx8ta1dhhOgtMvdgoaQwnfJcBmMs9YjcKi/P924MYAAoZFAWJeUxaaiIiLzMoXszAe4g@2WLCJdUQM83ebBWpc@3vqs9h/AQ "Haskell – Try It Online")
This is just a modified version of the Levenshtein distance calculation. Instead of normal edits our permitted edits are:
* Remove a character from string \$a\$
* Replace a character from string \$a\$ with space.
I use one clever-ish trick. Because two cases only differ by whether the head is maintained, we can use a list comprehension to create the two cases in situ.
So
```
(a:b)!(c:d)|a/=c&&c>' '=b!(c:d)|1>0=b!d
```
(this could be shorter anyway but I've structured it like this for illustrative purposes)
becomes
```
(a:b)!(c:d)=b!([c|a/=c,c>' ']++d)
```
[Answer]
# [Perl 5](https://www.perl.org/) `-pl`, 26 bytes
```
y/ /./;s//.*/g;$_=<>=~/$_/
```
[Try it online!](https://tio.run/##hU@7DsIwDNzzFTcwIdGUgYnHH/ANVUosGholFYmEsvDpBFNaBAWJwfHd5c6WOzrbVc5JQhZyHaQs5vK4nlXbzW57lbNK5hwbEn1h6G90gA05GFyUbUkLZ5TVE03VJ66DpvFFjQM0j0hRJESvVRLBqZZEUJbgHYIjpucgolc8rnfElEYEwtPPi/CdaRB4OxQ3OKaGaXhQc3Rj5DPwc0ovAn@dfBXfBL4K6FE9dAwfwEt4oal481003oW82K@KclnmRWfv "Perl 5 – Try It Online")
Takes the new resulting message first, followed by the original message, on separate lines.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 19 bytes
```
ßḢxn⁶anʋ¥@Ḣ};ʋɗṆ}ȧ?
```
[Try it online!](https://tio.run/##jZIxbsIwFIb3nuIXMxIHYGjvgRheYqsJWC8SjgQeGNqhCwfoWKlSxdK5ghUW4BZwEWPHDgoBtY0sxf/3P//OczySShlrtx/H1eeMTy8/xIfF5uvJyXn/sNi/H9dv893y0W6XvdPrt7WDh0GnzGSni@o17DY0WrqWNy4jx5TUWIp2zrXDOSkRPEpSUeVQMooECVIIROrtihuUhSDjqSkD0qQkCoZmSWM50d7T7KZx37q@LEi0kTGXj8O9HNcXmllZruEGQefPHNqDI/AE4D/CAm/S/9QDNysIcOcDpPF0GjSgyk7vFSM8v3m1Gf802lcBGa505tXwDA "Jelly – Try It Online")
Dyadic link that takes the original string as the left argument and the new string as the right argument. Uses something similar to @WheatWizerd's modified Levenstein algorithm, so it's very fast, unlike a brute force solution.
## Explanation
I admit this explanation is more confusing that the code itself.
```
ßḢxn⁶¥anʋ@Ḣ};ʋɗṆ}ȧ?   Main dyadic link
                  ?   If
                 ȧ    both strings are non-empty
              ɗ       then (
ß                       Recursively apply this link to the left string
             ʋ          and to (
 Ḣ                        First character of the left string, removing it from the string
          Ḣ}              First character of the right string, removing it from the string
        ¥                 Apply this dyad to them
         @                in reverse (
  x                         Repeat the left character
       ʋ                    this many times (
   n⁶                         Is the left character not a space?
     a                        And
      n                       are the characters not equal?
       ʋ                    )
        ¥                 )
            ;             Join the result with the right string
             ʋ          )
              ɗ       )
               Ṇ}     else return the logical negation of the right string
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~55~~ 51 bytes
```
f(char*a,char*b){for(;*a;)*a++-*b&*b-32||b++;b=*b;}
```
[Try it online!](https://tio.run/##jVJJboMwFN1ziiekVExR03aJ6EnYfA8EN9RE2B1QkrNTBzrEhEhFyN@8yfbHfL3lfBiqiNfUJZSNhcWHqu2iPKE8TihN1wm7S9j66fF4ZGmasyJh@Wl4b5WAlcb63kxpiy4@BNh3blohCstwZcoQmGqp0Unz1lgUz1gJ3EN@7iW3UrivUpc6zChjWRW5MS6KTdbFeXAKgnPuKymNyIWP6yK0tQyzaXxwKh/FIjoDf5UbT6mh8EHNTorlfI/XihrhKYhxcU4m9uIlExg4BCZu1Fy4ethWUO@43nqEoUai1TBa0k52ximMdjN/V99e25Lwj/ND9P38mFhIdt3AQnqtDNxLMGqrx6bAATgDgJ73ZzF4gj3w3y7glo8A11WATz295kZi1PDZz7gwYnr47Wj8STbzW4WxXMM1Fq5gPWHBafgC "C (gcc) – Try It Online")
-Saved 4 thanks to @Davide
* Output 0 if can be vandalized, truth if not.
* we iterate Marquee(a) until end of one of the two inputs :
we increment result(b) if current letters are equal or if we need a space.
Finally we return \*b which is \0 if compatible
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 26 bytes
-3 bytes by converting to tacit form
```
{(1_t_x;!0)@^t:(x?y)*~^y}/
```
[Try it online!](https://ngn.bitbucket.io/k#eJyVUt0OgiAYve8pTl5pF1m3dVFPUvsUTMvhFrRirZ49hFoidJFjzp0/5PBVq3u63Kv9bT1dZNudWqW3jc5mz51+5JNJhXmaqJona/vOkKvzhXsw4rBFMYAH4opa+VULNLhSe+Lsxy6eQDTUMl9CRcn6dCqOo3RCgRIMju1VnlFDdYy0IbXyGUktRycgBacTP0sjkcJ8jf7t7VYdsfG5PpTW4YkRiTfVILZF3UiYRZDNQdiCYAD0ACCCrqLRDh6Cf9iAn0YCTMFA6eqNkJaxojK4moEX7okljCRBjhs3vOcmJGrExrP+gC8969jI)
Returns `!0` if the marquee can't be vandalized, and some sort of string if it can be. To better standardize the output, `~(!0)~` can be inserted at the start of the function, i.e. `{~(!0)~x{(1_t_x;!0)@^t:(x?y)*~^y}/y}`.
* `{...}/` use a reduction, seeded with the original marquee text, running over the text to test
* `~^y` check if the current character in the input to test is not `" "`. (`" "` is the null character, so we can test this by using `~^`, i.e. not null)
* `*` multiply this by...
* `(x?y)` the index of the first match in the (remaining) marquee text. This will return `0N` (also a null) if the character is not present. `0N*1` remains `0N`, whereas `0N*0` results in `0`.
* `t:` store this in variable `t`
* `(...)@^t` index into the list, using whether or not `t` is null. If it is null, the second item will be selected. If it is not null, it'll be the first item.
* `(1_t_x;!0)` `!0` here is a sentinel value, used to indicate that the test text is invalid (because it contains at least one invalid character, or is too long, etc etc.). `t_x` drops `t` characters from the beginning of the (remaining) marquee text. To make sure the modified test text lines up, we always want to remove at least one character, hence the `1_`.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 24 bytes
```
~(0G`
.
[ $&]?
^
$¶
$
$$
```
[Try it online!](https://tio.run/##fY9NCgIxDIX3OcVbVHFRRE/g0gO4FGUybdHq0AFbkG48lgfwYmPmRxnwp7S8vC8JTS4u@cDLZjLbFLq5zRbrgua0hZruVrQn9biTIqWaJh2dlkedYlCRtwvwuHJ1dvZVNyLBc2WJS2Od5vJEjBIGFq0TRhmptpx1ThS5cqgDYnB8dpeoYxClPp9qtq8w5/YTfNTLPBh6jj5CLiP6Q5CxIBatBcKP5h6O0N86jKFsBdkLMO1WvZOwY2acRH@@MZgn "Retina – Try It Online") Takes newline-separated input, but link includes test suite that converts from comma-separated input on newline-separated test cases. Explanation:
```
~(`
```
Interpret the output of the rest of the program as a program (specifically a Count stage) and execute that on the original input.
```
0G`
```
Keep the original marquee.
```
.
[ $&]?
```
Replace each character with an optional character class of itself or space.
```
^
$¶
$
$$
```
Anchor the list of character classes to ensure that the match starts at the beginning of the vandalised marquee and ends at the end of the input.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 38 bytes
```
->o,s{o[/#{s.tr(" ",?.).chars*".*"}/]}
```
[Try it online!](https://tio.run/##jZBdbsIwEITfe4qR@9KiNJyAchDEw8Z2SCCyq6wRslDOHuz8UKJEgGXJ1jc7o92tz5lv803782sTvtrd@vPKqau/BESyTb9TWVDNK5GuRLPeN@0f8p1whRYJumf/MSGYkX@wUGFQ4kLVSat53lQzJVVqVCmTqkuj7HhnyCChMPBYMCgezirykXs3QqZKwxqw0XTSNUeVTfjeOxg9zpKaQ@8fWsVSWpgU08SiZIRL4PJg@oERCCIBzMvAnj/S9xzAgoeAsDFADvua8B52BXLZgP48V6Pc3gA "Ruby – Try It Online")
Outputs a string for truthy values, otherwise `nil` for falsey.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~79~~ \$\cdots\$ ~~73~~ 70 bytes
Saved a byte thanks to [Jonah](https://codegolf.stackexchange.com/users/15469/jonah)!!!  
Saved 3 bytes thanks to [dingledooper](https://codegolf.stackexchange.com/users/88546/dingledooper)!!!  
Saved 2 bytes thanks to [caird coinheringaahing](https://codegolf.stackexchange.com/users/66833/caird-coinheringaahing)!!!  
Saved 3 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!
```
lambda m,v:match(sub(*' .',sub('(^|\S)',r'\1.*',v)),m)
from re import*
```
[Try it online!](https://tio.run/##jZLfToMwFMbv9xRfuGm71CVzJiYm89IX0DunSSmdoNAS2k1x7tlnW5iy@ZcQOOf3HT7OaU7dutzo2W45X@xKUaWZQMXXF5VwMqd2ldIxwYTwEBF6/7a4ZoQ3ZDGdjAlfM8YrNlo2pkKjUFS1adx455R1FnNQmrhcJRzxxTg@cxzl@/SLqlHgWZRPKjv2OVR0Icqs00Qqs@gj0seeIIVEhp4GOfIWzmSiDbR1HbKiVDAaVivxpBobNKt92P93X@@MyI5R2340h@98/FwYeuWFhb8FbPGgu/HgCQIB9B9mHR/S/9QDX74QgD8fQPanM6AdirL8rhjd9ZsWRTZSL7WSTmVhLW6aleIYPq9Eaf9GB8KP@o8mXcJGMlfSTx86IYvV6fmZJBwxms6I32bTwHG/zRqvRU3jMnPs@2cXozBUxbH2Bi4mYddTY0q6pIEzFmndFNrRJUk21TYcyGa9TXByiY3dYtP3cGvnc3W3JWz3Dg "Python 3 – Try It Online")
Returns a truthy value if the new message can be created by removing characters from the original message or `None` otherwise.
[Answer]
# [Python 3](https://docs.python.org/3/), 69 89 86 bytes
```
def p(s,v,a=1):
 for c in v:_,x,s=s.partition(c);a*=c==x;s=(s," "+s)[x!=" "]
 return a
```
[Try it online!](https://tio.run/##TYxBCoMwEADvvmLrybRBsL0peYlIWWysoe0m7G5FX596kt6GgZm06RzplsMnRVaQTfLDT5AqsYtF15i2gCkyjBAIlvZuVytO6oSsQUOkajQdnt3o3NqJ26sSyouYfj25nYYC2OuXCTAnDqTVPt6kRn4ufTPYg6@DMTnr7EHw7SESCHl8eZY/CYf8AQ "Python 3 – Try It Online")
*Dropped to 86 thanks to Danis*
I haven't posted just a function before, but I think that's allowed for this one from reading the description? This returns `1|0` not `True|False` so I'll have to add a few more bytes if that's a requirement.
It just relies on the `partition` call to throw away characters from the front of the original string. And if the next character in the "vandalized" string isn't found the `a*=c==x` statement zeros out the accumulated answer.
Sadly... I missed the rule that when a character is replaced, it can match a blank the comes after it in the "vandalized" string. Accommodating that added more code.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 24 bytes
```
≔⪪⮌Ｓ¹θＵＭＳ∧∧θ№⁺ ι§θ±¹⊟θ¬θ
```
[Try it online!](https://tio.run/##VYyxDoMwEEN3vuLU6SKlAzMTYmIoQuULIjhB1HCB5ED9@zQZO1iyny3PmwmzNy6lNka7Mk6Hs4JvuilEwp6PSyYJlldUSkOddaqmepmj8/tuePmfaGgzKjo1dP5iwdFdER/w0GBLLT0v9C31QKsRwlqV49EfeGbXVGN@Ehy8lNykJEAQ2Xyoki074wg8Z0IZhZiet/sB "Charcoal – Try It Online") Link is to verbose version of code. Takes input as the new and original messages and outputs a Charcoal boolean, i.e. `-` if the transformation is possible, nothing if not. Inspired by my answer to [Speed of Lobsters](https://codegolf.stackexchange.com/questions/217690/). Explanation:
```
≔⪪⮌Ｓ¹θ
```
Get the new message and reverse it and split it into characters (so we can pop from the list).
```
ＵＭＳ∧∧θ№⁺ ι§θ±¹⊟θ
```
Loop over the original message, and pop the next character from the new message if it is a space or the next character from the original message.
```
¬θ
```
Check whether the list is now empty.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + coreutils, ~~53~~ 51 bytes
```
grep -q `sed -E 's/ /./g;s/(.)/.*\1.*/g'<<<$2`<<<$1
```
[Try it online!](https://tio.run/##hZFNboMwEIX3nOLJIsqPFFy6DW1XvUUWGbADbpBJMWqEqp6dGhsKtJFqweD53vPgsVMyRXfebD@7vJZX7N9xMlJg/4q14eARzw@Gb6Itj3bHONrxfJ0kSfh46mPcfQXBrVClRC1JoFRaHiCqAHbIDyrBzgh7yhxy4Vor3ZzBVgZPz1iJo2Zg3oTwJRCVlh1rCpv5@BCMGRbZkPwosVM0FG5UXqRYrl9wragUTqE0E30FSt9cBUKKDAKeOc26WjSVoNaytnHAkG250jBa0kXWxipG25n/2@BtKhJ@WyNo23GbuFPBdoFZlUIZ2IdgVK5dM7AAPQD02NfdQh4v4L9u4Lef7GWl9s38WUzMAadlw6HNjPAj@1sCkxSPtwj3mdICsysu@vk3 "Bash – Try It Online")
Rough port of [Jonah's J answer using regex](https://codegolf.stackexchange.com/a/217190/94093), I am sure there is a better way.
Takes two strings as arguments in the order of the test cases.
Exit code is 0 for a match, 1 for a mismatch.
[Answer]
# [R](https://www.r-project.org/), ~~105~~ 104 bytes
```
function(a,b){for(x in el(strsplit(gsub(" ",".",b),""))){c=sub(paste0(".*?",x),"",a);if(a==c)T=F;a=c};T}
```
[Try it online!](https://tio.run/##lZJBboMwFET3PcXI3diVG3WPaHc9QS7wMSa4QSbCRg2KcnaKIakomEhFSFjz5ntgcNMXaV@0VnlTW04yE5eibvgZxkJX3PnGnSrj@cG1GWdgku3YYJKMCSEuKg3yiZzXb5ztXj6YPAcmSSSm4JSmSuzTz4RSdU32177gzJeaSYwPgWe8vsM3rX6aEWySNVhOFFS5@4iFwTdVR51vB/71WENVvnRRpvIxhrKvVQwhg0KOmyE4F@MdfJ1TF3jnl9BRpVFbOKvpqBsXXM4Oy9Wr3vfwNeXrj/2lXRdrArGcoTXEs0rjMNwEZw526g6DgqAANlJjPGDS5@r/JoEHswQM3QPq1nyUT3A0qsi/m@@A6VKPc7C0zWsODszO2YqV2DjZ5VzvfwA "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~22~~ 14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
v¬DyQsðQ~i¦]õQ
```
First input is the original message, second input the new message.
Modification of [my 05AB1E answer for the *Speed of Lobsters* challenge](https://codegolf.stackexchange.com/a/217695/52210) (thanks *@Neil* for the tip, resulting in -8 bytes).
[Try it online](https://tio.run/##yy9OTMpM/f@/7NAal8rA4sMbAusyDy2LPbw18P//kozUolSuEgWFVAA) or [verify a few more test cases](https://tio.run/##hZE9jsIwEIWv8uQ62ivQcIE026BITGKLGCJHYiKQG0oOwCGoKLbZC8BNuEhw7AAxv5Zl@X1vPPaMa6Zcq3ZlRwLn7Q5iZKcs2tXxMLYpn/7SjT7us9N/2oqf36SdTERTKpH4NUtuCpHqxYNjoLGmaqFkfD7iRlMlvUN5IbsMlM@DRo4CEoF1XkctmlqSdcw2HjBVCrUBG0ULtWTnsHG7cFsf29QkY2Dt9Tl4kcFVgUGWUjPcJLCeGV8MHEAHAPMxUcBD@D0aeIwnwHUDKEIv7swD7xXPgQjjvdNb4RcRfzFKDFQpsuwC).
**Explanation:**
```
v            # Loop over the characters `y` of the (implicit) input original_message:
 ¬           #  Get the first character without popping the string
             #  (which uses the implicit input new_message the first iteration)
  D          #  Duplicate this first character
         i   #  If
   yQ        #  this first character is equal to the current character `y`
        ~    #  OR
     sðQ     #  this first character is a space:
          ¦  #   Remove this first character from the new_message
]            # Close both the if-statement and loop
 õQ          # And check if the new_message is now empty
             # (after which the result is output implicitly)
```
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), 62 bytes
```
->\a,\b {a~~/<{join ".*",map {" "eq$_??"."!!"'$_'"},b.comb}>/}
```
[Try it online!](https://tio.run/##jVNNb4JAFDzrrxg3pKJBbXvoofXj3Ev/QGnMA5aK4qIupiUW/zrdRURQmpQQlp2ZN7w3wIbvwqdsndz5k2wwtcmyHRzoeByND8soEGDDPrPWtMGBgfGtMZ/N2JB1OqxrzLsstZyhG62ddDpKMz/awei/vg3DQHCJQ7sV@BjZzBwP3m32Me33bOVhgeEaw2CqLma82/Mfn0LJeyNd3lonMAgTHI37l2Lr5NuH85Z/b7gbc0@hxiP4FkybsDNNbrynUJG@aZClqnuakZSA@RSEz6oTg2zVk1od1YlZ@pXOFgqTwqzHoMa6PLgzwayglHfaTjMWL7geUy96Mt1RuwTRBNawmi6PIxcKBPiicMW9RvM6LQIKvYqAHNfLfclZVn0JDlx4KDgtuhQliCOPEk0lcQWXFHJEAlJwWvGd1AIp1G21o3NlHJFXm6QkkuRqQjQZqyBwY74IJNRJkMGnOMUBhUAjgKgn02x7wqvov4uA5jICVJyAW4R5TZ3wXOPWX0K1DqfD/dMYNcUlvvzXOn8XV/ACt1/dooR@AQ "Perl 6 – Try It Online")
]