Mi amigo hizo un traductor lisp el otro día, es decir, tomó una cadena y convirtió s => th y S => Th. Fue bastante largo y pensé que se podía jugar golf.

Entonces, la tarea es hacer un programa / función que tome una cadena de entrada, la traduzca a lisp y genere la cadena

Caso de prueba

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

Tenga en cuenta que no importa que h se repita todo el tiempo

Este es el código de golf, así que la respuesta más corta gana

Lithp común, 62

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

Primero, (read)la entrada (debe ser una cadena). Las cadenas en CL son secuencias que usamos mappara iterar en cada carácter. El primer argumento para maprepresenta el tipo de resultado (por ejemplo, podría construir una lista a partir de un vector). Cuando es nil, alias (), los resultados se descartan. La función que se asigna a la entrada simplemente princ(imprime de forma no legible) cada carácter, excepto los que deben reemplazarse.

Retina, 9 bytes

S
Th
s
th

Pruébalo en línea!

La respuesta obvia.

JavaThcript ETh6, 38 bytes

Al principio fui con la solución obvia

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

Pero lo jugué 4 bytes

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

Esto utiliza el iindicador regex , que busca patrones que no distinguen entre mayúsculas y minúsculas. Lo bueno de Javascript es que puede especificar una función anónima para manejar el reemplazo (regex).

Pruébalo aquí

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

La respuesta obvia.

$ 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

Jalea , 13 bytes

“Ss”,“Th“th”y

Destrozando el nuevo y delgado átomo de trantilato de Jelly. Pruébalo en línea!

Python 3 - 40 bytes

Primero golf!

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

Utiliza el método de traducciónstr del módulo que acepta una tabla de traducción. La tabla de traducción es simple con código clave como claves y en su lugar como valor.dictstr

JavaThcript ETh6, 43 byteth

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 bytes

Ís/th
ÍS/Th

Pruébalo en línea!

Con un idioma que hice. No está terminado, pero es realmente bueno en la regekth.

C, 50 bytes

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

Reemplazar \1con un \x01byte real .

jimmy23013 guardó un byte, ¡y luego salvé dos más usando su enfoque! Gracias.

05AB1E, 14 12 bytes

's„th:'S„Th:

La respuesta directa.

Pruébalo en línea

Guardado 2 bytes gracias a @Adnan

Java, 71 65 bytes

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

Primer intento de jugar al golf, entonces, ¿por qué no con Java?

GNU AWK, 31 bytes

Simplemente usando la gsubfunción para traducir S inferior o superior a través de expresiones regulares e imprimirlo después. Puede trabajar con archivos, o stdincomo en este caso

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

CJam, 15 bytes

q"sS""thTh"2/er

Pruébalo aquí.

Explicación

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")

¡Se eliminaron 4 bytes con la ayuda de @DenkerAffe !

C # 6.0 - 58 bytes

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

Toma la cadena de entrada como argumento para la función.

Haskell, 36 bytes

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

Óxido, 46 ​​bytes

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

Pruébalo en línea!

PHP, 42 bytes

si se ejecuta desde un archivo:

<?=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"));}}

Tenga en cuenta que este es un programa completo a diferencia de la respuesta anterior de Java .

Bonificación (se debe alimentar al preprocesador C, ELE, el preprotetro primero):

#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"));}}

Pyth, 14 bytes

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

Banco de pruebas

¡Gracias a @LeakyNun por detectar un error tipográfico!

MATL , 17 bytes

115'th'YX83'Th'YX

Pruébalo en línea!

Explicación

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

Lenguaje GameMaker, 74 bytes

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

Matlab, 39 bytes

Un enfoque directo:

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

Emacth Lithp, 61 bytes

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

Emacs Lisp intenta ser inteligente al reemplazar texto, pero esa inteligencia se rompe cuando la cadena reemplazada solo ocupa un espacio, es decir, la letra mayúscula S. Para evitar que esto convierta "Sam y Sally" en "THam y THally", la palabra completa se compara en su lugar. Sin embargo, esto también maneja "SAM y Sally" de la manera que uno desearía, es decir, producir "THAM y Thally".

código de máquina x86, 19 bytes

En hexadecimal:

86ac3c5374043c73750440aab068aa84c075eec3

Entrada:: ESIcadena de entrada,: EDIbúfer de salida.

Desmontaje

_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

Versión original :

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

Edición final, según consenso:

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

Esto deja un gran agujero en la cuadrícula del código que no estoy muy contento. Lo investigaré cuando tenga tiempo.
El byte 49 es un espacio al final de la segunda línea, incluido para tener una cuadrícula rectangular, necesario para evitar que ccbi (y probablemente otros intérpretes) salgan e impriman una línea infinita de "Th" s.

35 Bytes de Julia:

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

Pruébalo en línea! (incluye todos los casos de prueba)

SpecBAS ThpecBATh - 53 bytes

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