8 -9 bytes

# Perl 6, 50 42 585849 bytes

-9 bytes thanks to nwellnhof

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


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 4258 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 5849 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

# 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 # Perl 6, 50 424258 bytes {($!=[~]~first {m:g/<<./)x(TR/ //.indexjoin.starts-with($!)===0$^a)},[R,] [\~] .words}


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, 5042 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 4258 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)