Este desafío está inspirado en el meme Men of Culture .

El meme implica eliminar partes del subtítulo original,

Ah, veo que también eres un hombre de cultura.

para que parezca que el personaje dice algo más.

Su desafío es escribir un programa que, dada una entrada, muestre cómo se puede borrar la oración original para lograr la cadena de entrada.

Reglas:

• Use un -personaje para representar un personaje en blanco.
• No debe agregar letras adicionales para lograr la cadena de entrada
• Puede tratar las comparaciones de cadenas como mayúsculas y minúsculas
• Puede ignorar los espacios en blanco en las comparaciones de cadenas
• Si no es posible la sustitución, genera un valor falso.
• También puede sustituir el espacio en blanco redundante con un -, aunque no es obligatorio.
• Cuando hay varias soluciones posibles, puede generar cualquiera de ellas.

Casos de prueba:

BASIC:

Ejemplo Meme 1

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

Ejemplo Meme 2

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

Caso de borde 1:

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

Edge case 2 (editado):

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

Intermedio:

Ejemplo Meme 3

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

Ejemplo Meme 4

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

Ejemplo Meme 5

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

Más fuerte:

Ejemplo Meme 6

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

Ejemplo Meme 7

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

TL; DR: Dada una cadena de entrada, genera una cadena que representa cómo se debe modificar la cadena original para que se ajuste a la cadena de entrada, usando un "-" para representar un carácter en blanco. Si no es posible una sustitución, genere un valor falso.

Código de golf, por lo que gana el código más corto en bytes.

Editar: aclaraciones

• Ignorar espacios en blanco en las comparaciones de cadenas significa que puede eliminar espacios en blanco antes de comparar cadenas. Por ejemplo, las entradas Ah, a manualy Ah , a manualse tratan como iguales. Se , ' .debe preservar otra puntuación . De manera similar para la salida, Ah, a manuales igual a Ah, amanual.

• el espacio en blanco redundante sustituto se refiere a los espacios presentes en el título original. No es necesario reemplazarlos con "-", pero si reemplaza redes obtendrá más puntos, entonces continúe.

> <> , 94 bytes

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

Pruébalo en línea!

Distingue entre mayúsculas y minúsculas, no ignora los espacios en blanco o la puntuación y genera una cadena vacía si la entrada no es válida. Si desea probar otras cadenas, puede modificar la primera línea después de la "v, siempre que no contenga un "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.*|¶.*¶.*

Pruébalo en línea! Podría ahorrar 1 byte al requerir mayúsculas y minúsculas. Podría ahorrar 3 bytes devolviendo una --, - --- ---'-- - --- -- ------- -- ----.entrada vacía. Explicación:

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

Anteponga el texto deseado a la entrada.

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

Mueva tantos caracteres del texto deseado al resultado como sea posible. Si el carácter es una letra, también debe coincidir con la siguiente letra en la entrada, que luego se elimina.

}1`¶\w
-¶

Si no hay una letra coincidente en la entrada, cámbiela por a -e intente nuevamente.

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

Si aún quedan letras en la entrada, elimine todo; de lo contrario, elimine el resto de la entrada.

Gelatina , 58 55 48 45 bytes

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

Pruébalo en línea!

Versión más legible:

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

Desglose de compresión de cadena:

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

Python 2 , 126114 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

Pruébalo en línea!

Python 2 , 108 106 bytes

La entrada es una 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==[])

Pruébalo en línea!

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)

Pruébalo en línea!

Explicacion:

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

Se puede reducir aún más, pero también reemplaza los espacios en blanco con '-'. Si esto es aceptable, entonces

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):'-')

Pruébalo en línea!

Reducido aún más, solo reemplaza los espacios en blanco que están después de la cadena dada con '-'.

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):'-')

Pruébalo en línea!

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)

Pruébalo en línea!

Si "puede" significa hacer o no hacer está bien, entonces

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)

Pruébalo en línea!

Brain-Flak , 764 600 bytes

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

Pruébalo en línea!

Grandes mejoras gracias a Jo King , especialmente en la construcción de cuerdas, pero también algunos ajustes lógicos en el cuerpo principal. Explicación de él

Es sensible a mayúsculas y minúsculas (por lo tanto, "Ah, veo que eres Orwell" no coincide, pero "Ah, veo que eres Orwell" sí), no se ignora el espacio en blanco en la entrada , y el espacio en blanco no coincidente en la cadena original es convertido a -. Según tengo entendido, todas esas son opciones válidas.

Explicación:

(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 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

Pruébalo en línea!

Sin golf:

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

Prólogo (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.

Pruébalo en línea!

Mayúsculas y minúsculas y espacios en blanco. El -/2predicado es el predicado principal con su primer argumento siendo la cadena de entrada y el segundo argumento siendo la cadena de salida.

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

Pruébalo en línea!

Distingue mayúsculas y minúsculas.

Pyth , ^{SBCS de} 78 bytes

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

Conjunto de
^{pruebas Caracteres no imprimibles presentes en el código, vea el enlace para la versión correcta.}
Mayúsculas y minúsculas, no ignora los espacios en blanco.

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

Pruébalo en línea!