这只小猪推向市场，这只小猪写了一些代码...

啊，等等，我们不是在谈论那培根，而是在谈论弗朗西斯·培根爵士！具体地，密码培根在1500年代末期设计，作为一种将消息隐藏在另一条消息中的方法，即隐写术。

密码通过隐藏文本表示中的消息而不是其内容来起作用。首先，您的邮件字母被编码为二进制（从0到25），如下所示：

注意：请在代码中使用以下编码，不要担心输入中的数字，空格或其他符号，尽管我可能会为那些在编码中包含这些字符的人带来一些好处。如果确实包含其他符号，则字母在编码中仍必须占据0-25的空格。

Letter  Encoding
A       AAAAA
B       AAAAB
C       AAABA
D       AAABB
E       AABAA
F       AABAB
G       AABBA
H       AABBB
I       ABAAA
J       ABAAB
K       ABABA
L       ABABB
M       ABBAA
N       ABBAB
O       ABBBA
P       ABBBB
Q       BAAAA
R       BAAAB
S       BAABA
T       BAABB
U       BABAA
V       BABAB
W       BABBA
X       BABBB
Y       BBAAA
Z       BBAAB

将消息中的所有字母都编码为上述As和Bs之后，您现在必须为代码选择两个字体。在这个例子中，我将使用的字体正常的文本A和粗体文本的字体B。

所以消息

HELLOWORLD

被编码为

AABBB AABAA ABABB ABABB ABBBA BABBA ABBBA BAAAB ABABB AAABB

现在，我们用载体文本隐藏此二进制文件。

敏捷的棕色狐狸跳过了那些懒惰的狗，在牧羊人守望的田野里咆哮。

如果载波消息比实际编码的消息长，则可以，尽管它不能短一些。现在，根据Bs在编码消息中的位置，将运营商文本变为粗体，

钍Ë 曲 IC ķ BRO 瓦特 Ñ FO X Ĵ ù 熔点小号OVE ř 吨 ħ ë 升 AZ ý 做克小号，GAM b ö 升我纳克在吨他字段其中牧羊保持手表。

没有Markdown的读为

Th**e** **qu**ic**k** bro**w**n **fo**x **j**u**mp**s **ove**r **t**h**e** **l**az**y** 
**do**g**s**, gam**b**o**l**i**ng** in t**he** fields where the shepherds keeps watch.

请注意，我没有在载体消息中使用标点符号对消息进行编码，但是标点符号是否已编码取决于您/。

规则

• 您的输入将是要编码的消息和运营商消息。如果运营商消息太短，则返回某种错误消息。

• 您必须选择两种字体进行编码A和B，例如UPPERCASE，小写字母，斜体，粗体，粗斜体，删除线，in code format等等。您必须使用Stack Exchange的Markdown形式对这些字体进行编码，即

  UPPERCASE, lowercase, *italic*, **bold**, 
  ***bold italic***, <s>strikethrough</s>, `in code format`
  

• 您的输出必须是您现在编码的运营商消息，如上例所示，显示为Markdown或不显示。

• 您只需要制定一种编码算法。欢迎您希望提供任何解码算法，但是在撰写本文时，不会帮助或阻碍您的成绩。

• 您的代码必须是程序或函数。

• 这是代码高尔夫，因此最少的字节数获胜。

与往常一样，如果问题仍然不清楚，请告诉我。祝你好运，打高尔夫球！

Pyth，47个字节

Vsm.[05jxGd2r~zw0#I}Jr@z~Z+1Z0GBpJ)p?NrJ1J;>zZ

在这里尝试。

说明：

             ~zw                               - Get the first line of input and 
                                               - set z to the next line
            r   0                              - Turn it to lower case
  m                                            - Map each character
        xGd                                    - Get it's position in the alphabet
       j   2                                   - Turn it to base 2
   .[05                                        - Pad the start with 0's
 s                                             - Turn it to a 1d-array (flatten it)
V                                        ;     - For N in above array:
                 #                )            - While 1:
                      @z~Z+1Z                  - Get the current position in the 
                                               - second line and increment the position
                    Jr       0                 - Set J to it lowercased
                  I}          GB               - If it's a letter, break
                                pJ             - Otherwise, print it
                                    ?N         - Is the character code
                                               - (the current 1d-array) 1
                                      rJ1      - Get the current char uppered
                                         J     - Leave it lowered
                                   p           - Print the character
                                           >zZ - Print out the rest of the second input

Python 3中，216个 211 231 225 207字节

这是一个使用普通文本和Markdown样式斜体作为其两种字体的解决方案。并且它对除空格之外的所有内容进行编码。

编辑：必须修复代码，以便结果可以正确打印并在代码下方添加了示例。

编辑：由于正确打印斜体时出现问题，因此将代码编辑为以前较差的大写/小写解决方案。

def g(s,c):
 c=c.lower();w=[h.upper()for h in s if h.isalpha()];t=''.join("{:05b}".format(ord(i)-65)for i in w);r='';j=m=0
 while t[j:]:a=c[m];x=a!=" ";r+=[a,a.upper()][x*int(t[j])];j+=x;m+=1
 return r+c[m:]

例子

>>> g('HELLOWORLD', 'The quick brown fox jumps over the lazy dogs, gamboling in the fields 
where the shepherds keep watch')
'thE QUicK broWn FOx JuMPs OVEr ThE LazY DOgS, gaMbOlINg in THe fields where the shepherds keep watch'

取消高尔夫：

def bacon(message, carrier):
    # Lowers the case of the carrier message
    carrier = carrier.lower()
    # Removing all non-alphabetic characters and making the rest uppercase
    words = ""
    for char in message:
        if char.isalpha():
            words += char.upper()
    # Encoding the message
    binary = ""
    for letter in words:
        encode = ord(letter) - 65
        binary += "{:05b}".format(encode)
    # Encoding the carrier message
    result = ""
    bin_index = 0
    char_index = 0
    while bin_index < len(binary):
        letter = carrier[char_index]
        # If letter isn't a space and it needs to be encoded
        if letter != " " and int(binary[bin_index]): 
            letter = letter.upper()
        result += type + letter + type
        # The encoding only proceeds if letter wasn't a space
        bin_index += letter != " "
        # char_index increments whether or not letter was alphabetical
        char_index += 1
    # Return the encoded text and any leftover characters from the carrier message
    return result + carrier[char_index : ]

C，124字节

这要求自变量采用ASCII兼容的编码（例如ISO-8859.1或UTF-8）。它就地修改载波，并在成功时返回0，否则返回非零。编码为A==小写和B==大写。未使用的承运人字母设置为上限。

int f(char*p,char*s){int m=16;do{if(isalpha(*s)){*s|=32;*s-=(*p-1)&m?32:0;if(!(m/=2)){m=16;p+=!!*p;}}}while(*++s);return*p;}

说明

包括测试程序。将字母编码作为第一个参数，将载体字符串作为第二个参数。

#include <stdio.h>
#include <ctype.h>

/* ASCII or compatible encoding assumed */
int f(char *p, char *s)         /* plaintext, carrier */
{
    int m=16;                   /* mask */
    do {
        if (isalpha(*s)) {
            *s |= 32;
            *s -= (*p-1)&m ? 32 : 0;
            if (!(m/=2)) {
                /* reset mask and advance unless we reached the end */
                m=16;
                p+=!!*p;
            }
        }
    } while (*++s);

    /* 0 (success) if we finished p, else non-zero */
    return *p;
}

int main(int argc, char **argv)
{
    int r = argc < 3 || f(argv[1], argv[2]);
    if (r)
        puts("~!^%&$+++NO CARRIER+++");
    else
        puts(argv[2]);
    return r;
}

测试输出：

$ ./66019 "HELLOWORLD" "The quick brown fox jumps over the lazy dogs, gamboling in the fields where the shepherds keep watch."  
thE QUicK broWn FOx JuMPs OVEr ThE LazY DOgS, gamBoLiNG in tHE FIELDS WHERE THE SHEPHERDS KEEP WATCH.