Ce défi est inspiré du mème Men of Culture .

Le mème implique de masquer des parties de la légende d'origine,

Ah, je vois que tu es aussi un homme de culture.

pour le faire apparaître comme si le personnage disait autre chose.

Votre défi est d'écrire un programme qui, étant donné une entrée, montre comment la phrase originale peut être effacée pour atteindre la chaîne d'entrée.

Règles:

• Utilisez un -caractère pour représenter un caractère masqué.
• Vous ne devez pas ajouter de lettres supplémentaires pour obtenir la chaîne d'entrée
• Vous pouvez traiter les comparaisons de chaînes comme insensibles à la casse
• Vous pouvez ignorer les espaces dans les comparaisons de chaînes
• Si aucune substitution n'est possible, affichez une valeur fausse.
• Vous pouvez également remplacer un espace blanc redondant par un -, mais ce n'est pas obligatoire.
• Lorsque plusieurs solutions sont possibles, vous pouvez générer n'importe laquelle d'entre elles.

Cas de test:

De base:

Exemple Meme 1

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

Exemple Meme 2

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

Cas de bord 1:

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

Cas de bord 2 (édité):

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

Intermédiaire:

Exemple Meme 3

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

Exemple Meme 4

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

Exemple Meme 5

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

Plus fort:

Exemple Meme 6

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

Exemple Meme 7

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

TL; DR: étant donné une chaîne d'entrée, affichez une chaîne qui représente la façon dont la chaîne d'origine doit être modifiée pour s'adapter à la chaîne d'entrée, en utilisant un "-" pour représenter un caractère masqué. Si une substitution n'est pas possible, affichez une valeur fausse.

Code golf, donc le code le plus court en octets gagne.

Edit: Clarifications

• Ignorer les espaces dans les comparaisons de chaînes signifie que vous pouvez supprimer les espaces avant de comparer les chaînes. Par exemple, les entrées Ah, a manualet Ah , a manualsont traitées comme égales. Les autres signes de ponctuation , ' .doivent être conservés. De même pour la sortie, Ah, a manualest égal à Ah, amanual.

• remplacer les espaces blancs redondants fait référence aux espaces présents dans la légende d'origine. Vous n'avez pas besoin de les remplacer par "-", mais si vous remplacez les filets vous avez plus de points, allez-y.

> <> , 94 octets

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

Essayez-le en ligne!

Respecte la casse, n'ignore pas les espaces ou la ponctuation et génère une chaîne vide si l'entrée n'est pas valide. Si vous voulez essayer d'autres chaînes, vous pouvez simplement modifier la première ligne après le "v, tant qu'elle ne contient pas d' "octet nul.

Retina 0.8.2 , 117 octets

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

Essayez-le en ligne! Pourrait économiser 1 octet en exigeant la respect de la casse. Pourrait économiser 3 octets en revenant --, - --- ---'-- - --- -- ------- -- ----.sur une entrée vide. Explication:

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

Ajoutez le texte souhaité à l'entrée.

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

Déplacez autant de caractères du texte souhaité vers le résultat que possible. Si le caractère est une lettre, il doit également correspondre à la lettre suivante dans l'entrée, qui est ensuite supprimée.

}1`¶\w
-¶

S'il n'y a pas de lettre correspondante dans l'entrée, remplacez-la par a -et réessayez.

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

S'il reste des lettres dans l'entrée, supprimez tout, sinon supprimez le reste de l'entrée.

Gelée , 58 55 48 45 octets

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

Essayez-le en ligne!

Version plus lisible:

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

Répartition de la compression des chaînes:

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

Python 2 , 126 114 octets

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

Essayez-le en ligne!

Python 2 , 108 106 octets

L'entrée est une liste de caractères.

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==[])

Essayez-le en ligne!

JavaScript (Node.js) , 122 120 octets

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)

Essayez-le en ligne!

Explication:

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

Peut être réduit davantage mais remplace également les espaces blancs par «-». Si cela est acceptable,

JavaScript (Node.js) , 112 octets

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

Essayez-le en ligne!

Réduit encore plus, ne remplace que les espaces blancs qui se trouvent après la chaîne donnée par «-».

JavaScript (Node.js) , 105 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 135 octets

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)

Essayez-le en ligne!

Si "peut" signifie que faire ou ne pas faire est correct, alors

JavaScript (Node.js) , 106 octets

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)

Essayez-le en ligne!

Brain-Flak , 764 600 octets

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

Essayez-le en ligne!

De grandes améliorations grâce à Jo King , en particulier dans la construction des cordes mais aussi quelques ajustements logiques dans le corps principal. Explication de sa part

Il est sensible à la casse (donc "Ah, je vois que vous êtes Orwell." Ne correspond pas mais "Ah, je vois que vous êtes orwell." Le fait), les espaces en entrée ne sont pas ignorés et les espaces inégalés dans la chaîne d'origine sont converti en -. À ma connaissance, toutes ces options sont valables.

Explication:

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

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

Essayez-le en ligne!

Non 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

Prolog (SWI) , 109 octets

[]+[]+[].
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.

Essayez-le en ligne!

Respecte la casse et les espaces. Le -/2prédicat est le prédicat principal, son premier argument étant la chaîne d'entrée et le deuxième argument étant la chaîne de sortie.

JavaScript (Node.js), 103 octets

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

Essayez-le en ligne!

Sensible aux majuscules et minuscules.

Pyth , 78 octets ^SBCS

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

Suite de
^{tests Caractères non imprimables présents dans le code, voir le lien pour la version correcte.}
Respecte la casse, n'ignore pas les espaces.

Perl 5 -F , 192 octets

@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

Essayez-le en ligne!