[Question]
  [
### Inspiration
The longest words that can be typed with only the left hand on a standard QWERTY keyboard are "sweaterdresses", "tesseradecades", and "aftercataracts" ([Source: Wikipedia](https://en.wikipedia.org/wiki/Longest_word_in_English#Typed_words)).
### Challenge
Given as input a "keyboard" \$K\$ and a string \$S\$ determine whether \$S\$ can be typed using only the left hand on keyboard \$K\$.
### Input
The keyboard \$K\$ will be provided as a list of 3 *rows*. You may take this input in any reasonable format (eg. a list of 3 strings, a list of 3 lists of characters, etc.), but please do not take the left-hand-side and right-hand-side of the keyboard separately, as that defeats the purpose of the challenge. 
You may assume that the input contains only lowercase letters (or only uppercase letters if you wish). Each of the three rows of the keyboard may be of any non-zero size, but each letter from `a-z` will appear only once on the keyboard.
Example 1: [`qwertyuiop`, `asdfghjkl`, `zxcvbnm`]
Example 2: [`qazwsxplkm`, `edcrfv`, `tgbyhnuji`]
The string \$S\$ may also be taken as input in any reasonable format.
### Output
Output a truthy value if the string \$S\$ can be typed using the left hand on the keyboard \$K\$ and a falsey value otherwise. 
**For the purposes of this challenge**: A word can be typed with the left hand if it is made up solely of letters appearing in the first half of each row of the keyboard. If a row contains an odd number of letters, the **middle letter is also included** in the first half. 
Using the row `asdfghjkl` as an example, the word `gafs` can be typed with the left hand.
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Make your code as short as possible.
### Test Cases
These are formatted as \$K\$, \$S\$ `->` (expected output)
```
[qwertyuiop, asdfghjkl, zxcvbnm], qazg -> true
[qwertyuiop, asdfghjkl, zxcvbnm], qpazg -> false
[p, asdfghjklqwertyuio, zxcvbnm], sxzklkl -> true
[p, asdfghjklqwertyuio, zxcvbnm], b -> false
[qazwsxplkm, edocrfv, tgbyhnuji], bad -> true
[qazwsxplkm, edocrfv, tgbyhnuji], tex -> false
[thequick, brownfx, jmpsvlazydg], brow -> true
[thequick, brownfx, jmpsvlazydg], fox -> false
```
  
[Answer]
# [Python 3](https://docs.python.org/3/), 48 bytes
Takes as input \$ K \$ and \$ S \$, the keyboard and the target string. \$ K \$ is a taken as a list of lists.
```
lambda K,S:{r.pop(0)for r in K for i in r}>={*S}
```
[Try it online!](https://tio.run/##zZLPboMwDIfve4rcAhOaJu02qXuBHnukPRAghRIIhHT8qfrsrD/Sudq0Sd1l4vLJEjb@bKcebKarl0mutpOKSpFEbB1sXk/mqda19@xLbZhhecXWDGGO0JzfVqfHzXmqTV5ZT3phyBseMN4BKWAACwzAEcgBDdR8F7CQR4hbIAEksAcy4AAUgHLpI@IeiIF3QAAVUPLdJYs30bjnvv/wv2qNK71gLhxd@m9Cf@6B39w9xP27avuxUIVaqJ346Yy39Xbk19PyFVmVrlFK/jF5Sddy/m5pKkG2GYkcadL8qhQly5Oyaf9NylJFSse53SB2PnMrQQKa9Cvy6V3Swbl/ztPSydTX4Qea6/r0hdHdQtWkxtKmDw "Python 3 ‚Äì Try It Online")
## Explanation
It essentially converts \$ S \$ and the *valid* keyboard characters \$ K' \$ into sets, and returns `True` iff \$ S \$ is a subset of \$ K' \$. To obtain only the first half of each row of \$ K \$, we use the `pop` trick, which is explained in [this](https://codegolf.stackexchange.com/a/204230/88546) answer of mine.
---
The previous answer, where \$ K \$ is taken as a list of strings instead.
# [Python 3](https://docs.python.org/3/), 54 bytes
```
lambda K,S:{*''.join(r[:-~len(r)//2]for r in K)}>={*S}
```
[Try it online!](https://tio.run/##nZDNDsIgEITvPgU3WuNPojcTfQGPHtUDFGhpKVBKW4rRV68lJiYaD6a32ex8M5vVvc2U3A5sfxkEKjFB4Lg47W5zCFe54jIy593yIego4vV6c2XKAAO4BMf4ftjf5qf7oA2XNmLRGVYdNbZvuNJwASCqCUuzvBBh8C5psSzhddQV8imM49lfYKWD@zf26X6HfPfVzhdiTJvC4q9Dke9qp0VRBiMliWFtUDbFfSabnL8gRKZglrpPzGa0anhSBCs2qpPMBZmXum4F8j15PSasJoFMhcLhCQ "Python 3 ‚Äì Try It Online")
[Answer]
# [J](http://jsoftware.com/), 22 21 bytes
```
a:=(-.>.@-:@#$])~&.>/
```
[Try it online!](https://tio.run/##jY1Li8IwAITv/ophXYzCNrrXSEVY8ORp73tI2qSPpO9X2sP@9VpERCmIh7kM880Xjx@UKLgMBF/YgU1xKH5@z6eRM3ft0AM9Ouy4/Pzb/K/oYTtuFgvphRm@4UJhz0jRybLumyjLwStfBWGsDQbrtSJNUPAhIM8AyMPwDt@Jyg7aaHODdu9BYuaYxF1lc6MTSN8rVYs6EH2YNnEEwf3Z/at9Le3svw5l0USehiizLlUWcZJXreFD7wfXbmZ4SahsUowX "J ‚Äì Try It Online")
*-1 byte thanks to FrownyFrog*
---
Takes input as boxed words, with the string to test at the end.
Reduces the list, set-subtracting `-.` the first half `-.>.@-:@#` of each row `$]` from the string to test.
Check if the result is empty: `a:=`
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
-2 thanks to Kevin Cruijssen.
```
Œµ2√§¬¨}J√ÉQ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3Fajw0sOran1Otwc@P9/tFJheWpRSWVpZn6Bko5SYnFKWnpGVnYOkF1VkVyWlJerFMtVmFiVDgA "05AB1E ‚Äì Try It Online")
# Explanation
```
Œµ          For each item of the input list:
 2√§        Split into chunks of size 2
           (conveniently, the middle character is included in the left half)
   ¬¨}      Take the head of this list
     J     Join the output string
      √É    List intersection with the input
       Q   is the input
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Unix utilities, 57 bytes
```
s()(echo ${1:0:(${#1}+1)/2});grep ^[`s $1``s $2``s $3`]*$
```
[Try it online!](https://tio.run/##fY7LUsJAEEX38xW3xixAqozBHVK40q0fYGkxr2RCJg8yeQxBvj2GFCCrbM6i@/S9zZnVvWAVNkWZRyVLsV7T988P2tvZfKaEzuEdg9XzauYdH4LTIpj7y9P8NSpVgZ@vrYUXbM9cjnzZfj96/XBOiNBpLlEvHC7BhLQ6NgqlYhIMHAJxVtQVAWQ@ABjbqDdOKX7x5F9/oh6jA/gZgmIDX6rGz2pj/g@9tzEpU/2@VWV1qOO8ALMyjPQuMeicaHiWYs@6CGRaKQaH3G1u9k2xrktMYqYlToay1rrCJCmUFGXYoIr4QWf1LgZncnJfKUcqrfZ1LBLwMm@z0GGXFrYxrDvIaJxNG2HuSH81@ovR3xl/ "Bash ‚Äì Try It Online")
The three keyboard rows are passed as arguments, and the input string is passed on stdin.
Output is the exit code (0 for truthy, 1 for falsey).
This can probably be improved with clever golfing.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
≈íH‚Ç¨Z·∏¢Ff∆ë@
```
A dyadic Link accepting a list of lists of characters on the left and a list of characters on the right which yields `1` if the right may be typed with the left hand or `0` if not.
**[Try it online!](https://tio.run/##y0rNyan8///oJI9HTWuiHu5Y5JZ2bKLD////o9ULy1OLSipLM/ML1HUU1BOLU9LSM7Kyc0CcqorksqS8XPXY/8XlqYklqUUpRanFxanFAA "Jelly ‚Äì Try It Online")**
### How?
```
≈íH‚Ç¨Z·∏¢Ff∆ë@ - Link: keys, word
≈íH‚Ç¨       - halve each
   Z      - transpose
    ·∏¢     - head
     F    - flatten
        @ - with swapped arguments:
       ∆ë  -   is invariant under?:
      f   -     filter keep
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~42~~ 34 bytes
```
r`(?<-1>.)+(?<=(\w\w)+),
,
D`\w
,$
```
[Try it online!](https://tio.run/##fc29DoMgHATwnedoE03/bdK9H0uTvoSDIIgIIgIK8vLWdjCd3C53v@Qs80Lj5Zi9y8WW2fN2vj4u@WkN96wIRchPOSBAr7IICA7LMgRm/TyK3gB2tOZNKxWkWE1EdzDgxNG@MF/yt2x6Iy4mqaTaRwStX8FFo2QHjFa2nsBzMjd6bAUQTHd3zyLyDRtGUUkgtg@6jtB2xk0Kp5nyX7cv6j5@AA "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Explanation:
```
r`(?<-1>.)+(?<=(\w\w)+),
,
```
The `r` modifier causes the regex to be processed from right to left, so that the `,` is matched first, before the lookbehind then matches as many pairs of letters as possible. .NET captures each matching pair into a stack of values for capture group `1`. The balancing group then matches once for each value in the stack, thus deleting 1 character from the end of the row for every pair of letters.
```
D`\w
```
Remove all duplicate letters.
```
,$
```
Check that no letters of `S` remain.
[Answer]
# C (GCC) ~~114~~ ~~109~~ ~~108~~ ~~105~~ 102 bytes
-3 bytes ceilingcat
```
i,h,t,r;f(char**k,char*s){for(r=1;*s;++s)for(i=3;i--;)for(h=strlen(k[i]);t=k[i][++h/2];)r*=t!=*s;i=r;}
```
[Try it online!](https://tio.run/##lZDLbtswEEX3@gpGgAHJptE47SoEmw9xjILiQ6L1oEyO/Iy/3RFpuWi5SlYzA95z7wz5suT8dtO4woAtURmvmJ3Paxyqyy/K2MzSFZk7sli43I@a/iR6uSRhqKgD28guq9d6kxOgvq4Xi@rHy4bkdk7hiY6sppZcbyAd3BMQmB6je9tqIRr5mAoDYNrHdDBWYKQ7QNxYKzn8MQP0A@TokqBJU8tTYZgV618bRNHFO0@Wk9fzlYxib8I4DKyZPEaxyh4wDlG5F/Z2lKosnblXpJa/ZwJ9oJl471Ic8zTaCr2htGfOpegVpYrpJkZwfAZJrkniN2uZ7rL7VeGX0t1BWjgN2vSjScqcUGW1rb1jej7yfdG1vt2xcznWVVj8W2B/J5//If8H/vpEpDue6yb4rb7NFlHiuP7BHfumDq9SGG7V3rdQFqeqG7Y6UEzEN36JA3mM8qCSu0HzOrhac@iUV6Tbtnf7hp1Pony8RIFfA5WZAhFKrrdP "C (gcc) ‚Äì Try It Online")
[Answer]
# Google Sheets, ~~106~~ 99 Bytes
```
=ArrayFormula(1-IsErr(Or(Find(Mid(B1,Row(Offset(A1,0,0,Len(B1))),1),Join(,Left(A:A,Round(Len(A:A)/2
```
Keyboard input is in the range `A1:A3`. The word is input in `B1`. After entering the formula, Sheets will automatically add 7 trailing parentheses.
[![enter image description here](https://i.stack.imgur.com/1e5S3.png)](https://i.stack.imgur.com/1e5S3.png)
`Join(,Left(A:A,Round(Len(A:A)/2)))` combines the left-hand side of the keyboard rows into a single string we can search later.
`Mid(B1,Row(Offset(A1,0,0,Len(B1))),1)` pulls each letter of the word, one character at a time.
`Or(Find(Mid(~),Join(~)))` searches for each character in the search string and returns the location of each (a positive integer). If it can't find the character, it returns the `#VALUE!` error. Therefore, `Or(~)` returns either `TRUE` or `#VALUE!`.
`1-IsErr(Or(~))` returns `1` for `TRUE` and `0` for `#VALUE!`.
`ArrayFormula(~)` makes all these pieces work on input and output arrays instead of individual cells. This only matters for joining the input keyboard into a string and pulling out one character at a time from the word.
---
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 51 bytes
```
k=>s=>s.every(c=>k.some(l=>l.length/l.search(c)>2))
```
[Try it online!](https://tio.run/##jZE9b8IwEIZ3fsVt2KoxKh1RsnXp0A4dIRLGcT4vsbGdD6j621MjqpKNSrZknd7nuTu5Er1w0pbGr1qdqimLpjqKXThc9cqeiYzimjvdKIJRjBxVm/tijdwpYWVBJI03lE5eOS@FUxDBYbE7Dcr6c1dqw0C4NMuLqkYGl1H2x7ZJGJzEJYdVDN526j9x85vPBLoAzHN/8Bxw46XGGu8tHhLHmT5MN7jRYN0wUKm0Wc/A58dz0XZVec2KdDb8g7BX40ztC3XqSlkHidVDm40Mqsa4HsXlnObJrXyXP4xnemY/cG/LhlDuDJaeLPftkvJGGIIQxYDh6cOPrffD0zqnlGfavopQIDt8ZoCbcF8YDNqmYZPRKOkTegW/FgBSt06j4qhzks2BhJId5/xKJZTB2@fHOzfCOkVuCkq3i2@6nX4A "JavaScript (Node.js) ‚Äì Try It Online")
Input keyboard as an array of three strings. Input the word as an array of characters.
[Answer]
# x86 32-bit machine code: ~~34~~ 31 bytes
Strategy: build a bitmap of left-hand keys with bit test-and-set ([`bts`](https://www.felixcloutier.com/x86/bts)), then loop over the input string and check against that bitmap (`bt`). 386 `bt*` instructions with a register destination mask the bit-index like shifts do, so we can use ASCII characters directly as bit indices. (0x61 .. 0x7a)
Inputs:
* EDI: `const char *str` (0-terminated C string)
* ESI: points at rows serialized into 3 back-to-back explicit-length strings in a buffer. 3x { dword length, char[] }, no indirection just flat byte stream concatenated to be loaded with lodsd / lodsb. Asm wrapper to do this conversion from an array of 3x `char*` included with the test harness on TIO.
Output: AL=first non-left-hand character (non-zero=falsy), or zero=truthy (the terminator). Assembly language can just as easily jump on non-zero as on zero [so this is justified](https://codegolf.meta.stackexchange.com/questions/2190/interpretation-of-truthy-falsey#comment9441_2194). An alternate version of this took an explicit-length string and returned 0 or 1 in the CF flag.
Clobbers: all GP registers except ESP
```
 1                                  tlh:
 2 00000000 31DB                        xor   ebx, ebx              ; left hand keys bitmap
 3 00000002 8D4B03                      lea   ecx, [ebx + 3]
 4                                  .rows:
 5 00000005 AD                          lodsd              ; length.  Upper bytes zero because each letter can appear at most once.
 6 00000006 8D2C06                      lea   ebp, [esi + eax]
 7 00000009 92                          xchg  edx, eax
 8                                    .keys:                   ; do{
 9 0000000A AC                              lodsb
10 0000000B 0FABC3                          bts   ebx, eax      ; bmap |= 1<<(c & 31)
11 0000000E 4A                              dec   edx
12 0000000F 4A                              dec   edx
13 00000010 7FF8                            jg   .keys        ; while(len-=2 > 0);  // handles the len=0 case where --len becomes negative
14 00000012 89EE                        mov   esi, ebp      ; skip 2nd half of string
15 00000014 E2EF                        loop  .rows
16                                  
17                                  ;;; If the input string indexes any bit in EBX that isn't set, it's not left-hand typeable
18 00000016 89FE                        mov   esi, edi
19                                  .chars:               ; do{
20 00000018 AC                          lodsb
21 00000019 0FA3C3                      bt    ebx, eax
22 0000001C 72FA                        jc  .chars
23                                  .exit:
24                                      ; non-zero AL means we found a non-left-hand character.
25                                      ; zero means we found the terminating 0.  ASCII 'a' = 0x61 so our bitmap always has bit 0 = 0
26 0000001E C3                          ret
```
TODO: 
* A better row input format to save instructions in the input code? (When I designed this format, I forgot about having to skip over the right half of a row that I wasn't going to read. `lea ebp, [start + len]` + `mov` was a bugfix. It would be nice to at least not need that many regs.)
* Maybe start with an all-1 bitmap and clear bits for right-hand keys? But that introduces a corner case for a row of length 1 which has no right-hand keys. Otherwise it might allow efficient looping to the end of a 0-terminated string.
I used the nice C test harness from [@Noodle9's answer](https://codegolf.stackexchange.com/questions/204581/can-i-type-this-with-my-left-hand/204604#204604). This is 32-bit asm so it would be a double pain to get something runnable on TIO.run with NASM. (You can use FASM to make a 32-bit executable directly, without a separate linker invocation, but I think that doesn't link libc. You could I guess inline a simple strlen, or hard-code some data structures to at least exit with a 0 / 1 exit status...) I put the source + asm wrapper (to adapt to a normal C calling convention), and C test harness itself [on TIO](https://tio.run/##pVZtb9s2EP7OX3FI0cVpbNdvKLIoKdZl/RCgGAZsAwZkRkCJlMVYElWSiuV0/e3ZHfViOUmxZDWMRKTueHfP89zR3FqZhel2lHOb3d@7NDllgJ9KG/wrw2pIf2DvE0AqYwcJzwWs5dZCqFzGC@@XSk5@EfpdkeMxzJdsbPTG1uemWljx@Lh85ZIxwJ9FIQ2EWyct3EmjIZQRL60EyaMEzZzD1xHPgaMhN8AdZNo60Hkkx/34YUHxrcL4klfL/ivhU@PV8XTpgxtdYh1lEdDBhw4oXBUlq8YULb23TUzrPcWNMRV@Co8/AQj9hbUrKjfsVqGzHai8au1DxA7@OYfp2dkggh9gPj3qPISM6qjdzg0mVkffRdwkKpWD0QhxhPcwOQoA3r71/KQIpEskIXw@wQKxtk0ijYTaGOHVGZrkcsWdupU@SqZvKaZVRH3RxrBrVcAMkUp4GoOOwTqj8lVDqkY7zzJjQRDAZeyjqrwoXWOICyErjMXzLQkG1/Dx57/QDklUlpC30g1BuUPMRzuvsZHXmNsi2WH6ODuh2DhKuHlExI6EHQGhgx74fusGwa0PYGNZKVdLNMDw@cjL78MnyCTPLWwkxF4n3L/c5UbePEJZjhtf7/fAibBAk0zliDJCMUGpf/j94vISDvkhnMOkejcFq0GXpukl4OmGI8UJ990FE7LyEYx0jDFZ4Xk5QYs0MsZTtcph@o6tUh3yFLCNrzeGmsSw3vNpB0@odQrxINI5dg/VAG/WobiaL4fQ38Pzay0WpU1IDTsKfItJW7CgiXltHTeOBfX/075b1VtY1VsggXVzlSFxiidOZye9GEL5GG3SpUprMAV3nIovI1eimGOjM5jDRSM1u5tgewMsAG4aHQ7BZ0lkoPxiZbBk7KlQcyNaZY8JXVT2aS8hkt0VdcUxnCwf7dfzJqzeLJYseNJpOttZPMIk4mnaUNrydAlCCeqNKJHRGuVkKHF88oxnMnfYw7grvTPK6o9EkWqQbRSg07DRpnXzUvFBqVtxpvTbpcyyLb2o6XB6f0gHfuCikutJ3Ss86rWTkYXftmHnlsksKrZ1k2e@8/1s94QRkS1lQ@DilucREfLxl0t/nMoj6MQTZUXD5rxu3ZTGYMMQYw80Q2gfT2cPGSK5dkBjX8CT8xuvGZxCOHrxdL3FIfUboq0xsY1yCWhM22Cpjco8zTi4IrSBp8/Dji2xV6nlcCzQ3PvwyfsiEg7dhjxlzSl3uKxr4UI86IiGNdVb2P4Cgeqvit20qBuU7RqTEEHS6ptMoYYm1cmE1ZKlxn8D62tK7mqJY@fLweeNNG5bKl0cDOGAWxGvkpt1Sou7KroN8@zga9D3Brvnzu9WZPu5oAe0vMfLySvgp1@1xivqx0O6FSxGaQWM3wt/CeCPkgDoEnF@Gy9@hKnAkeuw6/HSG7NXKJO0FBLOrBNKj5P3@1sEO20yP/J6w/BZwy9gr4SMVY7R9oYqI9QyrvLBEdQXzc7zf6H38Ij/gNATjY3j4sHBawv@@3eOJk3oybJ7nO4eZ8uj2hUHwoAqUOeTANTZLIDjY9VWUvceXscYOh7UrsM2H9Ue8SCD0Xt4LWDwWhz5NDprfMTv@fl0pBrHr9@Aa9bUug9Th95TePWRat1tdbdOa3jDZyA160E162E1@w6wZsMupxfBNXsRXvOdNja2KtJ1RjVLoSMT39KjW4XbJC9v1JN4te4hF95YVs9Aa95Da95Da/4daM2HXUYvQmv@IrQWTbk4vT@XKlp7feAP1jyu6PEmK@xtyu@2YvUkWq07uZB9rJ8D16IH16IH1@I74FoMu5ReBNfiG3B9Zff/Ag "Assembly (nasm, x64, Linux) ‚Äì Try It Online") even though you can't actually try it there.
```
$ nasm -f elf32 -l/dev/stdout type-left-hand.asm &&
 gcc -Wall -fno-pie -no-pie -m32 type-left-hand.[co] &&
 ./a.out
qwertyuiop asdfghjkl zxcvbnm
qazg -> 1 (1)
qpazg -> 0 (1)
p asdfghjklqwertyuio zxcvbnm
sxzklkl -> 1 (1)
b -> 0 (1)
qazwsxplkm edocrfv tgbyhnuji
bad -> 1 (1)
tex -> 0 (1)
thequick brownfx jmpsvlazydg
brow -> 1 (1)
fox -> 0 (1)
```
`0 / 1 (1)` means *left-hand typeable (matches the correct result)* 
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~116~~ \$\cdots\$ ~~108~~ 104 bytes
Saved 4 bytes thanks to [rtpax](https://codegolf.stackexchange.com/users/85545/rtpax)!!!  
Saved 4 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! 
```
c;p;l;r;i;f(char**k,char*s){for(r=1;*s;++s)for(i=3;i--;r&=l>p*2)for(l=p=0;c=k[i][l];++l)p=c-*s?p:l;c=r;}
```
[Try it online!](https://tio.run/##pZLtboIwGIX/7yoaEhdASLTwa13dhTiyYPmqVKgtKmq8dkcREDeXYWya8Jae0573SYkdE3I@E8QRQwJRFOkk8YVpplb9lcYxyoUu8BSZEo3H0lBLih1EbRuJV8xm3IT1T4Y5niCC0zn15syrxMzgmNim/OBvrNoQ6HRe@TTTDXB8AdWobwDpVxHKYu4BDI7aeheKYr@hOdcsoPkyiOJkmTK1OJRku8hW2gn1zEDeuP1DrKRrropGyAXNikjXRhLU8zOrJM2lE68rp9cSesbFWveaFYBWjQH6DhEYj2mbXg21KaurI/1itdo8tD3iRwJ7BkYB0EeBUcfo1FVZTYynNm2Mp1@IYNPlLZqO2H@MWrssDym7IF0MYAR7kGCPEnwCE7S6TA@BggNJOdf3sJMlZ@lKdRsGORHRVpVFvNgn2WZJ75Jq7Qs/qMVhOYCT0@Pk9Dg5T3ByrC7RQ5ycgZzcptEiCdcbStL6TYh8l0WlKpcrLrfMP@yD@C6n1q4sSh/lQ0C5PVBuD5T7BCjX6iI9BMr9A9Tp/A0 "C (gcc) ‚Äì Try It Online")
Takes the keyboard as an array of strings and the word as a string.  
Returns \$1\$ for true and \$0\$ otherwise.
[Answer]
# Haskell, 69 bytes
```
x l=take(length l`div`2)l;l k s=all(\c->elem c$foldl(++)[]$map x k)s
```
Use (in `ghci`):
```
$ let kbd = ["qwertyuiop","asdfghjkl;","zxcvbnm,./"]
$ l kbd "stewardesses"
=> True
$ l kbd "joker"
=> False
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~56~~ 63 bytes
```
k=>s=>s.All(c=>k.Any(l=>(uint)l.IndexOf(c)/(float)l.Length<.5))
```
[Try it online!](https://tio.run/##nZIxa8MwEIXn@lccpoMEjjt1SmwIpYWUQIcOHUIGWZZsRYqUWHLi2Pi3p1YSCk02g4Z7uvvuCZ6onVArzh@1prPFu663rCKZYjPrKqGLNIJL56oiyIxRaQockrNMUjuceK4Uokkq47k@IZWkqBbaYRUvdM6aL44ofkFcGeLvlkwXrpzFrxifp0FwIBU4Zp2FBDQ7rtZBFzyhSwUdhPsjq9ypFmYXRhASm/Oi3EjlRdvQQ6a3IfSD2JO2CHE0Ct09sv@Rv00PrG1aqYad4@js/sWkPdpmp@TWj7Lc0IoffOmK7FTqeiNuHMlHko41d6Qr2b4WVPrhrDJHzRtfbrY7e1CkPeXFzXPojUS5GUyDfhpwUzFCS0A@dCQjsBiEvsaPfe5vRlujWPxTCceWQjP0HK6678vHiz@N0MgbRCBxv46gsz1MUug4khhZ3Id4GvTnXw "C# (Visual C# Interactive Compiler) ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~72~~ 71 bytes
```
function(k,s)all(t(sapply(k,function(x)match(s,x,0)))<(lengths(k)+2)/2)
```
[Try it online!](https://tio.run/##jc@xEoIwDAbgWR6jU3L21GPWZ/EKFMHWgjQq@PL111MGJodvSPO3SYfkbS3HxoTqkOpbKKXtAjkd2XhPQtH0vZ9wMPdGvhgpG4p61Dtm3pO34SRNJMfrnLc5J2enojNDtfFWxA7x4NsolK1KUlel1QMsDCAwwQ1a6KBXrD9hgyJCBTWcoIEzOPC/4BPFCCXcoYAAF8WczR@k5V76u9B7zvPz/l/xfnElvQA "R ‚Äì Try It Online")
[Answer]
# JavaScript (ES6), 53 bytes
Takes input as `(keyboard)(word)`. Returns a Boolean value.
```
k=>w=>!w.match(`[${k.map(r=>r.slice(-r.length/2))}]`)
```
[Try it online!](https://tio.run/##ndHNasQgEAfwe5/CSg8Kuwn0nn2RZWGNUZNo1Kj5LH32NDZQaBc2obcRmZ//GWvSE09dZcNZm4ItPFtkdhmyy@uQNCTQEt2vbx9yrS1y2cUlXlWUobNLFNMilOk7xp@3O16o0d4oligjEEdX2A7MhamrjIUnAIkvuChrqeJhHmmf6wbeMIItmQUEAGAM0hQE17GX/0p2ozaJE@Ufqd/CD/yX8uMs1frCk1AHpTzOBp6HWlcw@NEq2cRuVlDH@1gFkU@l7uoKgm@KFBDsbOqYFNgI90KFkrVdRWVsz50ZNB9jWTfW94rMUyG2@darne87KHHzEGr5Ag "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes
```
‚¨§Œ∑‚äôŒ∏‚Ññ‚Ä¶Œª‚äò‚äïÔº¨ŒªŒπ
```
[Try it online!](https://tio.run/##FYixDsIgFEV/hTA9E/wCp6aLJg7uTQekT0BfoVCK0p9HepZ77lFGRuUl1fqI1iXoiMAI1rkCQbDeb631RRH2xi9Agl0lZZzg5lTEGV1qfkenkwE6NQSzx1xqHQYevhhT2axfuGBcrtNLm/eHjrP/VH66mY/Ng9w1H@s50x8 "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Takes input as a list and a string. Output is a Charcoal boolean, i.e. `-` for true, nothing for false. Explanation:
```
 Œ∑              Input S
‚¨§               All characters 
   Œ∏            Input `K`
  ‚äô             Any row
      Œª         Current row
     ‚Ä¶          Truncated to
       ‚äò‚äïÔº¨Œª     Half its length rounded up
    ‚Ññ      Œπ    Contains input character
                Implicitly print
```
[Answer]
# [Python 3](https://docs.python.org/3/), 53 bytes
```
lambda k,w:all(max(map(r.find,w))<len(r)/2for r in k)
```
**[Try it online!](https://tio.run/##nZHdasQgEIXv@xTeRcF2ob0pS9sXaffCxJgYf2NMNHn5NLNbChsolAwI5@D5ZsTxc2ydfXn1YRXvX6tmpuQMKZrOTGtsWN6Ox@FJSMtpIuRN1xYHcnoWLqCApEWKrKAVRQksfkA/hT@LPtUhzqN0vqCoYAMXTdspDWbJ1VRaU1w23bOlKQj9J9l7iP/B3cd/u@wnDnlRemt3CC73b2VLGrLXykCy5lUQE6jYlHNrx07eKMYPcbHOOy62dT/KSkG2DC5ZkUF2xg@TZsvMb78DV8dI4e5GkvNV@iBtxLDnLfL4sYHi6ghZvwE "Python 3.8 ‚Äì Try It Online")**
[Answer]
# [Python 2](https://docs.python.org/2/), ~~57~~ 55 bytes
*-2 bytes thanks to @ovs !*
```
lambda k,s:all(t.find(c)*2<len(t)for t in k for c in s)
```
[Try it online!](https://tio.run/##jZBNkoMgEIX3OUUXK52QLLJMjXMRx6qgghIRCY2JenkHYn7cZXbd9Pdev8aMru70YRbJ76xYm5cMGopHplTk9kLqMirir8O34jpysegsOJAaGghlEUqMZ9mazjrAETfhWUnN75MR9@hKqY8bAKTANN64hQRaZiJ01g@tNPTO79Eo6SKy@yFx7HFGc1pQ9HDqFi4iaQYkhlcGfGooiTMvaQJ814XutexZJECc7TnxM8uxV87PRORvDeuMldr5w0PMkIE@GN@lZHtamiRZvE5bkpE5vfjSjb3s/AkMS1HV50ZRmIbimus2o3BhUwW7HwhrN//AzYMXTKEXrLmXeC3AYWpUo94rPirylb1Pd8PBqKalwMvCiisFV@VjrfuzDCwrV@E/wI4PK2tX80svC/@due1uWgwUzq3Bq2LTWFbZ8vw2/4iL7u3@Bw "Python 2 ‚Äì Try It Online")
]