Bash + coreutils, 46

tr b-zB-Z ${a=typetjkitkpstokrtyputjkyb}${a^^}

Try it online!

05AB1E, 24 bytes

ži.•ÜÁ©;«ìñä°ÔG·ÖYΘ•Du«‡

Explanation:

                       ‡   transliterate

ži                         a-zA-Z with

  .•ÜÁ©;«ìñä°ÔG·ÖYΘ•       atypetjkitkpstokrtyputjkyb

                    Du«    concatenated with itself, uppercased

Try it online!

Charcoal, 42 bytes

≔”$⌊∧Ｔ-¶I^F⁷ü@n⁹γ›7η”η⭆θ⎇№β↧ι§⎇№βι↧ηη⌕β↧ιι

Try it online! Link is to verbose version of code. Explanation:

≔                       Assign

 ”$⌊∧Ｔ-¶I^F⁷ü@n⁹γ›7η”  Compressed string `ATYPETJKITKPSTOKRTYPUTJKYB` 

                     η  To variable



 θ                      Input string

⭆                       Map over characters and join

  ⎇                     If

    β                   Lowercase alphabet

   №                    Contains

      ι                 Current character

     ↧                  Lowercased

                        (Then)

        ⎇               If

          β             Lowercase alphabet

         №              Contains

           ι            Current character

                        (Then)

             η          Variable

            ↧           Lowercased

                        (Else)

              η         Variable

       §                Indexed by

               ⌕        Index of

                  ι     Current character

                 ↧      Lowercased

                β       In lowercase alphabet

                        (Else)

                   ι    Current character

                        Implicitly print

T-SQL, 107 Bytes

SELECT TRANSLATE(v,'bcdfghjlmnpqrstvwxzBCDFGHJLMNPQRSTVWXZ',

                   'typtjktpstkrtyptjkbTYPTJKTPSTKRTYPTJKB')FROM t

Line break and indent are for readability only.

Uses the SQL 2017 function TRANSLATE for character replacement.

Unfortunately had to put (almost) the entire alphabet in there twice to maintain casing. There are probably better ways, maybe something that handles the t's as a group, but this worked for me.

Input is via a pre-existing table t with varchar column v, per our IO rules.

In this case the table must be created using a case-sensitive collation, either by running on a case-sensitive server, or by using the COLLATE keyword (not counted toward character total):

CREATE TABLE t(v varchar(999) COLLATE Latin1_General_CS_AS)

JavaScript (Node.js), 100 bytes

s=>s.replace(/[a-z]/gi,c=>(C='_atypetjkitkpstokrtyputjkyb'[Buffer(c)[0]&31],c>{}?C:C.toUpperCase()))

Try it online!

s =>                                  // s = input string

  s.replace(                          // replace in s ...

    /[a-z]/gi,                        // ... all letters, no matter the case

    c => (                            // for each letter c:

      C =                             //   pick a replacement letter C

        '_atypetjkitkpstokrtyputjkyb' //   from a 1-indexed lookup string

        [Buffer(c)[0] & 31],          //   using the 5 lowest bits of the ASCII code of c

      c > {} ?                        //   if the original letter was in lower case:

        C                             //     use the replacement letter as-is

      :                               //   else:

        C.toUpperCase()               //     convert it to upper case

    )                                 // 

  )                                   // end of replace()

R, 79 bytes

function(x)chartr("b-zB-Z",paste0(y<-"typetjkitkpstokrtyputjkyb",toupper(y)),x)

Try it online!

Only 3 bytes shorter than literally typing both lower- and uppercase replacement strings together...

R, 79 bytes

function(x,`[`=chartr)"B-Z"[toupper(y),"b-z"[y<-"typetjkitkpstokrtyputjkyb",x]]

Try it online!

Fancier code, same byte count.

Perl 5 -p, 54 bytes

eval"y/B-Zb-z/".uc($a=typetjkitkpstokrtyputjkyb)."$a/"

Try it online!

Ruby, 55 bytes

$_.tr!"b-zB-Z",(x="typetjkitkpstokrtyputjkyb")+x.upcase

Try it online!

J, 78 61 bytes

-17 bytes thanks to FrownyFrog!

rplc(u:,98 66+/i.25);"0(,toupper)@'typetjkitkpstokrtyputjkyb'

Try it online!

K (ngn/k), 87 63 61 60 59 57 bytes

{`c$x-a-@[!128;98+!25;:;"typetjkitkpstokrtyputjkyb"]a:_x}

Try it online!

{ } function with argument x

_ to lowercase

a: assign to a

!128 the list 0 1 2 ... 127

@[!128; indices ;:; values ] amend it by replacing the elements at indices with the given values

98+!25 the list 98 99 100 ... 122 which are the ascii codes for "bcd...z"

juxtaposition is indexing, so we use a (implicitly converted to integers) as indices in the amended list

x-a- subtract from a, then subtract form x; this restores upper/lowercase as in the original string

`c$ convert to characters

C# (Visual C# Interactive Compiler), 151 83 bytes

n=>n.Select(a=>char.IsLetter(a)?(char)(" ATYPETJKITKPSTOKRTYPUTJKYB"[a%32]|a&32):a)

Try it online!

Saved a whopping 68 bytes thanks to Pietu1998!

Retina 0.8.2, 59 bytes

[a-z]

 $&

T`l`L

T`L`ATYPETJKITKPSTOKRTYPUTJKYB

T`L `l_` .

Try it online! Link includes test cases. Explanation:

[a-z]

 $&

Prefix a non-ASCII character to each letter. (I tried to use a non-breaking space but Firefox might have changed it back to a regular space after copying and pasting.)

T`l`L

Uppercase all of the letters.

T`L`ATYPETJKITKPSTOKRTYPUTJKYB

Convert the letters to Corpus.

T`L `l_` .

Lowercase the letters after the non-ASCII character and delete the non-ASCII character.

Naïve solution is 63 bytes:

T`lL`atypetjkitkpstokrtyputjkybATYPETJKITKPSTOKRTYPUTJKYB

Try it online! Link includes test cases.

Python 2, 115 bytes

lambda i:i.translate(''.join(a))

a=map(chr,range(256))

b='typetjkitkpstokrtyputjkyb'

a[66:91]=b.upper();a[98:123]=b

Try it online!

Adapted from @ElPedro's answer. This generates the replacement for every ascii character in the array a and then uses str.translate.

Can be brought to 113 bytes if returning an array of chars is acceptable:

lambda i:[a[ord(x)]for x in i]

a=map(chr,range(256))

b='typetjkitkpstokrtyputjkyb'

a[66:91]=b.upper();a[98:123]=b

Try it online!

Jelly, 29 bytes

“qḍỊYl4ḃ©ƭṄxḳ½Dy’ṃⱮØA,Øa¤⁺żẎy

Try it online!

Japt, 37 bytes

;®i`…ypetjkŠkp¡okrtyp©jkyb`pu)gCpu bZ

Try it online!

The above link includes most test cases, but I haven't been able to input the second to last one as a string because it contains both single and double quotes. Here is that test case, input as an array of characters instead.

Explanation:

;                                        #Set C to the lowercase alphabet

 ®                                       #For each character Z of the input:

                                   bZ    # Find its index in:

                               C         #  The lowercase alphabet

                                pu       #  Plus the uppercase alphabet

                                         #  (-1 if it is not a letter)

                              g          # And get the character at that index in:

   `…ypetjkŠkp¡okrtyp©jkyb`              #  Get the lowercase Corpus alphabet

                           pu)           #  Plus the uppercase Corpus alphabet

  i                                      #  Add Z at the end (index -1)

Python 2, 138 132 bytes

def f(i,a='bcdfghjlmnpqrstvwxz',b='typtjktpstkrtyptjkb'):a+=a.upper();b+=b.upper();return''.join((x,b[a.find(x)])[x in a]for x in i)

Try it online!

Actually shorter with a named function than with a lambda!

lambda version, 138 bytes

lambda i,a='bcdfghjlmnpqrstvwxzBCDFGHJLMNPQRSTVWXZ',b='typtjktpstkrtyptjkbTYPTJKTPSTKRTYPTJKB':''.join((x,b[a.find(x)])[x in a]for x in i)

Try it online!

131 125 if we are allowed to return an array of characters and have the join outside the function.

def f(i,a='bcdfghjlmnpqrstvwxz',b='typtjktpstkrtyptjkb'):a+=a.upper();b+=b.upper();return[(x,b[a.find(x)])[x in a]for x in i]

Try it online!

PHP, 100 bytes

Code

<?=strtr($argv[0],($u=bcdfghjklmnpqrstvwxyz).($f=strtoupper)($u),($v=typtjktkpstkrtyptjkyb).$f($v));

Try it online!

Explanation

# using the provided character mapping given on the question, as an array

strtr($argv[0],                                  # strtr for the string replacement

($u=bcdfghjklmnpqrstvwxyz).($f=strtoupper)($u),  # Taking onthe the keys for the first string

($v=typtjktkpstkrtyptjkyb).$f($v));              # Using the values for second string

 # In both Strings appending the upper version of each string.

Pyth, 35 Bytes

XQ.*m+r1dd[tG."byàHuH¯¹e?rJyfh

Try it!

Could probably use Left map or something to get rid of the two d's, but I couldn't figure out how.

Java, 211 Bytes

a->{String b="BCDFGHJLMNPQRSTVWXZbcdfghjlmnpqrstvwxz",c="TYPTJKTPSTKRTYPTJKBtyptjktpstkrtyptjkb";a.chars().map(x->{int z;return(z=b.indexOf(x))>-1?c.toCharArray()[z]:x;}).forEach(x->System.out.print((char)x));};

Try it online!

Pyth, 34 chars

J."byàHuH¯¹e?rJyfh"XXztGJrtG1rJ1

Try it online!

The string is a compressed version of "typetjkitkpstokrtyputjkyb". For some reason I cannot get Pyth to compress "atypetjkitkpstokrtyputjkyb" with the function

+++.N++hSzeSzCi-RChSzCMz-hCeSzChSzN

Tcl, 114 bytes

proc C s {string map [split {btcydpftgjhkjtlpmsntpkqrrtsytpvtwjxkzbBTCYDPFTGJHKJTLPMSNTPKQRRTSYTPVTWJXKZB} ""] $s}

Try it online!