8 -9 bytes
source | link

Perl 6, 50 42 58 5849 bytes

-9 bytes thanks to nwellnhof

{~first {m:g/<<./.join.starts-with($^a)join~~/^$^a/},[R,] [\~] .words}

Try it online!Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{~first {m:g/<<./.join.starts-with($^a)join~~/^$^a/},[R,] [\~] .words}
{                                                        } # Anonymous code block
  first  # Find the first 
                                         [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                             }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       .starts-with($^a)~~/^$^a/   # And starts with the given word
 ~  # And stringify Nil to an empty string

Perl 6, 50 42 58 bytes

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}
{                                                        } # Anonymous code block
  first  # Find the first 
                                         [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                             }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       .starts-with($^a)   # And starts with the given word
 ~  # And stringify Nil to empty string

Perl 6, 50 42 58 49 bytes

-9 bytes thanks to nwellnhof

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}
{                                               } # Anonymous code block
  first  # Find the first 
                                [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                    }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       ~~/^$^a/   # And starts with the given word
 ~  # And stringify Nil to an empty string
7 fitting the weird test case
source | link

Perl 6, 50 42 58 bytes

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{($!=[~]~first {m:g/<<./)x(TR/ //.indexjoin.starts-with($!)===0$^a)},[R,] [\~] .words}
{                                        }# Anonymous code block
         m:g/   /  } # Match all
           Anonymous code <<.block
  first  # Single letters afterFind athe wordfirst boundary
     [~]            # And join
  $!=               # Assign to $!
 ( [R,] [\~] .words  # Of the reverse of the triangular joined words
  )x(       {             ) # Multiply this by
            }  # That matches:
          .index($!)m:g/   /   # TheMatch indexall offrom the acronymoriginal in:string
                <<.    TR/# //Single letters after a word boundary
           # The inputted string without spaces
  .join    # Joined
                       .starts-with($^a)   # And starts ===0with the #given Isword
 equal~ to 0# (startAnd ofstringify stringNil andto notempty Nil)string

Perl 6, 50 42 58 bytes

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{($!=[~] m:g/<<./)x(TR/ //.index($!)===0)}
{                                        }# Anonymous code block
         m:g/   /   # Match all
             <<.    # Single letters after a word boundary
     [~]            # And join
  $!=               # Assign to $!
 (               )x(                    ) # Multiply this by
                          .index($!)      # The index of the acronym in:
                    TR/ //                # The inputted string without spaces
                                    ===0  # Is equal to 0 (start of string and not Nil)

Perl 6, 50 42 58 bytes

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}
{                                                        } # Anonymous code block
  first  # Find the first 
                                         [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                             }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       .starts-with($^a)   # And starts with the given word
 ~  # And stringify Nil to empty string
6 fitting the weird test case
source | link

Perl 6, 50 42 4258 bytes

{($!=[~]~first {m:g/<<./)x(TR/ //.indexjoin.starts-with($!)===0$^a)},[R,] [\~] .words}

Try it online!Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{($!=[~] m:g/<<./)x(TR/ //.index($!)===0)}
{                                        }# Anonymous code block
         m:g/   /   # Match all
             <<.    # Single letters after a word boundary
     [~]            # And join
  $!=               # Assign to $!
 (               )x(                    ) # Multiply this by
                          .index($!)      # The index of the acronym in:
                    TR/ //                # The inputted string without spaces
                                    ===0  # Is equal to 0 (start of string and not Nil)

Perl 6, 50 42 bytes

{($!=[~] m:g/<<./)x(TR/ //.index($!)===0)}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{($!=[~] m:g/<<./)x(TR/ //.index($!)===0)}
{                                        }# Anonymous code block
         m:g/   /   # Match all
             <<.    # Single letters after a word boundary
     [~]            # And join
  $!=               # Assign to $!
 (               )x(                    ) # Multiply this by
                          .index($!)      # The index of the acronym in:
                    TR/ //                # The inputted string without spaces
                                    ===0  # Is equal to 0 (start of string and not Nil)

Perl 6, 50 42 58 bytes

{~first {m:g/<<./.join.starts-with($^a)},[R,] [\~] .words}

Try it online!

First option. I'm exploiting the fact the ord only returns the ordinal value of first letter of a string, while chrs takes a list of ords and returns a string. Or the regex from moonheart's answer is shorter :(. For reference, the previous answer was .words>>.ord.chrs instead of [~] m:g/<<./

Explanation:

{($!=[~] m:g/<<./)x(TR/ //.index($!)===0)}
{                                        }# Anonymous code block
         m:g/   /   # Match all
             <<.    # Single letters after a word boundary
     [~]            # And join
  $!=               # Assign to $!
 (               )x(                    ) # Multiply this by
                          .index($!)      # The index of the acronym in:
                    TR/ //                # The inputted string without spaces
                                    ===0  # Is equal to 0 (start of string and not Nil)
5 added explanation
source | link
4 -8 bytes
source | link
3 added 223 characters in body
source | link
2 deleted 33 characters in body
source | link
1
source | link