Esse desafio é inspirado no meme Men of Culture .

O meme envolve apagar partes da legenda original,

Ah, vejo que você também é um homem de cultura.

para fazer parecer que o personagem está dizendo outra coisa.

Seu desafio é escrever um programa que, com uma entrada, mostre como a frase original pode ser apagada para atingir a sequência de entrada.

Regras:

• Use um -caractere para representar um caractere em branco.
• Você não deve adicionar letras adicionais para obter a sequência de entrada
• Você pode tratar comparações de strings como não diferencia maiúsculas de minúsculas
• Você pode ignorar o espaço em branco nas comparações de string
• Se nenhuma substituição for possível, imprima um valor falso.
• Você também pode substituir espaços em branco redundantes por um -, embora não seja obrigatório.
• Onde várias soluções são possíveis, você pode produzir qualquer uma delas.

Casos de teste:

Básico:

Exemplo Meme 1

Ah, I see you're a well.
> Ah, I see you're a --- -- ------- -- well.

Exemplo Meme 2

Ah, I see well.
> Ah, I see ------ - --- -- ------- -- well.

Caso de borda 1:

What did you just say about me, you little
> false

Caso 2 do Edge (editado):

*no input*
> --- - --- ------ - --- -- ------- -- -----

Intermediário:

Exemplo Meme 3

Ah, I see you're Orwell.
> Ah, I see you're - --- o- -----r- -- well.

Exemplo Meme 4

Ah, ymca.
> Ah, - --- y----- - m-- -- c------ a- ----.

Exemplo Meme 5

Ah, a manual.
> Ah, - --- ------ a man -- -u----- a- --l-.
OR: > Ah, - --- ------ a man -- -u----- a- ---l.

Mais difíceis:

Exemplo Meme 6

tea.
> --- - --- ------ - --- -- ---t--e a- ----.

Exemplo Meme 7

eeeee
> --- - -ee -----e - --- -- ------e -- -e---

TL; DR: dada uma sequência de entrada, produza uma sequência que represente como a sequência original deve ser modificada para se ajustar à sequência de entrada, usando um "-" para representar um caractere em branco. Se uma substituição não for possível, imprima um valor falso.

Código golf, o código mais curto em bytes vence.

Editar: Esclarecimentos

• Ignorar espaços em branco nas comparações de cadeias significa que você pode separar os espaços em branco antes de comparar cadeias. Por exemplo, as entradas Ah, a manuale Ah , a manualsão tratadas como iguais. Outra pontuação , ' .deve ser preservada. Da mesma forma para saída, Ah, a manualé igual a Ah, amanual.

• espaço em branco redundante substituto refere-se aos espaços presentes na legenda original. Você não precisa substituí-los por "-", mas, ao substituir as redes, você ganha mais pontos, em seguida.

> <> , 94 bytes

"vAh, I see you're a Man of Culture as well.
0/i~ <r
!\:?!^:}=0={:@*:@"-"$?$~}$:@?
<>~i+0)?;>o

Experimente online!

Diferencia maiúsculas de minúsculas, não ignora espaços em branco ou pontuação e gera uma string vazia se a entrada for inválida. Se você quiser tentar outras strings, poderá modificar a primeira linha após a "v, contanto que não contenha um "ou um byte nulo.

Retina 0.8.2 , 117 bytes

^.
¶Ah, I see you're a Man of Culture as well.¶$&
{+i`¶(\W|(\w))(.*¶)(?(2)\W*\2)
$1¶$3
}1`¶\w
-¶
.*¶.*¶.*\w.*|¶.*¶.*

Experimente online! Pode economizar 1 byte, exigindo distinção entre maiúsculas e minúsculas. Pode salvar 3 bytes retornando --, - --- ---'-- - --- -- ------- -- ----.na entrada vazia. Explicação:

^.
¶Ah, I see you're a Man of Culture as well.¶$&

Anexe o texto desejado à entrada.

{+i`¶(\W|(\w))(.*¶)(?(2)\W*\2)
$1¶$3

Mova o maior número possível de caracteres do texto desejado para o resultado. Se o caractere for uma letra, ele também precisará corresponder à próxima letra da entrada, que será excluída.

}1`¶\w
-¶

Se não houver uma letra correspondente na entrada, altere-a para a -e tente novamente.

.*¶.*¶.*\w.*|¶.*¶.*

Se ainda houver letras na entrada, exclua tudo, caso contrário, exclua o restante da entrada.

Geléia , 58 55 48 45 bytes

“¬²Ẉ,ȷCIbƝɼeỴƤ/ɓIŒ;ṫṚS⁶_ŀỤ ṂB⁾÷ƈ»Ḣ”-1ị⁼ɗ?@€xṆ

Experimente online!

Versão mais legível:

“Ah, I see you're a man of culture as well.”Ḣ”-1ị⁼ɗ?@€xṆ

Quebra de compactação de string:

Ah, I{short: see}{short: you}'re a{short: man} of{long: culture} as{short: we}ll.

Python 2 , 126 114 bytes

i=input()
r=''
for c in"Ah, I see you're a man of culture as well.":x=c==i[:1];r+=c*x or'-';i=i[x:]
print(i=='')*r

Experimente online!

Python 2 , 108 106 bytes

Entrada é uma lista de caracteres.

lambda i:''.join(c==`i`[2:3]and i.pop(0)or'-'for c in"Ah, I see you're a man of culture as well.")*(i==[])

Experimente online!

JavaScript (Node.js) , 122 120 bytes

x=>"Ah, I see you're a Man of Culture as well.".replace(/./g,c=>c>' '?/^(.)\1/i.test(c+x)?(x=x.slice(1).trim``,c):'-':c)

Experimente online!

Explicação:

x =>                 // It takes in 'x' as parameter for function a string
    "Ah, I see you're a Man of Culture as well.". // What the actual is 
            .replace(                             // Now we are gonna replace 
                    /./g,     // selects everything 
                    c =>      // lambda function with param c
                        c > ' ' ?                 
                        /^(.)\1/i.test(           // does it all
                            c + x ) ?            // checks if there is a match
                            (x=x.slice(1). // returns everything from 1 to end in an array
                                trim`` ,   // removes whitespaces
                            c : '-' : c)   // and done

Pode ser reduzido ainda mais, mas substitui os espaços em branco por '-'. Se isso é aceitável, então

JavaScript (Node.js) , 112 bytes

x=>"Ah, I see you're a Man of Culture as well.".replace(/./g,c=>/^(.)\1/i.test(c+x)?(x=x.slice(1).trim``,c):'-')

Experimente online!

Reduzido ainda mais, apenas substitui os espaços em branco que estão após a sequência especificada por '-'.

JavaScript (Node.js) , 105 bytes

x=>"Ah, I see you're a Man of Culture as well.".replace(/./g,c=>/^(.)\1/i.test(c+x)?(x=x.slice(1),c):'-')

Experimente online!

JavaScript (Node.js) , 135 bytes

x=>!!x&&(t="Ah, I see you're a Man of Culture as well.".replace(/./g,c=>c>' '?/^(.)\1/i.test(c+x)?(x=x.slice(1).trim(),c):'-':c),!x&&t)

Experimente online!

Se "pode" significar fazer ou não fazer está bem, então

JavaScript (Node.js) , 106 bytes

x=>x&&(t="Ah, I see you're a Man of Culture as well.".replace(/./g,c=>c==x[0]?(x=x.slice(1),c):'-'),!x&&t)

Experimente online!

Brain-Flak , 764 600 bytes

(((<>)))([]((((((([][][]()){}[]){})[][]){}))[[]()])[][]())([[]](([][](([][]){})[]){}())[[]])(([()()][]([[]]([()]([[]](((([()][][][])[]){}[]())[])[]))()()()))[[]])((([[][][]]((([](([()()()][]){})){})(()()()()){}())[[]])[]){})((((()((([][]){}())((()()()){}){})[[][][]]))){}{}())((()(((([]()()()())())){}{}()())[[][]]){}[])(([(()()()){}](((((()()()()){}[]))){}{}))((()()){}()){})(([()][][]([()()()][])))(((([][][]())[([]()()){}()])[]())[[]])([[]]((([]()())(()()()()){}){})()()()){([{}]<>({})){(<{}(((((()()()()())){}{})){}{})>)}{}(<({}<(<()>)<>{({}<>)<>}>{})>)<>{({}<>)<>}{}<>}{}<>{{{}}<>}<>{({}<>)<>}<>

Experimente online!

Grandes melhorias graças a Jo King , especialmente na construção de cordas, mas também alguns ajustes lógicos no corpo principal. Explicação dele

Faz distinção entre maiúsculas e minúsculas (portanto, "Ah, eu vejo que você é Orwell." Não corresponde, mas "Ah, eu vejo que você também é." Sim), o espaço em branco na entrada é não ignorado e o espaço em branco inigualável na string original é convertido para -. Pelo meu entendimento, todas essas são opções válidas.

Explicação:

(476 bytes of much improved stack manipulation) #Push string

{ #While string
  ([{}]<>({})) #Check whether the top characters are equal
  {(<{}(((((()()()()())){}{})){}{})>)}{}  #If characters are not equal, push - on top of input
  (<({}<(<()>)<>{({}<>)<>}>{})>)<>{({}<>)<>}{}<>  #Take top of input (either - or matched char) and add to output
}{}
<>{{{}}<>} #Pop both stacks if input is left over
<>{({}<>)<>}<> #Reverse output

Haskell , 182 174 172 171 171 170 169 bytes

import Data.Char
t=toLower
a!b=(b:)<$>a
""%l=Just$'-'<$l
l@(a:b)%(c:d)|t a==t c=b%d!c|1>0=l%d!'-'
_%_=mempty
(%"Ah, I see you're a man of culture as well.").concat.words

Experimente online!

Ungolfed:

import Data.Char

template = "Ah, I see you're a man of culture as well."

-- strip spaces
preprocess :: String -> String
preprocess = filter (/=' ')

-- case-insensitive character comparison
a#b = (toLower a) == (toLower b)

strike' :: String -> String -> Maybe String
strike' "" "" = Just ""  -- base case
strike' _ "" = Nothing   -- chars are exhausted, impossible to convert
strike' "" rem = Just $ '-' <$ rem  -- full match, strike rest of chars
strike' cur@(x:xs) (r:rs)
    | x # r     =   (r:) <$> strike' xs rs  -- character matches; pop a char
    | otherwise = ('-':) <$> strike' cur rs -- no match; strike char, don't pop

strike :: String -> Maybe String
strike xs = strike' (preprocess xs) template

Prolog (SWI) , 109 bytes

[]+[]+[].
I+[B|X]+[C|O]:-(I=[B|J],B=C;I=J,C=45),J+X+O.
I-O:-I+`Ah, I see you're a man of culture as well.`+O.

Experimente online!

Diferencia maiúsculas de minúsculas e espaços em branco. O -/2predicado é o predicado principal, com seu primeiro argumento sendo a sequência de entrada e o segundo argumento sendo a sequência de saída.

JavaScript (Node.js), 103 bytes

s=>!s[i=0,r="Ah, I see you're a man of culture as well.".replace(/./g,c=>c==s[i]&&++i||c-1?c:'-'),i]&&r

Experimente online!

Maiúsculas e Minúsculas.

Pitão , 78 bytes ^SBCS

V." y°äz µÿéiSs¾ýØC[ócõ!ó5§n"=b.x@zZkIqbN=+kN=hZ.?=+k\-))I<Zlz!z.?k

^Conjunto de testes ^{Caracteres não imprimíveis presentes no código, consulte o link para a versão correta.}
Diferencia maiúsculas de minúsculas, não ignora o espaço em branco.

Perl 5 -F , 192 bytes

@q="Ah, I see you're a man of culture as well."=~/./g;while($x=shift@F){$x=~/\w/||next;while($_=shift@q){push@r,/\W/?$_:/\Q$x/i?$_:'-';$r[-1]=~/\w/i&&last}@q||last}say!$x&&@r,map/\w/?'-':$_,@q

Experimente online!