Literate Programming in Base 26

Question

Your task is to convert non-empty strings - between strings using the 26 letters, and programs, which are strings of bytes, where each byte has 256 possible values. You should use the same codepage your answer is written in for the possible values of bytes.

You need to do the following to do the conversion:

• Convert the letters to numbers 1-26.
• Treat it as a base 26 bijective numeration number to convert it to a positive integer.
• Convert it to base 256 using 1-256, again using bijective numeration.
• Turn it to bytes, where i turns to the byte with value i-1.

For example, for the string hello, you start with converting it to [8, 5, 12, 12, 15], then you evaluate \$15 + 12\cdot26 + 12\cdot26^2 + 5\cdot26^3 + 8\cdot26^4 = 3752127\$. Then you convert \$3752127 = 191 + 64\cdot256 + 57\cdot256^2\$, so the answer is [56, 63, 190].

However, you dislike gibberish. You want your code to be a concatenation of English words. You can't do that directly in your code, so instead you'll do that in its base26 representation.

Rules

• Your code, when converted to base 26 using bijective numeration, has to be a concatenation of English words from this wordlist, with 1 or 2 letter words removed, except for a, i, of, to, in, is, on, by, it, or, be, at, as, an, we, us, if, my, do, no, he, up, so, pm, am, me, go, ok, hi.
• You can choose whether you want your input to have lowercase or uppercase letters, but it has to be consistent.
• Your input has to be a string, an array of characters or an array of bytes - you can't take an array of numbers from 1 to 26, for example.
• Your output has to be a string, an array of characters, an array of bytes, or an array of numbers from 0 to 255.
• Standard loopholes are disallowed.
• If your language uses a base which isn't 256 then use that base, as long as it isn't a power of 26. If it is that language can't compete.

Test cases

input string -> array of bytes
hi -> [216]
iw -> [0, 0]
sr -> [0, 255]
cat -> [7, 25]
crxq -> [255, 0]
cshl -> [255, 255]
cshm -> [0, 0, 0]
hello -> [56, 63, 190]
helloworld -> [39, 138, 176, 111, 2, 107]
apple -> [10, 110, 12]
loremipsumdolorsitamet -> [81, 108, 15, 236, 169, 234, 61, 72, 24, 166, 102, 147, 49]

Scoring

Your score is the length of your program, encoded in base 26. This is code-golf, so the shortest answer in each language wins.

Answer 1

Jelly, score 23

The bijective base \$26\$ program as words:

yrs seo dts i am a be in cpu sap

The Jelly code:

ÑÞ²¶O_96ḅ26ḃ⁹’

Try it online!

Raw bytes as integers \$[1,256]\$:

[17, 21, 131, 128, 80, 96, 58, 55, 213, 51, 55, 232, 138, 254]

Converted from base \$256\$:

346505452333233856289746614520574

Converted to bijective base 26:

[25, 18, 19, 19, 5, 15, 4, 20, 19, 9, 1, 13, 1, 2, 5, 9, 14, 3, 16, 21, 19, 1, 16]

As characters, and then with spaces added to show the dictionary words used:

yrsseodtsiamabeincpusap
yrs seo dts i am a be in cpu sap

See this process starting with the Jelly code.

How?

The first part, up to the ¶ is filler to ensure we get a valid intermediate string, the ¶ is equivalent to a newline and separates Links, and execution of Jelly programs start at the final Link. Since the final Link (O_96ḅ26ḃ⁹’) is not calling the previous one (ÑÞ²) and the full program parses without error, the final Link is called with an input of the input string as a list of characters:

O_96ḅ26ḃ⁹’ - Link: list of characters
O          - ordinals
 _96       - subtract 96 from each
    ḅ26    - convert from base 26
       ḃ⁹  - convert to bijective base 256
         ’ - decrement each

---

I also tried these suffixes (some will only work with upper case input):

¶O%32ḅ26ḃ⁹’
¶O%48ḅ26ḃ⁹’
¶O%64ḅ26ḃ⁹’
¶O_64ḅ26ḃ⁹’
¶Oạ64ḅ26ḃ⁹’
¶Oạ96ḅ26ḃ⁹’

There are many more that could be tried (like using unused code-page entires like q to create a new Link, or making a single Link that has some sort of no-op at the start etc.), so there may be terser out there.