Convert alphanumeric (base-36) sentences into hexadecimal (base-16) sentences

Question

I use "sentence" here loosely to mean "any sequence of words separated by spaces" and "words" to mean "sequences of alphanumeric (hexatrigesimal) characters unseparated by spaces".

---

Conversion is from base-36 (0123456789abcdefg...) or (0123456789ABCDEFG...)

Conversion to base-16 (0123456789abcdef) or (0123456789ABCDEF)

Bonus -1 off your byte score if you are case-insensitive on input

Bonus -1 off your byte score if you are insensitive to non-alphanumeric characters (ignore them, except space)

---

Conversion of sentences

E.g. if your input sentence is "The meaning of life is 31313" then your out put should convert the following base-36 "words" into base-16 numbers (the, meaning, of, life, is, 31313) and then output them in order.

Bonus -1 off your byte score for retaining spaces in output sentence

Test Cases

You may convert these to your preferred single-case form if you choose not to opt for the case-insensitive bonus, strings end after spaces. Assume input will never start with a space.

---

Input text:

"The meaning of life is 31313"

Output: ("9542 B59F1602C 36F F508A 2A4 4DA897") - with or without spaces, with lower or upper case letters

Bonus -1 off your byte score for removing leading zeroes i.e. "9542" not "000009542".

---

Input text: 

"Jet fuel can't melt steel beams"

Output: ("6245 B47AD 8C0F9 FF371 2E28A2D 1241854")

---

Input text: 

"fhs8230982t90u20's9sfd902 %2'+13jos32*'ej eos"

Output: ("74510A686B453A2B1933C7AADA25DD2 BB8E18A11AEB 4A5C")

The Winner

This is code-golf, so the fewest bytes wins (including bonus -1 bytes). :)

Can accept the inputs in any way that works, as long as your code can solve arbitrary problems like the test cases.

Answer 1

Japt -S, 6 - 3 = 3 bytes

¸®n36G

Saved two bytes thanks to @Shaggy

Try it

Answer 2

Perl 6, 28 bytes - 2 = 26

{S:g{\S+}=:36(~$/).base(16)}

Try it online!

Answer 3

MATL array, 9 - 1 = 8 bytes

Yb36ZA1YA

Try it online!

Case-insensitive, but turns spaces into line breaks.

MATL inline, 20-2 = 18 bytes (inelligible)

Yb36ZA1YAO10Z(!999e!

Try it online!

Takes case-insensitive and preserve-spaces bonuses, (last test case fails due to implicit size assumptions = inelligible submission)

Yb     % Split the input at spaces, place the results in a cell array
36ZA   % convert from base-36
1YA    % Convert to hexadecimal. Gives a char array 

O10Z(  % Assign char 0 to 10th column. Adds "Spaces"
!999e! % Reshape in row-major order as a 999-column char array
       % Implicitly display. Display 0 as space.

(I hope Luis Mendo comes and improves on this, because I got most of this from his answers here, here, here and sundar's answer here.)

Answer 4

Ruby -p, 23-1 = 22 bytes

Only uses the case-insensitive bonus.

$_=$_.to_i(36).to_s(16)

Try it online!

Ruby -p, 33-2 = 31 bytes

Takes case-insensitive and preserve-spaces bonuses.

gsub(/\w+/){$&.to_i(36).to_s(16)}

Try it online!

Ruby -p, 46-3 = 43 bytes

Takes all 3 bonuses.

gsub(/\S+/){$&.gsub(/\W/){}.to_i(36).to_s(16)}

Try it online!

Answer 5

05AB1E, score 3 (4 bytes - 1 bonus)

#₆öh

Bonus -1: no leading 0s, since this is done implicitly.
Outputs as a list of converted words.

Try it online.

---

05AB1E, score 8 (12 bytes - 4 bonus)

u#εžKÃ}₆öhðý

All four bonuses:
-1 for no leading 0s, since this is done implicitly;
-1 case-insensitivity by first converting to uppercase with u;
-1 for retaining spaces in the output by joining the list by spaces with ðý;
-1 for ignoring every character apart from [A-Za-z0-9 ], by keeping [A-Za-z0-9] after the split_on_spaces with εžKÃ}

Try it online.

Explanation:

#             # Split the (implicit) input-string on spaces
 ₆ö           # Convert each string from base-36 to integers
   h          # Convert those integers to hexadecimal
              # (and output the list implicitly as result)

u             # Convert the (implicit) input to uppercase
 #            # Split it on spaces
  ε           # Map each string to:
   žK         #  Push builtin string "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
     Ã        #  And only keep those characters in the mapped string
      }₆ö     # After the map: convert each string from base-36 to integer
         h    # Convert those integer to hexadecimal
          ðý  # And join them by spaces
              # (after which the result is output implicitly)

Answer 6

Python 2, 47 - 2 = 45 bytes

lambda S:[hex(int(s,36))[2:]for s in S.split()]

Try it online!

Because case insensitive. And also leading 0s.

Answer 7

Perl 5 -Mbigint -MList::Util=reduce -p, 92 - 4 = 88 bytes

y/_/*/;s|\S+|Math::BigInt::as_hex reduce{$a*36+$b}map{7x/\d/+ord(uc)-55}$&=~/\w/g|ge;s/0x//g

Try it online!

Qualifies for all 4 bonuses (case insensitive, keeps spaces, ignores punctuation, no leading 0s). Handles even large test cases properly, including the last one.

Answer 8

Charcoal, 14 bytes - 1, score 13

⪫Ｅ⪪Ｓ ⍘⍘ι³⁶¦¹⁶ 

Try it online! Link is to verbose version of code. Only qualifies for the leading zeros bonus. Explanation:

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over words
       ι        Current word
      ⍘ ³⁶      Convert from base 36
     ⍘     ¹⁶   Convert to base 16
⪫               Join on spaces
                Implicitly print

• If output of the hex numbers on separate lines is acceptable, then the first and last characters can be removed for a 2-byte saving.
• Case insensitive input is possible at a cost of 1 byte, which would not affect the score.
• Preservation of multiple spaces is possible at a cost of 2 bytes, unless the current misbehaviour is a Charcoal bug, in which case it would work once the bug is fixed.
• Skipping of punctuation is possible at a cost of 4 bytes. (Currently the only supported case is a single trailing .)

Answer 9

Java, 94-2 = 92 bytes

These "bonuses" are too expensive to intentionally claim. I get case insensitive and leading zeros for free though.

s->{for(var w:s.split(" "))System.out.print(new java.math.BigInteger(w,36).toString(16)+" ");}

TIO

Answer 10

Gema, 20 characters

<A>=@radix{36;16;$1}

Sample run:

bash-4.4$ gema '<A>=@radix{36;16;$1}' <<< 'The meaning of life is 31313'
9542 B59F1602C 36F F508A 2A4 4DA897

Try it online!

Answer 11

Ecmascript 2020, score 90 - 3 = 87

Likely it would be there, already works in Firefox 68+ and Chrome 67+.

s=>s.replace(/\w+/g,x=>[...x].reduce((r,x)=>36n*r+BigInt(parseInt(x,36)),0n).toString(16))

Bonuses:

• Bonus -1 off your byte score if you are case-insensitive on input
• Bonus -1 off your byte score for retaining spaces in output sentence
• Bonus -1 off your byte score for removing leading zeroes i.e. "9542" not "000009542".

Test:

f=s=>s.replace(/\w+/g,x=>[...x].reduce((r,x)=>36n*r+BigInt(parseInt(x,36)),0n).toString(16))

console.log([
["The meaning of life is 31313", "9542 B59F1602C 36F F508A 2A4 4DA897"],
["Jet fuel can't melt steel beams", "6245 B47AD 8C0F9 FF371 2E28A2D 1241854"],
["fhs8230982t90u20's9sfd902 %2'+13jos32*'ej eos", "74510A686B453A2B1933C7AADA25DD2 BB8E18A11AEB 4A5C"],
["  123   1234   tyu ", "  55B   C0D0   97B6 "],
].map(([t,k])=>f(t.replace(/(?!\s|_)\W/g,"")).toUpperCase()==k))