Mon ami a fait un traducteur lisp l'autre jour, c'est-à-dire qu'il a fallu une chaîne et converti s => th et S => Th. C'était assez long et je pensais qu'il pouvait être joué au golf.

La tâche consiste donc à créer un programme / une fonction qui prend une chaîne d'entrée, la traduit en lisp et génère la chaîne

Cas de test

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

Notez que peu importe que h soit répété tout le temps

C'est le golf de code, donc la réponse la plus courte l'emporte

Lithp commun, 62

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

Tout d'abord, (read)l'entrée (il doit s'agir d'une chaîne). Les chaînes en CL sont des séquences que nous utilisons mappour itérer sur chaque caractère. Le premier argument à mapreprésente le type du résultat (par exemple, je pourrais construire une liste à partir d'un vecteur). Quand il est nil, alias (), les résultats sont mis au rebut. La fonction qui est mappée à l'entrée simplement princ(imprime de façon illisible) chaque caractère, sauf ceux qui doivent être remplacés.

Rétine, 9 octets

S
Th
s
th

Essayez-le en ligne!

La réponse évidente.

JavaThcript ETh6, 38 octets

Au début, je suis allé avec la solution évidente

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

Mais je l'ai joué au golf 4 octets

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

Cela utilise l' iindicateur regex , qui recherche les modèles insensibles à la casse. La bonne chose à propos de Javascript est que vous pouvez spécifier une fonction anonyme pour gérer (regex) le remplacement.

Essayez-le ici

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 réponse évidente.

$ 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

Gelée , 13 octets

“Ss”,“Th“th”y

Thhowing off Jelly'th minuscule nouvel atome de tranthlate. Essayez-le en ligne!

Python 3 - 40 octets

Premier golf!

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

Il utilise la méthode translatestr du module qui accepte une table de traduction. La table de traduction est un simple avec keycode comme clés et la place de celui-ci comme valeur.dictstr

JavaThcript ETh6, 43 octets

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 octets

Ís/th
ÍS/Th

Essayez-le en ligne!

Avec une langue que j'ai faite. Ce n'est pas fini, mais c'est vraiment bon en regekth.

C, 50 octets

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

Remplacez \1par un \x01octet réel .

jimmy23013 a enregistré un octet, puis j'ai enregistré deux autres en utilisant son approche! Merci.

05AB1E, 14 12 octets

's„th:'S„Th:

La réponse simple.

Essayez-le en ligne

Sauvegardé 2 octets grâce à @Adnan

Java, 71 65 octets

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

Première tentative de golf, alors pourquoi pas avec Java.

GNU AWK, 31 octets

Il suffit d'utiliser la gsubfonction pour traduire le S inférieur ou supérieur via l'expression régulière et l'imprimer ensuite. Peut fonctionner avec des fichiers, ou avec stdincomme dans ce cas

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

CJam, 15 octets

q"sS""thTh"2/er

Testez-le ici.

Explication

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 octets

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

Supprimé 4 octets avec l'aide de @DenkerAffe !

C # 6.0 - 58 octets

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

Prend la chaîne d'entrée comme argument de la fonction.

Haskell, 36 octets

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

Rouille, 46 octets

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

Essayez-le en ligne!

PHP, 42 octets

si exécuté à partir d'un fichier:

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

Courir comme:

~$ php [file] "This is Silly"

TI-Basic, 126 octets

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 octets

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

Notez qu'il s'agit d'un programme complet contrairement à la réponse Java précédente .

Bonus (doit d'abord être fourni au préprocesseur C LE pré- preneur):

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

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

Suite de tests

Merci à @LeakyNun d'avoir repéré une faute de frappe!

MATL , 17 octets

115'th'YX83'Th'YX

Essayez-le en ligne!

Explication

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

Python 3, 53 octets

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

Usage:

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

Tham and Thally like Thheep

GameMaker Language, 74 bytes

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

Matlab, 39 byteth

A straitforward approach:

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

Emacth Lithp, 61 byteth

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

Emacs Lisp tries to be smart when replacing text, but that smartness breaks when the replaced string only takes up one space, i.e. the capital letter S. To prevent this from converting "Sam and Sally" to "THam and THally", the whole word is matched instead. However, this also handles "SAM and Sally" in the way that one would want, i.e. producing "THAM and Thally".

x86 machine code, 19 bytes

In hex:

86ac3c5374043c73750440aab068aa84c075eec3

Input: ESI: input string, EDI: output buffer.

Disassembly:

_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

Original version :

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

Terminating edition, as per consensus :

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

This leaves a big honking hole in the code grid that I'm not very happy about. I'll look into that when I have the time.
The 49th byte is a space at the end of the second line, included to have a rectangular grid, required to prevent ccbi (and probably other interpreters) from bugging out and printing an infinite line of "Th"s.

35 Byteth of Julia:

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

Try it online! (includes all test cases)

SpecBAS ThpecBATh - 53 bytes

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