[Question]
  [
Inspired by [this](https://codegolf.stackexchange.com/questions/125470/multiply-two-strings) challenge (thanks @cairdcoinheringaahing for the title!), your task is to take two printable ASCII strings and multiply them element-wise with the following rules.
### How does it work?
Given two strings (for example `split` and `isbn`) you will first, truncate the longer one such that they have equal length and then determine their [ASCII codes](https://en.wikipedia.org/wiki/ASCII#Printable_characters):
```
split -> spli -> [115, 112, 108, 105]
isbn  -> isbn -> [105, 115,  98, 110]
```
The next step will be to map them to the range `[0..94]` by subtracting `32` of each code:
```
[115, 112, 108, 105] -> [83, 80, 76, 73]
[105, 115,  98, 110] -> [73, 83, 66, 78]
```
Now you will multiply them element-wise modulo `95` (to stay in the printable range):
```
[83, 80, 76, 73] ⊗ [73, 83, 66, 78] -> [74, 85, 76, 89]
```
Add `32` to get back to the range `[32..126]`:
```
[74, 85, 76, 89] -> [106, 117, 108, 121]
```
And the final step is to map them back to ASCII characters:
```
[106, 117, 108, 121] -> "july"
```
### Rules
* You will write a program/function that implements the described steps on two strings and either prints or returns the resulting string
* The input format is flexible: you can take two strings, a tuple of strings, list of strings etc.
* The input may consist of one or two empty strings
* The input will be characters in the printable range (`[32..126]`)
* The output is either printed to the console or you return a string
* The output is allowed to have trailing whitespaces
### Test cases
```
"isbn", "split"                  -> "july"
"", ""                           -> ""
"", "I don't matter"             -> ""
"             ", "Me neither :(" -> "             "
"but I do!", "!!!!!!!!!"         -> "but I do!"
'quotes', '""""""'               -> 'ck_iKg'
"wood", "hungry"                 -> "yarn"
"tray", "gzip"                   -> "jazz"
"industry", "bond"               -> "drop"
"public", "toll"                 -> "fall"
"roll", "dublin"                 -> "ball"
"GX!", "GX!"                     -> "!!!"
"4 lll 4", "4 lll 4"             -> "4 lll 4"
"M>>M", "M>>M"                   -> ">MM>"
```
**Note**: The quotes are just for readability, in the 6th test case I used `'` instead of `"`.
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
c32-p95\32+c
```
[**Try it online!**](https://tio.run/##y00syfn/P9nYSLfA0jTG2Eg7@f//avXigpzMEnUdBfXM4qQ89VoA "MATL – Try It Online")
### Explanation
```
c      % Implicitly input cell array of 2 strings. Convert to 2-row char matrix.
       % This pads the shorter string with spaces
32-    % Subtract 32, element-wise. Each char is interpreted as its ASCII code.
       % Note that padding spaces will give 0.
p      % Product of each column. Since (padding) spaces have been mapped to 0, the
       % product effectively eliminates those colums. So the effect is the same as
       % if string length had been limited by the shorter one
95\    % Modulo 95, element-wise
32+    % Add 32, element-wise
c      % Convert to char. Implicitly display
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~80~~ ~~74~~ 71 bytes
```
lambda*t:''.join(map(lambda x,y:chr((ord(x)-32)*(ord(y)-32)%95+32),*t))
```
*Thanks to @shooqie for golfing off 3 bytes!*
[Try it online!](https://tio.run/##JYkxDoAgEMC@wmLuQHTQOGjiT1xQYsQoELhBXo9EpzatT3Q42@edzWzJl7pXrQRNAO3pjMVbefwje2SatiMguqDx4U3fcfF5@rwah7pACuI8@2As4Y5g4mpBQvSXISjjBQ "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~15~~ 12 bytes
```
z⁶O_32P€‘ịØṖ
```
[Try it online!](https://tio.run/##ATIAzf9qZWxsef//euKBtk9fMzJQ4oKs4oCY4buLw5jhuZb///9bJ3NwbGl0JywgJ2lzYm4nXQ "Jelly – Try It Online")
-3 thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~75~~ 70 bytes
*-3 bytes thanks to Dennis' suggestion of shooqie's suggestion. -2 bytes thanks to Zacharý's suggestion.*
```
lambda*l:''.join(chr((ord(i)-32)*(ord(j)-32)%95+32)for i,j in zip(*l))
```
[Try it online!](https://tio.run/##HcYxDsIwDADAr3hBtkNhKGIAiZ@wtERRHQU7csNQPh9Qp7u6tcV07Onx7GV6z3EK5Y54ziZKr8WJzCMJny4jh/15/@F2Pf5J5iBDBlH4SqVQmHt10QaJUDR@1uYbDoCzaUTuPw "Python 2 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~60~~ 57 bytes
```
zipWith(\a b->toEnum$f a*f b`mod`95+32)
f=(-32+).fromEnum
```
[Try it online!](https://tio.run/##ddFPa8IwFADwez7F8ylUp91B3WEDexljjFEQdtgOwkztH6Np0qUJQ8XP3iV1bhTruyQkvzxe3lvTcptwXh38LnAqMkOzBB7nc@j6R5LNFtWeFe9Mr/sLCpEfaPkkTN5Lgd6kEC1zGS/v74aT8YCks74/GQ8Ht6mSuUNVTpmAGRRGv2kFPcgAv6WMEXBtRKZ2SA4@QVZGAkeAZcGZRrgIPwDcGG41OtYiGvSXvUAshachp1onCttY48y9CRMQif1qouChjzVrGoKR0eBSd5zvnAMbqf8N8b6M1EnpjcDDOrzLir3V9pO9Zh45NWf0153W7@2oErYOrejO0cxOB690YkP3e0uZiE2pVc0jKWJsobGShaWFiThbOagl5@0FpNTeEFQOWBi7J6KdRif6/FF3yy1Xp@aaSHAKnHOYOn3eXsjzBcEwCMJ6bG69kjcIwwCJf6x@AA "Haskell – Try It Online")
First line is an anonymous function taking two arguments. 
This a straight forward implementation of the algorithm: `zipWith` takes both strings and applies a given function to the pairs of characters. It handles the truncation and also works for empty strings. `fromEnum` and `toEnum` are alternatives to `ord` and `chr` to switch between characters and their ASCII values which do not need a lengthy import.
**Edit:** -3 bytes thanks to Bruce Forte.
[Answer]
## C++, ~~331~~ ~~291~~ ~~282~~ ~~270~~ 268 bytes, Version 2 = ~~178~~ ~~176~~ ~~150~~ 148 bytes
Original Version :
```
#include<string>
#include<algorithm>
#define L length()
#define S std::string
S m(S a,S b){S c;int m=a.L<b.L?a.L:b.L;auto l=[m](S&s){s=s.substr(0,m);std::for_each(s.begin(),s.end(),[](char&c){c-=32;});};l(a);l(b);for(int i=0;i<m;++i){c+=a[i]*b[i]%95+32;}return c;}
```
-40 bytes thanks to Bruce Forte  
-39 bytes thanks to Zacharý
Version 2, inspired by other people's answers
```
#include<string>
#define L length()
using S=std::string;S m(S a,S b){S c;for(int i=0;i<(a.L<b.L?a.L:b.L);++i)c+=(a[i]-32)*(b[i]-32)%95+32;return c;}
```
If the first version uses a lambda, it's because i wanted to test C++11 std::async function i just learnt before, so i kept it for no reasons...
More readable version :
```
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
#define L length()
#define S string
//Function code for the original version
S m(S a,S b) {
    S c;
    int m = a.L < b.L ? a.L : b.L;
    auto l=[m](S&s){
        s = s.substr(0, m);
        for_each(s.begin(),s.end(),[](char&c){
            c -= 32;
        });
    };
    l(a);
    l(b);
    for(int i=0;i<m;++i) {
        c += a[i] * b[i] % 95 + 32;
    }
    return c;
}
//Code for the version 2
S m2(S a,S b) {
    S c;
    for(int i = 0; i < (a.L < b.L ? a.L : b.L); ++i) {
        c += (a[i] - 32) * (b[i] - 32) % 95 + 32;
    }
    return c;
}
int main() {
    string a, b, c;
    getline(cin, a);
    getline(cin, b);
    c = m(a, b);
    cout << c;
}
```
[Answer]
# Dyalog APL, ~~36~~ ~~34~~ ~~33~~ ~~25~~ 24 bytes
```
{⎕UCS 32+95|×⌿32-⎕UCS↑⍵}
```
[Try it online (TryAPL)!](http://tryapl.org/?a=%7B%u2395UCS%2032+95%7C%D7%u233F32-%u2395UCS%u2191%u2375%7D%27split%27%20%27isbn%27&run)
[Try it online (TIO)!](https://tio.run/##Tc@xTsMwEAbgPU9x7WIk1KUtAwxdGBBDpgqJrUpqK7V0tYNzFgrQtRNFdEA8CQsLA2/iFwl26UW9xefv/pPsosaRbAu0VdetPdIibN@fw9vH3fUcJuPzy4uX38/w@jMZj/4xbPdh97XJUjZFDzsQdt9Ju07opjQCkoJoatQkMsH3k/YWpDVCEKwLIuXiBE6LY7kCozStlIOrsxgqPUFaHXBgwBWHD96SangyPFTkR2sl48qbyrURyRUtY/Wk60jaSN@Q67m0RkaufYl6yUgWMaJLx5FkCpiIN/f9s1KbiSkgIkwZ@ZqJfDbL@y@m/g8)
Input is a list of strings, and has trailing whitespace.
Here's how it works:
```
{⎕UCS 32+95|×⌿32-⎕UCS↑⍵}
                     ↑⍵ - the input as a 2d array
                 ⎕UCS   - codepoints
              32-       - subtract 32
            ×⌿          - element wise product reduction ([a,b]=>a×b)
         95|            - Modulo 95
      32+               - Add 32
 ⎕UCS                   - Unicode characters
```
[Answer]
# FSharp 275 bytes
```
let f (p : string, q : string) =     
let l = if p.Length < q.Length then p.Length else q.Length
p.Substring(0,l).ToCharArray() |> Array.mapi (fun i x -> (((int(x) - 32) * (int(q.[i]) - 32)) % 95) + 32) |> Array.map (fun x -> char(x).ToString()) |> Array.fold(+) ""
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~16~~ 15 bytes
```
.BÇ32-`*₃%32+çJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fz@lwu7GRboLWo6ZmVWMj7cPLvf7/j1YvLsjJLEkuSqyqzElMyUwtzk3MTs1NBQlkphap66hnFiflqcdyAQA "05AB1E – Try It Online")
-1 for Emigna pointing out `₃` pushes `95`.
---
```
                 # ['hi', 'you']
.B               # [['hi ', 'you']]
  Ç              # [[[104, 105, 32], [121, 111, 117]]]
   32-           # [[[72, 73, 0], [89, 79, 85]]]
      `          # [[72, 73, 0], [89, 79, 85]]
       *         # [[6408, 5767, 0]]
        ₃%       # [[43, 67, 0]]
          32+    # [[75, 99, 32]]
             ç   # [['K', 'c', ' ']]
              J  # ['Kc ']
```
---
```
.BÇ32-`*95%žQsèJ
```
is another.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 23 bytes
```
{z{2' e]' f-:*95%' +}%}
```
[Try it online!](https://tio.run/##S85KzP1fWPe/uqraSF0hNVZdIU3XSsvSVFVdQbtWtfZ/3f9opeKCnMwSJQWlzOKkPKVYAA "CJam – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform),100 96 95 bytes
```
(l,n)=>{for(int i=0;i<l.Length&i<n.Length;)Console.Write((char)((l[i]-32)*(n[i++]-32)%95+32));}
```
[Try it online!](https://tio.run/##NY7BSsRAEETv8xVNQOkx2SDKHmSSBfGqB9mDh8VDdhyThrFHpltBQr49G7Nal1dUQVFeNj7lMH8JcQ/7H9Hw4YzxsROBZzMaWCTaKXn4TvQGTx0x2jU@l7@690qJG9G8rFRw5g56aGHGWLFtd@N7ykisQO21oybWj4F7HS6p4T/r7ENiSTHUL5k0IPqhyxYxHuh1c3tjr5APVJarv7jblgusm@bl7f@NHgv5jKRFVZAcubBurSYzzSc "C# (.NET Core) – Try It Online")
-4 bytes thanks to @Zacharý
-1 byte by moving the increment
Uses a lambda and abuses the fact that characters are basically ints. 
[Answer]
# Mathematica, 114 bytes
```
(a=Min@StringLength[x={##}];FromCharacterCode[Mod[Times@@(#-32&/@ToCharacterCode/@(StringTake[#,a]&/@x)),95]+32])&
```
  
**input**
> 
> ["public","toll"]
> 
> 
> 
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 52 bytes
```
[,:$#'"!MIN$take"![CS#.toarr]"!32-prod 95%32+#:''#`]
```
[Try it online!](https://tio.run/##bZExT8MwEIX3/opLUnSJ2magZcBDhcSAOoSFBalUIqnd1qqJjXMWKn8@JIU2ccSTPPjpe3enu4ry7VHwul5P2TjCMMhWz2PKjyIM1o8vUUo6t3YTBvPbmbGaw/3dzfx2EjHE6H1TP7DdaBTH8CesjJKE0BPKqigxGUEMnu1Bv85/EK6A6xKR4CMnEvYM@dn2h5mAUkg6CAssvlbCwhG0FYJLBIOL@u3w02kSVa8uhmf5M@GX1rwPHVy5t6cBRDY/@SvYf0vTQShL7iqyA6jQJfdmMq5QcutDpJUatLOt1UN4GxtuHJ9eg8HWWqeDcAFKKVh00NXx22XLZebPdHaSBNbAIE1T2MEUNs25DMQx5s0Ji@ZpR8YRJs3xZp2QsSb4BpMJcFmZ@gc "Stacked – Try It Online")
Function that takes two arguments from the stack.
## Explanation
```
[,:$#'"!MIN$take"![CS#.toarr]"!32-prod 95%32+#:''#`]
```
Let's look at the first part, assuming the top two items are `'split'` and `'isbn'`:
```
,:$#'"!MIN$take"!      stack:                      ('split' 'isbn')
,                      pair top two:               (('split' 'isbn'))
 :                     duplicate:                  (('split' 'isbn') ('split' 'isbn'))
  $#'                  length function literal:    (('split' 'isbn') ('split' 'isbn') $#')
    "!                 execute on each:            (('split' 'isbn') (5 4))
      MIN              obtain the minimum:         (('split' 'isbn') 4)
         $take         "take" function literal:    (('split' 'isbn') 4 $take)
                       (e.g. `'asdf' 2 take` is `'as'`)
              "!       vectorized binary each:     (('spli' 'isbn'))
```
This part performs the cropping.
Then:
```
[CS#.toarr]"!     stack: (('spli' 'isbn'))
[         ]"!     perform the inside on each string
                  string `'spli'`:
 CS               convert to a character string:    $'spli'
   #.             vectorized "ord":                 (115 112 108 105)
     toarr        convert to array:                 (115 112 108 105)
                  (needed for empty string, since `$'' #.` == `$''` not `()`
```
Then, the last part:
```
32-prod 95%32+#:''#`  stack: (((115 112 108 105) (105 115  98 110)))
32-                   subtract 32 from each character code:   (((83 80 76 73) (73 83 66 78)))
   prod               reduce multiplication over the array:   ((6059 6640 5016 5694))
        95%           modulus 95:                             ((74 85 76 89))
           32+        add 32:                                 ((106 117 108 121))
              #:      convert to characters:                  (('j' 'u' 'l' 'y'))
                ''#`  join:                                   ('july')
```
[Answer]
# [R](https://www.r-project.org/), 88 bytes
```
function(r,s,u=utf8ToInt)intToUtf8((((u(r)-32)*(u(s)-32))%%95+32)[0:min(nchar(c(r,s)))])
```
anonymous function; takes input as two strings; third argument is just to ensure this is a one line function and save some bytes.
The TIO link below returns an array with entries named with the first input.
[Try all test cases!](https://tio.run/##ZY5BSwMxEIXv/oo0UJLUFERb0FJ7lR56qyCIh93NbjeQncRkgqx/fp1sEQQfgffNMJl5cerYfj11GRq0HmTUSefnjN3j2R8BlQU8@1cqJSnLqNYP92pFlGZSy@XT9pbg/W43WJDQ9FWUTVmjlPpQ01CF4EbZ6UZym2rgml8f@yOuGa8zMsuMX1AhPrPHNglqf3lvaBpjNZJZMDlhLBhy7WxDEL1zZC9v9JNvmHOObcrC0@Fw4krf0OEUnMXr2SOdAIFsqBDbOM@1DFqLfRvZTpbG4lclCZ8ltOgzXOJIcPm2gaz2YMiQrpOZkgYIKEaJ/S@Hmn4A "R – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 65 bytes
64 bytes of code + `-p` flag.
```
$n=reverse<>;s/./($_=chop$n)&&chr 32+(-32+ord$&)*(-32+ord)%95/ge
```
[Try it online!](https://tio.run/##K0gtyjH9r6xYAKQVdAv@q@TZFqWWpRYVp9rYWRfr6@lrqMTbJmfkF6jkaaqpJWcUKRgbaWvoAon8ohQVNU0tGFtT1dJUPz31/39fOztfLhABAA "Perl 5 – Try It Online")
[Answer]
# D, 113 bytes
```
T m(T)(T a,T b){T c;for(int i;i<(a.length<b.length?a.length:b.length);++i)c~=(a[i]-32)*(b[i]-32)%95+32;return c;}
```
This is a port of [HatsuPointerKun's C++ solution](https://codegolf.stackexchange.com/a/133871/55550), don't forget to upvote them!
[Try it online!](https://tio.run/##Ncy9DoIwFIbhmV5FF9NTQQaIgxbjTXQjDOVHPQm0pFQdCN56rQaGJ3nzneS03ks6gOQgqUokrfksaSNuxgJqR1FgASrtO313j6Je47ot523hIo6RN58LqBKrQ57xPdRr7U7HOM@E7dzT6vB7IS@DLR0UauB0JhEOo7GOTq5NAzSCRG@Lrus1DFCyiSVsDPoAA8eqpPzX71IHmlWcC7J4/wU)
[Answer]
# Java 8, ~~127~~ ~~115~~ ~~97~~ 95 bytes
```
a->b->{for(int i=0;i<a.length&i<b.length;System.out.printf("%c",(a[i]-32)*(b[i++]-32)%95+32));}
```
**Explanation:**
[Try it here.](https://tio.run/##tZNfS8MwFMXf9ymuhWnqXBD/PGi3ggiKD3vaizD3kKbZlpklNblR5thnn5lWEVlAiqaFXjg3v3Mu9M7ZM@uaSuh5@bjhijkHAyb1qgXgkKHkMA8d1KNUdOI1R2k0vamLHp8xOxof7eq5Ntr5hbB1T54Dhz5sWDcvuvlqYiyRGkH2jzPZY1QJPcXZvuwVdZkNlw7FghqPtLKhdUKSNk@OCBvJcff0JD0kxUh2Ou91@@K8Ez5ptt5kIXh4K1@okL0e4dnIEhZhLDLEwJqOxsDS7YgAnLKqUkuSuEpJTCia65D3ylq2JGlKGeeiQpJIV@ifYvYO@JlTaVIrX@go9e@Jd1AafYBhWERhG/Ph@4maDQRoIXEmLFySxl6FR9jG3ov67H2exh5P3qBwUYOHb09jjxdjyqjDzOupXTZmY@iPsqevsmpMlrr0Dm2cjkapxvSPNfyf5HZHsC9yuTVuvrG39/G/cYf2a@4ZKKXgLMqO6L/mD/J8EF/XHeL2/rq13rwB)
```
a->b->{                       // Method with 2 char-array parameters and no return-type
  for(int i=0;                //  Index-integer, starting at 0
      i<a.length&i<b.length;  //  Loop over both arrays up to the smallest of the two
    System.out.printf("%c",   //   Print, as character:
      (a[i]-32)               //    Current char of `a` minus 32
      *(b[i++]-32)            //    multiplied with current char of `b` minus 32
      %95                     //    Take modulo-95 of that multiplied result
      +32));}                 //    And add 32 again
```
[Answer]
# C#, 166 bytes
```
using System.Linq;s=>t=>{int e=s.Length,n=t.Length,l=e>n?n:e;return string.Concat(s.Substring(0,l).Select((c,i)=>(char)((((c-32)*(t.Substring(0,l)[i]-32))%95)+32)));}
```
I'm sure there's a lot of golfing to be done but I don't have time right now.
[Try it online!](https://tio.run/##ZVDBTsMwDL3nK6JKSAl0EQJxgJJwQOI0JEQPHBCHLPO2SJkLtYuEpn57SVcmMXgX2@/52bIDzbYNNkNHEdey/iKGbSV@V2Ye8aMSIiRPJJ/ETsgMYs8xyM8mLuWjj6j0np7EEQ8dhlviNg8qj4spOidX0sqBrGPrdhFZgiUzB1zzpkTLhzRZcHiHN1C1wF2LP35z32DwrMjU3WKi1HmZtKkhQWClQhm1dSpsfKtVRphdXuhTxX/6X@PbKOiT6yt9Nia66od87uGOvIaaBOaljQz5FaCO969UQe8pcqFVEWmBxTjhv/0Z/HLvzuLI96IfvgE "C# (Mono) – Try It Online")
Full/Formatted Version:
```
using System;
using System.Linq;
class P
{
    static void Main()
    {
        Func<string, Func<string, string>> f = s => t =>
        {
            int e = s.Length, n = t.Length, l = e > n ? n : e;
            return string.Concat(s.Substring(0, l).Select((c, i) => (char)((((c - 32) * (t.Substring(0, l)[i] - 32)) % 95) + 32)));
        };
        Console.WriteLine(string.Concat(f("split")("isbn")));
        Console.ReadLine();
    }
}
```
[Answer]
# Common Lisp, 99 bytes
```
(lambda(a b)(map'string(lambda(x y)(code-char(+(mod(*(-(#1=char-code x)32)(-(#1#y)32))95)32)))a b))
```
[Try it online!](https://tio.run/##NcxBCoMwFATQq3ziwvmWLKp00YWH@SZFBWNCtNScPjWCqxnewJhl3kJGiPO6EzIWcYMVCA0MJ6He9nMZbz4oMYy3H20miXjAeYsGGtWzL6LLRgd3LV9YpVL5/bqCyytn9fPeKlLTdx1jUqf8AQ)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 24 bytes
```
¬íVq)®®©c -HÃ×u95 +H dÃq
```
Returns a string with trailing null-chars (`\u0000`) when the first input is longer than the second.
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=rO1WcSmurqljIC1Iw9d1OTUgK0ggZMNx&input=InNwbGl0IgoiaXNibiIKLVE=) with the `-Q` flag to show formatted output, including the null-chars.
[Run all the test cases](https://codepen.io/justinm53/full/NvKjZr?code=rO1WcSmurqljIC1Iw9d1OTUgK0ggZMNx&inputs=ImlzYm4iCiJzcGxpdCI=,IiIKIiI=,IiIKIkkgZG9uJ3QgbWF0dGVyIg==,IiAgICAgICAgICAgICAiCiJNZSBuZWl0aGVyIDooIg==,ImJ1dCBJIGRvISIKIiEhISEhISEhISI=,J3F1b3RlcycKJyIiIiIiIic=,Indvb2QiCiJodW5ncnki,InRyYXkiCiJnemlwIg==,ImluZHVzdHJ5IgoiYm9uZCI=,InB1YmxpYyIKInRvbGwi,InJvbGwiCiJkdWJsaW4i,IkdYISIKIkdYISI=,IjQgbGxsIDQiCiI0IGxsbCA0Ig==,Ik0+Pk0iCiJNPj5NIg==&flags=LVE=) using my WIP CodePen.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~95~~ 73 bytes
* Thanks @Zacharý for 4 bytes: unwanted brackets removed
```
lambda x,y:''.join(chr((ord(i)-32)*(ord(j)-32)%95+32)for i,j in zip(x,y))
```
[Try it online!](https://tio.run/##HcsxDsIwDEDRq3hBtiEwFDGAxE1YWqKojsCO3CARLh@qTv8tv7Q6mw493R/9Nb6nOMI3tBviKZsoPWcnMo8kfDwPvN@cN@@ul8OaZA4SMojCTwqtM3MvLlohEU6mEQOKxs9SvSH3Pw "Python 2 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 30 bytes
```
Ｆ⌊⟦ＬθＬη⟧℅⁺³²﹪×⁻³²℅§θι⁻³²℅§ηι⁹⁵
```
[Try it online!](https://tio.run/##dYy7CgIxFER7vyLlDWQbxUKsxEpwcQs7sQhJ3ASSXDYPH19/zeK2VjMMZ46yMimUnuiBiUHvogs1wO1s4lgsTFywpVp@55wNycUCx/aSqpgEg68ZNmvBetTVI1xdMHnWLPMlaRelh0M5RW3eMAnmOG/W/4j9IY3ZbefcE70Q9crWOKYPdU/qsv8C "Charcoal – Try It Online") Link is to verbose version of code. I actually wrote the calcualation as `(32 - ord(q)) * (32 - ord(h))` because it avoids consecutive numeric literals but I guess I could have just written `(ord(q) - ord(" ")) * (ord(h) - ord(" "))` instead.
[Answer]
# [Perl 5](https://www.perl.org/), 95 bytes
```
@a=<>=~/(.)/g;@b=<>=~/(.)/g;$#a=$#b if@a>@b;print chr 32+(-32+ord$_)*(-32+ord$b[$i++])%95 for@a
```
[Try it online!](https://tio.run/##K0gtyjH9/98h0dbGzrZOX0NPUz/d2iEJmaeinGiropykkJnmkGjnkGRdUJSZV6KQnFGkYGykraELJPKLUlTiNbXg7KRolUxt7VhNVUtThbT8IofE//8zi5PyuIoLcjJLAA "Perl 5 – Try It Online")
**Explanation:**
```
@a=<>=~/(.)/g;@b=<>=~/(.)/g;  # Split the strings into 2 arrays
$#a=$#b if@a>@b;              # Truncate the first if longer than the second
print chr 32+(-32+ord$_)*(-32+ord$b[$i++])%95 for@a  # Multiply each character
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 19 bytes
```
(PA$* *(PA@?Zg)%95)
```
Takes the strings as command-line arguments. [Try it online!](https://tio.run/##K8gs@P9fI8BRRUtBC0g52Eela6pammr@//@/uCAns@R/ZnFSHgA "Pip – Try It Online")
### Explanation
```
(PA$* *(PA@?Zg)%95)
                     g is list of args; PA is string of all printable ASCII characters
            Zg       Zip items of g together: result is list of pairs of characters
        PA@?         Find index of each character in PA
       (      )      (Parentheses to get correct operator precedence)
   $* *              Map (fold on *) to the list: multiplies each pair of numbers
               %95   Take list items mod 95
(PA               )  Use those numbers to index into PA again
                     Print the resulting list of chars, concatenated together (implicit)
```
[Answer]
# [Factor](http://factorcode.org), 45
```
[ [ [ 32 - ] bi@ * 95 mod 32 + ] "" 2map-as ]
```
It's a quotation (lambda), `call` it with two strings on the stack, leaves the new string on the stack.
As a word:
```
: s* ( s1 s2 -- ps ) [ [ 32 - ] bi@ * 95 mod 32 + ] "" 2map-as ;
"M>>M" "M>>M" s*      ! => ">MM>"
dup s*                ! => "M>>M"
dup s*                ! => ">MM>"
...
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 26 bytes
**Solution:**
```
`c$32+95!*/-32+(&/#:'x)$x:
```
[Try it online!](https://tio.run/##y9bNz/7/PyFZxdhI29JUUUtfF8jQUNNXtlKv0FSpsNJQysxLKS0uKapUslZKys9LUdL8/x8A "K (oK) – Try It Online")
**Example:**
```
`c$32+95!*/-32+(&/#:'x)$x:("split";"isbn")
"july"
```
**Explanation:**
Evaluation is performed right-to-left:
```
`c$32+95!*/-32+(&/#:'x)$x: / the solution
                        x: / assign input to variable x
                       $   / pad right to length on left
               (  #:'x)    / count each x (return length of each char list in list)
                &/         / min-over, get the minimum of these counts
           -32+            / subtract 32, this automagically converts chars -> ints
         */                / multiply-over, product of the two lists
      95!                  / modulo 95
   32+                     / add 32 back again
`c$                        / convert to character array
```
[Answer]
# [Kotlin](https://kotlinlang.org), 65 bytes
```
{zip(it){a,b->(a-' ')*(b-' ')%95+32}.fold(""){s,i->s+i.toChar()}}
```
[Try it online!](https://tio.run/##dY69DoIwFIV3nuKGxHArlEHjIAk4uLr5BG0AvbEUQouDTZ@91p@4eZaTnG843220inS4CwXDoio425n0pcRPM@DNd4I6uAdNSJY5UUjeoOAZZGyN8t2r/S7fbnzZj6rFNGXOFMQbk1Npx@NVzMi8D/2iYRCkkYFLIOb1K6CGuRPtiXQXwaGCNP1B@Q9OUcpidMZow1jiAxmpEzMpsk8 "Kotlin – Try It Online")
[Answer]
# [Factor](https://factorcode.org/), 39 bytes
```
[ [ [ 32 - ] bi@ * 95 mod 32 + ] 2map ]
```
[Try it online!](https://tio.run/##HY4xC8IwFIR3f8WRRVB0qDioIG7SxUWcpEOaPjHYJjHvOUjpb4@J3PR93ME9tBEf0@1aX857aGZvGC@KjnoMWp4IkUS@IVonYHp/yBliHGYjRijLrVNQHHorClNRGWt03s2l7IVi8VO6o2RTYYUGrT1hgd0Wg@@KW2ZXDTqgSWNu/18cC6/TDw "Factor – Try It Online")
## Explanation:
This is a quotation (anonymous function) that takes two strings from the data stack and leaves one string on the data stack. In Factor, strings are just sequences of unicode code points and can be manipulated like any other sequence.
* Assuming a data stack that looks like `"split" "isbn"` when this function is called...
* `[ [ 32 - ] bi@ * 95 mod 32 + ]` push a quotation to the data stack (to be used later by `2map`) `"split" "isbn" [ [ 32 - ] bi@ * 95 mod 32 + ]`
* `2map` map over two sequences, combining them into one sequence with the given quotation which has stack effect `( x x -- x )`.
* At the beginning of the first iteration of `2map`, the data stack looks like this: `115 105`
* `[ 32 - ]` push a quotation to the data stack to be used later by the word `bi@`. `115 105 [ 32 - ]`
* `bi@` apply a quotation to the object on top of the data stack *and* the second-top object on the data stack `83 73`
* `*` multiply top two objects on the data stack `6059`
* `95` push `95` to the data stack `6059 95`
* `mod` reduce NOS (next on stack) modulo TOS (top of stack) `74`
* `32` push `32` to the data stack `74 32`
* `+` add top two objects on the data stack `106`
* So, at the end of the quotation to `2map`, we are left with `106`, which is the code point for `'j'`, which is the first element of the output sequence. The quotation given to `2map` will be run on each pair of elements until one of the two sequences no longer has any elements, meaning the output sequence will have the same size as the shorter of the two input sequences.
[Answer]
# [Red](http://www.red-lang.org), 81 bytes
```
func[a b][repeat i min length? a length? b[prin a/:i - 32 *(b/:i - 32)% 95 + 32]]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85OlEhKTa6KLUgNbFEIVMhNzNPISc1L70kw14hEc5Kii4oAkok6ltlKugqGBspaGkkwdiaqgqWpgraQFZs7P80BaXigpzMEiUFpczipDyl/wA "Red – Try It Online")
[Answer]
# [Itr](https://github.com/bsoelch/OneChar.js/blob/main/ItrLang.md), 11 bytes
`32â-R*95%+¥`
Takes input as an array of 2 strings
prints additional trailing spaces if one string is longer
[online interpreter](https://bsoelch.github.io/OneChar.js/?lang=Itr&src=MzLiLVIqOTUlK6U=&in=WyJpc2JuIiwgInNwbGl0Il0=)
## Explanation
```
32â-R*95%+¥ ; implicit input
32          ; constant 32
  â         ; push 32 below implicit input
   -        ; subtract 32 from input
    R*      ; multiply elements of input array
      95%   ; take input modulo 95
         +  ; add 32
          ¥ ; print value as string (implicit output will print '()' for empty string)
```
]