Meu amigo fez um tradutor de lisp no outro dia, ou seja, pegou uma string e converteu s => th e S => Th. Era bastante longo e eu pensei que poderia ser jogado golfe.

Portanto, a tarefa é criar um programa / função que pegue uma string de entrada, traduza-a para lisp e produza a string

Caso de teste

Sam and Sally like Sheep        Tham and Thally like Thheep
Sally likes sausages            Thally liketh thauthageth
Sally sells seashells           Thally thellth theathhellth

Observe que não importa que h seja repetido o tempo todo

Este é o código de golfe, então a resposta mais curta ganha

Lithp comum, 62

(map()(lambda(u)(princ(case u(#\s"th")(#\S"Th")(t u))))(read))

Primeiro, (read)a entrada (deve ser uma string). Seqüências de caracteres em CL são sequências, por isso usamos mappara iterar em cada caractere. O primeiro argumento para maprepresenta o tipo do resultado (por exemplo, eu poderia criar uma lista a partir de um vetor). Quando é nil, também conhecido (), os resultados são descartados. A função que é mapeada para a entrada simplesmente princ(imprime de forma não legível) cada caractere, exceto os que devem ser substituídos.

Retina, 9 bytes

S
Th
s
th

Experimente online!

A resposta óbvia.

JavaThcript ETh6, 38 bytes

No começo eu fui com a solução óbvia

a=>a.replace(/s/g,'th').replace(/S/g,'Th')

Mas joguei 4 bytes

a=>a.replace(/s/gi,b=>b>'r'?'th':'Th')

Isso faz uso do isinalizador regex , que procura padrões que não diferenciam maiúsculas de minúsculas. O bom do Javascript é que você pode especificar uma função anônima para manipular (regex) a substituição.

Experimente aqui

f=
a=>a.replace(/s/gi,b=>b>'r'?'th':'Th')

s.innerHTML = [
    'abScdsefSghsij',
    'Sam and Sally like Sheep',
    'Sally likes sausages',
    'Sally sells seashells'
].map(c=>c + ' => ' + f(c)).join`<br>`

<pre id=s>

GNU Sed - 17

s/S/Th/g;s/s/th/g

A resposta óbvia.

$ sed -e "s/S/Th/g;s/s/th/g"

Sam and Sally like Sheep
Tham and Thally like Thheep

Sally likes sausages
Thally liketh thauthageth

Sally sells seashells
Thally thellth theathhellth

Gelatina , 13 bytes

“Ss”,“Th“th”y

Exibindo Jelly, o novo átomo de tranthlato. Experimente online!

Python 3-40 byteth

Primeiro golfe!

lambda s:s.translate({115:'th',83:'Th'})

Ele usa o método de conversãostr do módulo que aceita uma tabela de conversão. A tabela de conversão é simples, com código-chave como chave e o lugar dela como valor.dictstr

JavaThcript ETh6, 43 bytes

s=>s.replace(/s/gi,m=>({s:'th',S:'Th'})[m])

Tetht Thuite:

th=s=>s.replace(/s/gi,m=>({s:'th',S:'Th'})[m])
  
console.log(th('Sam and Sally like Sheep'));
console.log(th('Sally likes sausages'));
console.log(th('Sally sells seashells'));

V , 11 byteth

Ís/th
ÍS/Th

Experimente online!

Com a linguagem que eu criei. Não está terminado, mas é realmente bom em termos de regimento.

C, 50 bytes

s(c){c=getchar();c+=c-83&95?0:'h\1';s(printf(&c));}

Substitua \1por um \x01byte real .

jimmy23013 salvou um byte e depois salvei mais dois usando sua abordagem! Obrigado.

05AB1E, 14 12 bytes

's„th:'S„Th:

A resposta direta.

Experimente online

Guardado 2 bytes graças a @Adnan

Java, 71 65 bytes

String t(String s){return s.replace("S","Th").replace("s","th");}

Primeira tentativa de jogar golfe, então porque não com Java.

GNU AWK, 31 bytes

Basta usar a gsubfunção para traduzir S inferior ou superior via regex e imprimi-lo depois. Pode trabalhar com arquivos ou stdincomo neste caso

$ awk '{gsub(/s/,"th");gsub(/S/,"Th")}1' <<< "This is Sparta"                   
Thith ith Thparta

CJam, 15 bytes

q"sS""thTh"2/er

Teste aqui.

Explicação

q      e# Read input.
"sS"   e# Push string.
"thTh" e# Push string.
2/     e# Split into pairs, i.e. ["th" "Th"].
er     e# Transliteration, replaces 's' with 'th' and 'S' with 'Th'.

Python3 - 46 bytes

lambda s:s.replace("s","th").replace("S","Th")

Queda de 4 bytes com a ajuda de @DenkerAffe !

C # 6.0 - 58 bytes

string f(string s)=>s.Replace("s","th").Replace("S","Th");

Leva a string de entrada como um argumento para a função.

Haskell, 36 bytes

f 's'="th";f 'S'="Th";f x=[x]
(>>=f)

Ferrugem, 46 bytes

|s:&str|s.replace("s","th").replace("S","Th");

Experimente online!

PHP, 42 bytes

se executado a partir de um arquivo:

<?=strtr($argv[1],["s"=>"th","S"=>"Th"]);

Correr como:

~$ php [file] "This is Silly"

TI-Basic, 126 bytes

Input Str1
inString(Str1,"s
While Ans
sub(Str1,1,Ans-1)+"th"+sub(Str1,Ans+1,length(Str1)-Ans->Str1
inString(Str1,"s
End
inString(Str1,"S
While Ans
sub(Str1,1,Ans-1)+"Th"+sub(Str1,Ans+1,length(Str1)-Ans->Str1
inString(Str1,"S
End
Str1

Java, 101 bytes

interface a{static void main(String[]A){System.out.print(A[0].replace("S","Th").replace("s","th"));}}

Observe que este é um programa completo, diferente da resposta Java anterior .

Bônus (deve ser alimentado primeiro ao pré-processador C THEE pré-processador ):

#define interfaith interface
#define thtatic static
#define Thtring String
#define Thythtem System
#define replaith(x,y) replace(x,y)

interfaith a{thtatic void main(Thtring[]A){Thythtem.out.print(A[0].replaith("S","Th").replaith("s","th"));}}

Pitão, 14 bytes

::z\s"th"\S"Th

Suíte de teste

Obrigado a @LeakyNun por detectar um erro de digitação!

MATL , 17 bytes

115'th'YX83'Th'YX

Experimente online!

Explicação

115    % 's' (ASCII)
'th'   % String 'th'
YX     % Regex replacement
83     % 'S' (ASCII)
'Th'   % String 'Th'
YX     % Regex replacement

Python 3, 53 bytes

def l(s):return s.replace("s","th").replace("S","Th")

Uso:

>> l('Sam and Sally like Sheep')

Tham and Thally like Thheep

Idioma do GameMaker, 74 bytes

return string_replace_all(string_replace_all(argument0,'s','th'),'S','Th')

Matlab, 39 byteth

Uma abordagem direta:

@(t)strrep(strrep(t,'s','th'),'S','Th')

Emacth Lithp, 61 bytes

(lambda(s)(replace-regexp-in-string"[Ss]\\(\\w*\\)""th\\1"s))

O Emacs Lisp tenta ser inteligente ao substituir o texto, mas essa inteligência é interrompida quando a sequência substituída ocupa apenas um espaço, ou seja, a letra maiúscula S. Para impedir que isso converta "Sam e Sally" em "THam e THally", a palavra inteira é correspondido. No entanto, isso também lida com "SAM e Sally" da maneira que se deseja, ou seja, produzindo "THAM e Thally".

código de máquina x86, 19 bytes

Em hexadecimal:

86ac3c5374043c73750440aab068aa84c075eec3

Entrada:: ESIsequência de entrada,: EDIbuffer de saída.

Desmontagem:

_loop:
0:  ac          lodsb       
1:  3c 53       cmp al,'S'  
3:  74 04       je _th      
5:  3c 73       cmp al,'s'  
7:  75 04       jne _nth    
_th:
9:  40          inc eax     ;[Ss]->[Tt]
a:  aa          stosb       
b:  b0 68       mov al,'h'  
_nth:
d:  aa          stosb       
e:  84 c0       test al,al  
10: 75 ee       jnz _loop   
12: c3          ret         

Befunge 98, 37 49 bytes

Versão original :

~:"s"- #v_$"ht",>,
_;#-"S":<;$"hT",^ 

Edição final, conforme consenso:

~:a-!#@_:"s"-#v_$"ht",>,
_;#-"S":      <;$"hT",^ 

Isso deixa um grande buraco na grade de código que eu não estou muito feliz. Vou investigar isso quando tiver tempo.
O 49º byte é um espaço no final da segunda linha, incluído para ter uma grade retangular, necessária para impedir que o ccbi (e provavelmente outros intérpretes) espreite e imprima uma linha infinita de "Th" s.

35 Byteth of Julia:

s->replace(s,r"s"i,s->"$(s[1]+1)h")

Experimente online! (inclui todos os casos de teste)

SpecBAS ThpecBATh - 53 bytes

1 INPUT a$: ?REPLACE$(REPLACE$(a$,"S","Th"),"s","th")