_{(Não, nem isso nem nenhum deles )}

Dada uma sequência e uma lista de sequências, preencha todos os espaços em branco na sequência de entrada com as sequências correspondentes.

Entrada / Saída

A sequência de entrada contém apenas caracteres alfabéticos, espaços e sublinhados. Não é vazio e não começa com um sublinhado. Em outras palavras, a sequência de entrada corresponde ao regex^[a-z A-Z]([a-z A-Z_]*[a-z A-Z])?$

Cada sequência na lista de entrada não é vazia e contém apenas caracteres alfanuméricos e espaços. Em outras palavras, eles correspondem ao regex ^[a-z A-Z]+$.

Um espaço em branco é uma sequência contígua de sublinhados ( _) que não é precedida nem prosseguida por um sublinhado.

A cadeia de entrada contém nespaços em branco para algum número inteiro positivo ne a lista de cadeias contém exatamente ncadeias.

A saída é obtida substituindo cada k-ésimo espaço em branco na string de entrada pela k-th string na lista de entradas de strings.

Exemplo

Dada uma string de entrada "I like _____ because _______ _____ing"e uma lista de strings ["ice cream", "it is", "satisfy"], podemos encontrar a saída da seguinte maneira:

• O primeiro espaço em branco vem logo depois "like ". Nós preenchemos isso com "ice cream"para obter "I like ice cream because ______ _____ing".
• O segundo espaço em branco vem logo depois "because ". Nós preenchemos isso com "it is"para obter "I like ice cream because it is _____ing".
• O terceiro espaço em branco vem logo depois "is ". Nós preenchemos isso com "satisfy"para obter "I like ice cream because it is satisfying".

Nós produzimos a string final "I like ice cream because it is satisfying".

Casos de teste

input string, input list => output
"Things _____ for those who ____ of how things work out _ Wooden",["work out best","make the best","John"] => "Things work out best for those who make the best of how things work out John Wooden"
"I like _____ because _______ _____ing",["ice cream","it is","satisfy"] => "I like ice cream because it is satisfying"
"If you are ___ willing to risk _____ you will ha_o settle for the ordi_____Jim ______n",["not","the usual","ve t","nary ","Roh"] => "If you are not willing to risk the usual you will have to settle for the ordinary Jim Rohn"
"S____ is walking from ____ to ____ with n_oss of ___ W_____ Churchill",["uccess","failure","failure","o l","enthusiasm","inston"] => "Success is walking from failure to failure with no loss of enthusiasm Winston Churchill"
"If_everyone_is_thinking ____ ____ somebody_isnt_thinking G____e P____n",[" "," "," ","alike","then"," "," ","eorg","atto"] => "If everyone is thinking alike then somebody isnt thinking George Patton"
"Pe_________e __say ____motivation does__ last Well___her doe_ bathing____thats why we rec____nd it daily _ __________lar",["opl","often ","that ","nt"," neit","s","  ","omme","Zig","Zig"] => "People often say that motivation doesnt last Well neither does bathing  thats why we recommend it daily Zig Ziglar"

Convexo , 5 bytes

'_%.\

Experimente online!

Convex é uma linguagem baseada em CJam, e esta resposta é quase a mesma que a minha resposta CJam, exceto a l~que é desnecessária aqui, pois o Convex faz avaliação automática de argumentos no início do programa.

Explicação:

'_%.\ e# Full program only
'_    e# Push '_'
  %   e# Split and remove empty chunks
   .\ e# Vectorize by Swap

Japonês , 8 bytes

r"_+"@Vv

Teste online!

Sinto que perdi algumas capturas ocultas nas regras, porque isso é extremamente simples: "substitua cada execução de sublinhados na string pelo próximo item da matriz".

JavaScript, 35 bytes

a=>b=>a.replace(/_+/g,a=>b.shift())

Experimente online

Próton , 42 bytes

a=>b=>re.sub("_+",_=>b.pop(0),a)
import re

Experimente online!

Importações estúpidas ...

A mesma coisa em python:

Python 3 , 53 bytes

lambda a,b:re.sub("_+",lambda _:b.pop(0),a)
import re

Experimente online!

MATL , 9 bytes

'_+'i1&YX

Experimente online!

Explicação

'_+'   % Push this string: regexp pattern
i      % Input cell array of replacement strings
1      % Push 1
&YX    % Four-input regexp replacement. This implicitly inputs the original
       % string, and consecutively replaces each first occurrence of the 
       % regexp pattern in that string by one of the replacement strings.
       % Implicitly display

CJam , 7 bytes

l~'_%.\

Experimente online!

-1 graças a um truque inteligente de Martin Ender .

Explicação:

l~'_%.\ e# Full program only
l       e# Input line
 ~      e# Eval
  '_    e# Push '_'
    %   e# Split and remove empty chunks
     .\ e# Vectorize by Swap

Geléia , 8 7 bytes

ṣ”_¬Ðfż

Experimente online! Editar: salvou 1 byte graças a @Erik the Outgolfer. Explicação:

ṣ”_         Split on underscores
   ¬Ðf      Discard empty values
      ż     Zip with second input
            Implicit concatenated output

Perl 5 , 25 + 1 (-p) = 26 bytes

@a=eval<>;s|_+|shift@a|eg

Experimente online!

Pitão , 10 bytes

s.i:E"_+"3

Experimente aqui!

Como funciona?

si: E "_ +" 3 Programa completo.

   : E 3 Divida a segunda entrada em correspondências da regex ...
     "_ +" A regex "_ +" (corresponde a 1 ou mais sublinhados)
 .i Intercalar os elementos da lista dividida com a entrada.
s Associe-se a uma sequência.

RProgN 2 , 11 bytes

x='_+'³[x‘r

Pega uma string e uma pilha de strings no topo da pilha.

O primeiro elemento (superior) de uma pilha é para a direita, portanto, a entrada é da direita para a esquerda.

Explicado

x='_+'³[x‘r
x=          # Set the stack of replacements to x
  '_+'³   r # Replace each chunk of _'s with the function...
       [    # Pop off the group of _'s
        x‘  # Pop the top element off x. Use that.

Experimente online!

Java 8, 57 bytes

a->s->{for(String i:a)s=s.replaceFirst("_+",i);return s;}

Quando li o desafio, pensei que deveríamos fazer uma sentença gramaticalmente correta com as palavras em ordem aleatória, mas apenas substituir linhas por cada palavra seqüencial é mais fácil. ;)

Explicação:

Experimente aqui.

a->s->{            // Method with String-array and String parameter and String return-type
  for(String i:a)  //  Loop over the input-array
    s=s.replaceFirst("_+",i);
                   //   Replace the first line (1 or more adjacent "_") with the substring
                   //  End of loop (implicit / single-line body)
  return s;        //  Return the result
}                  // End of method

05AB1E , 12 bytes

„__¤:sv'_y.;

Experimente online!

Explicação

„__¤:          # replace all runs of multiple "_" with a single "_"
     sv        # for each y in the list of replacements
       '_y.;   # replace the first instance of "_" with y

C # (.NET Core) , 97 96 + 18 bytes

_{Guardado 1 byte graças a Kevin Cruijssen !}

Os 18 bytes são para uso System.Linq.

s=>l=>string.Concat(s.Split('_').Where(x=>x!="").Zip(l.Concat(new[]{""}),(x,y)=>x+y).ToArray());

Experimente online!

Ruby , 28 + 1 = 29 bytes

$_=gsub(/_+/){|i|gets[/.*/]}

Usos -p

A primeira linha é a string de formato, o restante das linhas é a matriz.

Experimente online!

Python 2 , 61 bytes

import re
s,l=input()
for i in l:s=re.sub('_+',i,s,1)
print s

Experimente online!

Droga.

Python 2 , 63 bytes

import re
f=lambda s,l:l and f(re.sub('_+',l[0],s,1),l[1:])or s

Experimente online!

Empilhados , 21 bytes

[@y'_+'[y shift]repl]

Experimente online!

Substitui todas as execuções de _com y shift. Nada original, como parece.

SOGL V0.12 , 7 bytes

lΔ╔*№≤ŗ

Experimente aqui!

Explicação:

l        get the strings length
 Δ       range
  ╔*     multiply an underscore with each of the numbers
    №    reverse vertically (so the longest underscores get replaced first)
     ≤   put the array on top - order parameters for ŗ correctly
      ŗ  replace in the original string each any occurence of the underscores with its corresponding item in the array

Python 2 , 49 bytes

s,l=input();import re;print re.sub("_+","%s",s)%l

Experimente online!

A entrada da lista é tomada como uma tupla. Permitir listas reais como entrada adicionaria outros sete bytes, pois seria necessária uma conversão ( tuple(...)).