输入项

一个非空的编码字符串，由可打印的ASCII字符组成（范围为32-126），其中一些丢失的字母已替换为_。

输出量

长度相同的解码字符串，所有字母均小写，包括丢失的字母。

怎么样？

编辑：正如@Deusovi在评论中提到的，这是Bacon密码的一种变体。

• 收集原始字符串中的所有字母，然后将它们分组为5。不适合全部5个字符的其他字母将被忽略。
• 将每个组转换为二进制：小写= 0，大写= 1。这导致一个整数列表。
• 使用此列表中的每个值N，按出现顺序_将原始字符串中的每个值替换为字母的第N个字母（0索引）。

例： prOGraMMIng PuZZleS & cOde ____

prOGr --> 00110 -->  6 -->  7th letter = 'g'
aMMIn --> 01110 --> 14 --> 15th letter = 'o'
gPuZZ --> 01011 --> 11 --> 12th letter = 'l'
leScO --> 00101 -->  5 -->  6th letter = 'f'

通过替换丢失的字母并将所有内容都转换回小写，原始字符串被公开：

programming puzzles & code golf

这是预期的输出。

澄清和规则

• 保证缺少的字母出现在字符串的末尾。更正式地讲：_输入字符串中的第一个字母之后绝不会有任何字母。但是，可能还有其他可打印的ASCII字符，例如空格和标点符号。
• 保证输入中不包含任何无用的大写字母：所有大写字母都是设置为1的位，用于解码丢失的字母。其他所有内容均为小写。
• 输入的字符串保证有效。特别：
  • 它将始终包含足够的完整组（由5个字母组成）以解码下划线。
  • 二进制编码的整数保证在[0-25]范围内。
• _输入字符串中可能根本没有任何内容，在这种情况下，您只需要返回输入即可。
• 这是代码高尔夫球，因此最短答案以字节为单位！

测试用例

Input : hello!
Output: hello!

Input : helLO, worl_!
Output: hello, world!

Input : i aM yoUr faTh__.
Output: i am your father.

Input : prOGraMMIng PuZZleS & cOde ____
Output: programming puzzles & code golf

Input : Can YOu gUesS tHE ENd oF This ____?
Output: can you guess the end of this text?

Input : THe qUICk brown FOx JUMps oVEr the la__ ___.
Output: the quick brown fox jumps over the lazy dog.

Input : RoadS? wHERe we're goinG WE doN't need _____.
Output: roads? where we're going we don't need roads.

Input : thE greatESt Trick thE DeVIl EVer PUllEd wAs CONvInciNg tHe WorLD h_ ____'_ _____.
Output: the greatest trick the devil ever pulled was convincing the world he didn't exist.

一些额外的测试用例：

Input : BInar_
Output: binary

Input : 12 MonKey_
Output: 12 monkeys

Input : hyPerbolIZ__
Output: hyperbolized

Input : {[One Last Test ca__]}
Output: {[one last test case]}

05AB1E，18个字节

码：

áS.u5ôJC>.bv'_y.;l

使用05AB1E编码。在线尝试！

说明：

á                       # Remove non-letters from the input string.
 S                      # Split the result into individual characters.
  .u                    # Check if is uppercase for each character.
    5ôJ                 # Split into binary numbers of length 5.
       C                # Convert from binary to decimal.
        >               # Add one.
         .b             # Map 1 → A, 2 → B, 3 → C, ..., 25 → Y, 26 → Z.
           v            # For each letter:
            '_y.;       #   Replace the first occurrence of '_' with the current letter.
                 l      #   Convert the string to lowercase.

Python 2，113字节

s=input()
i=k=0
for c in s:
 if c.isalpha():k+=k+(c<'a');i+=1;s=s.replace('_',chr(k%32+97),i%5<1)
print s.lower()

在线尝试！

Perl -pF -MList::Util=sum5，75个字节

@a=grep!/\W|\d/,@F;s!_!(a..z)[sum map{a gt shift@a&&16/2**$_}0..4]!eg;$_=lc

在线尝试！

说明：

• -pF将输入行读入变量$_，然后将其拆分为字符，并读入数组@F。
• @a=grep!/\W|\d/,@F将数组设置为@a等于那些@F不满足正则表达式的成员\W|\d。\W除了字母，数字和之外_，什么都不是；\d是数字。所以\W|\d是什么，但信和_，并且@a拥有所有的字母和_字符。我们将永远不要检查中的_字符@a。（请注意，这仅适用于输入保证为ASCII的情况。）
• map{a gt shift@a&&16/2**$_}0..4对0到4执行以下操作：将下一个元素移出@a，将其缩短，并评估它的折号是否a大于该元素（即该元素是否为大写）。如果是这样，&&则不会短路，因此我们得到16除以2得到输入值（0到4）的功率。否则&&短路，我们得到0。map将五个数字的列表返回到sum，将它们相加。
• 这就是我们想要从列表中a..z获取的元素，而这正是我们从中得到的(a..z)[…]。
• s!_!…!eg每个转换_中$_，反过来，以适当的字母。
• $_=lc转换$_为其自身的小写版本，并进行-p打印。

J，62 61字节

tolower u:@]`(I.@t=.'_'=[)`[}+/@t$97+_5#.\3|0 2 4-.~'@Z`z'&I.

在线尝试！

果冻， 28 27  26 字节

-1感谢Outgolfer和dylnan的Erik

^{这不是对果冻友好的挑战！}

ḟŒs$Ƈ<”[s5Ḅ+97Ọż@ṣ”_$FṁLŒl

接受和返回字符列表的单子链接。

在线尝试！

怎么样？

ḟŒs$Ƈ<”[s5Ḅ+97Ọż@ṣ”_$FṁLŒl - Link: list of characters    e.g. "MfUNE_?"  (shorthand for ['M','f','U','N','E','_','?'])
    Ƈ                      - filter keep each if:
   $                       -   last two links as a monad:
 Œs                        -     swap-case
ḟ                          -     filter discard
                           - ...i.e. keep A-Z,a-z since they change when the case is swapped
                           -                                  "MfUNE"
      ”[                   - literal character                '['
     <                     - less than? (i.e. is upper-case?) [1,0,1,1,1]
        s5                 - split into fives                 [[1,0,1,1,1]]
          Ḅ                - from base two (vectorises)       [[23]]
           +97             - add (vectorises) ninety-seven    [[120]]
              Ọ            - from ordinals (vectorises)       [['x']]
                    $      - last two links as a monad:
                  ”_       -   literal character              '_'
                 ṣ         -   split at                       [['M','f','U','N','E'],['?']]
               ż@          - swapped @rgument zip             [[['M','f','U','N','E'],'x'],['?']]
                     F     - flatten                          "MfUNEx?"
                       L   - length (of input)                7
                      ṁ    - mould like                       "MfUNEx?"
                           - ...removes any excess characters
                        Œl - lower-case                       "mfunex?"

视网膜，91 90字节

T`l`a
T`L`A
[^Aa]

L`.{5}
A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
^
$+¶
+`_(.*)¶a+(.)
$2$1
0G`
T`L`l

在线尝试！说明：

T`l`a
T`L`A
[^Aa]

将小写字母转换为a，大写字母转换为A，删除其他所有内容。

L`.{5}

将Aas分成5组。

A
aA
+`Aa
aAA

从二进制转换为一进制，分别A作为1和a0。由于Aa最初有5 as ，所以还剩下5 s，再加上一些As，具体取决于字母表中的期望位置。

+T`_lA`l_`[^A]A

a根据以下As 的数量递增最后一个。

^
$+¶

附加原始输入。

+`_(.*)¶a+(.)
$2$1

用_下一个已解码的字母替换任何。

0G`

删除所有备用的解码字母。

T`L`l

小写的一切。

视网膜0.8.2，117字节

.+
$&¶$&
T`L`l`^.*
T`l`a`.*$
T`L`A
T`aAp`aA_`.*$
(.*¶)?.{5}
$&;
A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
+`_(.*¶)a+(.);
$2$1
1G`

在线尝试！说明：

.+
$&¶$&

复制输入。

T`L`l`^.*

小写第一份副本。

T`l`a`.*$

a在第二个副本中将小写字母翻译成。

T`L`A

将大写字母转换为A。这些必须在第二个副本中，因为第一个副本已经小写。

T`aAp`aA_`.*$

删除第二个副本中的所有其他内容。

(.*¶)?.{5}
$&;

将第二个副本（现在为Aas）分成5组。

A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
+`_(.*¶)a+(.);
$2$1
1G`

解码字母并像以前一样插入它们。

APL（Dyalog Unicode），46 字节^SBCS

匿名lambda，假定⎕IO（索引原点）为0。

{_←'_'=⊢⋄819⌶A[2⊥⍉(+/_⍵)5⍴A∊⍨⍵∩A,819⌶A←⎕A]@_⍵}

在线尝试！

{... ⋄... } 两个函数的声明; ⍵是参数，⋄分隔语句

 ⊢
 '_'= 等于下划线（即布尔映射函数）的 参数（无操作函数）
 _← 将该函数分配给_

 A[... ]@_⍵ 把下面的字符A 在下划线的位置在参数
  ⎕A 大写一个 lphabet
  A← 赋值给A
  819⌶ 小写它（819≈大，没有左参数的手段并不大，即小写）
  A, 前面加上大写字母; 这给了我们所有
  ⍵∩ 参数的字母交集；只是论点中的字母，
  A∊⍨ 其中哪一个是大写字母的成员；大写比特
  (... )5⍴ ř ESHAPE其以下的行数，和五列：
   _⍵ 在参数下划线的掩模
   +/ 总和是什么; 下划线数量
  ⍉ 转置（将每一行视为一个数字而不是一个位）将 所有结果都
  2⊥ 以2为
 819⌶小写

Scala，189字节

def f(s:Array[Char])={var j=0;s.zipWithIndex.collect{case(95,i)=>s(i)=(Integer.parseInt(s.filter(_.isLetter)slice(j,j+5)map(k=>if(k<91)1 else 0)mkString,2)+97)toChar;j+=5};s.map(_.toLower)}

在线尝试！

说明：

def f(s: Array[Char]) = {                // takes a String in input
  var j = 0                              // j stores at which block of 5 letters we're currently at
  s.zipWithIndex.collect {               // Array('h', 'e', ...) => Array(('h', 0) ('e', 1), ...) and we apply a collect transformation (filter/map)
    case (95, i) =>                      // we only handle cases where the char is '_' (95)
      s(i) = (                           // we modify the char at index i with the following
        Integer.parseInt(                // Integer.parseInt("00110", 2) = 6
          s                              //
            .filter(_.isLetter)          // filter out non letter chars (spaces, punct, figures, ...) from the input string (thanks @Arnauld for the fix)A
            .slice(j, j+5)               // "substring" the array to the block of 5 letters in question
            .map(                        // map on the current block of 5 letters
              k =>                       // the index of the next char in the block f 5 (e.g. 13)
                if (k < 91) 1 else 0     // if the current char is upper case (<91) then we replace it by a bit true, otherwise by a bit false
            )mkString,                   // Array(0, 1, 1, ...) => "011..."
          2                              // cast string to binary
        )                                //
        + 97                             // +97 to create a lower case char
      )toChar                            // cast from int to char
      j += 5                             // update the starting index of the next block of 5 letters
    }                                    //
  s.map(_.toLower)                       // return the updated seq of chars all in lower case
}                                        //

的JavaScript（Node.js的），125个 124字节

x=>x.replace(s=/./g,c=>parseInt(c,36)>9?c.toLowerCase(s+=+(c<{})):c=='_'?('0b'+s.slice(4,9)-~9).toString(36,s=s.slice(5)):c)

在线尝试！

果冻，26个字节

xn¥Œs<”[s5Ḅ‘ịØaṛi”_ḟ0Ɗ¦ƒŒl

在线尝试！

与乔纳森·艾伦的方法不同。编辑：所以，我，呃，显然想到了与乔纳森·艾伦相同的字节减少，因此再次提及他的名字也没有什么害处。

CJam，43个字节

q'_/_0={el_eu=!},_eu.=5/2fb65f+:c1$,(<.+:el

在线尝试！

干净，180 ... 150字节

import StdEnv
?s=['a'+sum[i\\i<-:""&c<-s|c<'a']: ?(drop 5s)]
@['_':b][x:y]=[x: @b y]
@[a:b]z=[toLower a: @b z]
@e _=e
$s= @s(?(filter isAlpha s))

在线尝试！

定义函数$ :: [Char] -> [Char]以@ :: [Char] [Char] -> [Char]用作替换下划线? :: [Char] -> [Char]的助手，以及作为生成替换字符的助手。

JavaScript（Node.js），100字节

s=>s.toLowerCase(c=/[a-z]/gi).replace(/_/g,_=>(g=n=>n?(c.exec(s)<{})*n+g(n>>1):10)(16).toString(36))

在线尝试！

感谢@Arnauld，节省了2个字节。

[R ，153个 135 113字节

function(s,S=utf8ToInt(s)){S[S==95]=2^(4:0)%*%matrix(S[S%in%c(65:90,97:122)]<95,5)+97
cat(tolower(intToUtf8(S)))}

在线尝试！

使用发出一些警告，matrix但不应影响结果。还发出警告，因为[<-默认情况下分配会删除无关的分配对象。

由于JayCe的改进，减少了40（！）个字节

C（GCC） ，111个 109 101 100字节

编辑：根据@FrownyFrog的评论添加小写字母；感谢Lynn，Christoph和user5329483的建议！

f(s,t,i)char*s,*t;{for(t=s;t=strchr(t,95);*t=i+1)for(i=3;i<64;s++)isalpha(*s)?i=2*i|*s<97,*s|=32:0;}

在线尝试！

围棋，219个 217 192 210 209 156字节

感谢@Lynn，节省了25个字节！ 感谢@ovs，节省了53个字节！

由于没有下划线的字符串的错误而不得不丢失18个字节:(

func p(s string){b:=0;n:=0;for _,c:=range s{if IsLetter(c){b+=b;if IsUpper(c){b+=1};n++;s=g.Replace(s,"_",string('a'+b%32),(5-n%5)/5)}};Print(g.ToLower(s))}

在线尝试！

Stax，22 个字节

â╟▓ïMeee¶▐f◄┴≈┘n╛äyΩ○N

运行并调试

一般方法是"_"使用回调函数对输入的字母进行切片以计算每个替换字符的正则表达式替换。

v       convert to lower case
'_      "_" string literal
{       begin block for regex replacement
  yVl|& all the letters only from the original input
  5/    split into chunks of 5
  i@    keep the ith one, where i is the 0-based number of times this block has run
  {97<m map 5-letter chunk to bits to indicate which are lowercase
  :b    decode as 5-bit integer
  97+]  add 97 and wrap in array to convert to lower case character
}       end block for regex replacement
R       do regex replacement

运行这个

红色，247字节

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]v: copy""parse s[any[copy c a(append v to-string c)|
skip]]k: 0 t: copy""repeat n(length? v)/ 5[c: 0 p: 16
loop 5[if v/(k: k + 1) <#"a"[c: c + p]p: p / 2]append t#"a"+ c]foreach c
t[replace s"_"c]lowercase s]

在线尝试！

更具可读性：

f: func[s][
    a: charset[#"a"-#"z"#"A"-#"Z"]
    v: copy ""
    parse s[any[copy c a(append v to-string c)| skip]]
    k: 0
    t: copy ""
    repeat n (length? v) / 5[
        c: 0
        p: 16
        loop 5[
            if v/(k: k + 1) < #"a" [c: c + p]
            p: p / 2
        ]
        append t #"a" + c
    ]
    foreach c t[replace s "_" c]
    lowercase s
]

Java 10，186个字节

s->{var b="";for(int i=0,c;i<s.length();)if((b+=(c=s.charAt(i++))>64&c<91?1:c>96&c<123?0:"").length()>4)s=s.replaceFirst("_",(char)(97+Byte.valueOf(b,2))+(b=""));return s.toLowerCase();}

在线尝试。

说明：

s->{                            // Method with String as both parameter and return-type
  var b="";                     //  Binary-String, starting empty
  for(int i=0,c;i<s.length();)  //  Loop over the characters of the input-String
    if((b+=(c=s.charAt(i++))>64&c<91?
                                //   If the current character is a lowercase letter:
            1                   //    Append "1" to the binary-String
           :c>96&c<123?         //   Else-if it's an uppercase letter:
            0                   //    Append "0" to the binary-String
           :                    //   Else (not a letter):
            "")                 //    Append nothing to the binary-String
       .length()>4)             //   And if the length is now 5:
      s=s.replaceFirst("_",     //    Replace the first "_" in the input-String with:
           (char)(97+Byte.valueOf(b,2))
                                //     The binary-String as character
           +(b=""));            //    And reset the binary-String
  return s.toLowerCase();}      //  Return the modified input-String as lowercase

红宝石，107个 106 103字节

->s{s.chars.map{|c|c !~/\W|\d/?c<?a?1:0:p}.join.scan(/.{5}/){|b|s[?_]&&=(b.to_i(2)+97).chr};s.downcase}

在线尝试！

Japt，25个字节

r'_@r\L mè\A sTT±5 ÍdIÄÃv

试试吧

说明

r'_                           :Replace underscores
   @                          :Pass each match through a function
    r                         :  From original input remove
     \L                       :    /[^a-zA-Z]/g
        m                     :  Map
         è                    :    Count
          \A                  :      /[A-Z]/g
             s                :  Slice
              T               :    From index T (initially 0)
               T±5            :    To index T+=5
                   Í          :  Convert from base-2 string to base-10 integer
                     IÄ       :  Add 64+1
                    d         :  Get character at that codepoint
                       Ã      :End function
                        v     :Lowercase

Pyth，36个字节

Km@Gim!}kGd2c@+r1GGQ5VQp?qN\_.(KZr0N

在这里尝试

说明

Km@Gim!}kGd2c@+r1GGQ5VQp?qN\_.(KZr0N
             @+r1GGQ                   Get the letters from the input...
            c       5                  ... in chunks of 5.
 m        d                            For each chunk...
     m!}kG                             ... check if each letter is uppercase...
    i      2                           ... converted to binary...
  @G                                   ... and get the corresponding letter.
                     VQp               For each character in the input...
K                       ?qN\_.(KZ      ... if the character is '_', replace it...
                                 r0N   ... otherwise, lowercase it.

Python 3.5，296字节

u=input();f=u.find('_');m=''.join([c for c in u if c.isalpha()]);z=[chr(int(''.join(['0'if o.islower() else'1' for o in l]),2)+65)for l in[m[h:h+5]for h in range(0,len(m),5)]if len(l)==5];[z.insert(v,d)for v,d in enumerate(u[f:])if d!="_"];u=list(u);u[f:]=z[:len(u[f:])];print(''.join(u).lower())

在线尝试

第一次打高尔夫球:)

（我知道它的字节数不小，我只是在制作一个1行代码而感到很开心）

这里是解释：

用户输入

u = input（）

查找字符串中第一个_的索引并将其存储

f = u.find（'_'）

去除所有非字母字符的字符串

m =''。join（[如果c.isalpha（）为c，则为u中的c）

将alpha字符串拆分为一个数组，每个元素包含5个字符

例如 ['THeqU'，'ICkbr'，'ownFO'，'xJUMp'，'soVEr'，'thela']

然后将小写字符转换为0，大写字符转换为1

例如 ['11001'，'11000'，'00011'，'01110'，'00110'，'00000']

并将二进制字符串转换为整数，加65并将其转换为字符

例如 ['z'，'y'，'d'，'o'，'g'，'a']

z = [chr（int（''。join（['0'如果o.islower（）否则为'1'表示l中的o]），2）+65）表示l处于[m [h：h + 5]如果len（l）== 5]，则h在范围（0，len（m），5）]中

查找第一个_之后的所有字符，并将它们推入数组z的相应位置（如上定义）

例如 ['z'，'y'，'，'d'，'o'，'g'，'。'，'a']

[如果d！=“ _”，则枚举（u [f：]）中的v，d的z.insert（v，d）]

将我们的字符串分成字符列表

u =列表（u）

将我们的字符串从第一个_切到列表的末尾，并将其替换为数组z。我还必须将数组z切成从第一个_到末尾的分割字符串的长度，因为在惰性狗示例中（在上述示例的末尾有“ a”），我得到了一个额外的字符

u [f：] = z [：len（list（u [f：]））]

*打印答案*

print（''。join（u）.lower（））

Haskell，165个字节

g""
import Data.Char
f t(x:s)('_':r)=x:f t s r
f[0,a]s r=g(s++[chr a])r
f[n,a]s(c:r)=toLower c:f[div n$1+sum[1|isAlpha c],a+sum[n|isUpper c]]s r
f _ s e=e
g=f[16,97]

在线尝试！用法示例：g"" "BInar_"yields "binary"。

PowerShell，121字节

switch -r($args|% t*y){_{$_=$a[$n++]+97}[a-z]{$x+=$x+($_-le96);if(!(++$i%5)){$a+=,$x;$x=0};$_=$_-bor32}.{$r+=[char]$_}}$r

在线尝试！

少打高尔夫球：

switch -Regex ($args|% toCharArray){
    _ {                     # is underscore
        $_=$a[$n++]+97      # get a char from the array of letter
    }

    [a-z] {                 # is letter
        $x+=$x+($_-le96)    # $x=2*$x+($_-le96)
        if(!(++$i%5)){      # if(++$i%5 -eq 0)
            $a+=,$x         # add an element to the array of letters
            $x=0            # init
        }
        $_=$_-bor32         # to lower
    }

    . {                     # is any char ('_' and letters included)
        $r+=[char]$_        # add the char to result
    }
}
$r

Perl -p 5，78个字节

for$h(s/\W|\d//gr=~y/a-z/0/r=~y/A-Z/1/r=~/.{5}/g){s%_%chr 65+oct"0b$h"%e}$_=lc

在线尝试！