Questa sfida è ispirata al meme Men of Culture .

Il meme prevede l'oscuramento di parti della didascalia originale,

Ah, vedo che anche tu sei un uomo di cultura.

per far sembrare che il personaggio stia dicendo qualcos'altro.

La tua sfida è scrivere un programma che, dato un input, mostri come la frase originale può essere cancellata per ottenere la stringa di input.

Regole:

• Usa un -personaggio per rappresentare un personaggio cancellato.
• Non è necessario aggiungere ulteriori lettere per ottenere la stringa di input
• È possibile trattare i confronti di stringhe come maiuscole e minuscole
• È possibile ignorare gli spazi bianchi nei confronti delle stringhe
• Se non è possibile la sostituzione, emettere un valore errato.
• È possibile sostituire anche uno spazio ridondante con uno -, anche se non richiesto.
• Laddove sono possibili più soluzioni, è possibile produrne una qualsiasi.

Casi test:

Di base:

Esempio meme 1

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

Esempio Meme 2

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

Custodia per bordi 1:

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

Edge case 2 (modificato):

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

Intermedio:

Esempio meme 3

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

Esempio meme 4

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

Esempio meme 5

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

Più forte:

Esempio meme 6

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

Esempio meme 7

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

TL; DR: data una stringa di input, genera una stringa che rappresenta il modo in cui la stringa originale deve essere modificata per adattarla alla stringa di input, usando un "-" per rappresentare un carattere cancellato. Se una sostituzione non è possibile, emettere un valore errato.

Codice golf, quindi vince il codice più breve in byte.

Modifica: chiarimenti

• Ignorare lo spazio bianco nei confronti delle stringhe significa che è possibile rimuovere lo spazio bianco prima di confrontare le stringhe. Ad esempio, gli input Ah, a manuale Ah , a manualsono considerati uguali. Altre punteggiatura , ' .devono essere preservate. Allo stesso modo per l'output, Ah, a manualè uguale a Ah, amanual.

• lo spazio bianco ridondante sostitutivo si riferisce agli spazi presenti nella didascalia originale. Non è necessario sostituirli con "-", ma se si sostituiscono le reti più punti si procede.

> <> , 94 byte

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

Provalo online!

La distinzione tra maiuscole e minuscole, non ignora gli spazi bianchi o la punteggiatura e genera una stringa vuota se l'input non è valido. Se vuoi provare altre stringhe, puoi semplicemente modificare la prima riga dopo il "v, purché non contenga un "byte nullo.

Retina 0.8.2 , 117 byte

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

Provalo online! Potrebbe salvare 1 byte richiedendo la distinzione tra maiuscole e minuscole. Potrebbe salvare 3 byte ritornando --, - --- ---'-- - --- -- ------- -- ----.su input vuoto. Spiegazione:

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

Prepara il testo desiderato all'input.

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

Sposta il maggior numero possibile di caratteri dal testo desiderato al risultato. Se il carattere è una lettera, deve anche corrispondere alla lettera successiva nell'input, che viene quindi eliminata.

}1`¶\w
-¶

Se non è presente alcuna lettera corrispondente nell'input, cambiarla in a -e riprovare.

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

Se ci sono ancora lettere nell'input, elimina tutto, altrimenti elimina il resto dell'input.

Gelatina , 58 55 48 45 byte

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

Provalo online!

Versione più leggibile:

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

Analisi della compressione delle stringhe:

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

Python 2 , 126 114 byte

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

Provalo online!

Python 2 , 108 106 byte

L'input è un elenco di caratteri.

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

Provalo online!

JavaScript (Node.js) , 122 120 byte

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)

Provalo online!

Spiegazione :

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

Può essere ulteriormente ridotto ma sostituisce anche gli spazi bianchi con '-'. Se questo è accettabile, allora

JavaScript (Node.js) , 112 byte

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

Provalo online!

Ridotto ulteriormente, sostituisce solo gli spazi bianchi che seguono la stringa data con '-'.

JavaScript (Node.js) , 105 byte

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

Provalo online!

JavaScript (Node.js) , 135 byte

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)

Provalo online!

Se "può" significare fare o non fare va bene, allora

JavaScript (Node.js) , 106 byte

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)

Provalo online!

Brain-Flak , 764 600 byte

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

Provalo online!

Grandi miglioramenti grazie a Jo King , specialmente nella costruzione delle stringhe ma anche alcune modifiche logiche nel corpo principale. Spiegazione da lui

Fa distinzione tra maiuscole e minuscole (quindi "Ah, vedo che sei Orwell." Non corrisponde, ma "Ah, vedo che sei orwell."), Lo spazio bianco in input non viene ignorato e lo spazio bianco senza pari nella stringa originale è convertito in -. Secondo la mia comprensione, tutte queste sono opzioni valide.

Spiegazione:

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

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

Provalo 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 byte

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

Provalo online!

Distinzione tra maiuscole e minuscole e spazi bianchi. Il -/2predicato è il predicato principale con il suo primo argomento come stringa di input e il secondo argomento come stringa di output.

JavaScript (Node.js), 103 byte

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

Provalo online!

Che tiene conto del maiuscolo o minuscolo.

Pyth , 78 byte ^SBCS

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

Test suite
^{Caratteri non stampabili presenti nel codice, vedere il link per la versione corretta.}
Case sensitive, non ignora gli spazi bianchi.

Perl 5 -F , 192 byte

@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

Provalo online!