입력

인쇄 할 수없는 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] 범위에 있도록 보장됩니다 .
• _입력 문자열에 전혀 없을 수도 있습니다 .이 경우 입력 만 반환하면됩니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다!

테스트 사례

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.

파이썬 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()

온라인으로 사용해보십시오!

펄 5 -pF -MList::Util=sum, 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멤버와 동일하게 설정합니다 . 문자, 숫자 및 ; 숫자입니다. 그래서 아무것도하지만, 문자이며 , 그리고 모든 문자와이 문자를. 의 문자를 검사하지 않습니다 . (입력은 ASCII가 보장되기 때문에 작동합니다.)@F\W|\d\W_\d\W|\d_@a__@a
• map{a gt shift@a&&16/2**$_}0..40 ~ 4에 대해 다음을 수행합니다. 다음 요소를의 밖으로 이동하여 @a짧게하고 a해당 요소보다 우연히 더 큰지 여부 (즉, 해당 요소가 대문자인지 여부)를 평가합니다 . 그렇다면 &&단락되지 않았으므로 입력 값 (0 ~ 4)의 출력에 대해 16을 2로 나눕니다. 그렇지 않으면 &&단락되고 0을 얻습니다. map5 개의 숫자 목록을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에게 감사합니다

^{젤리 친화적 인 도전은 아닙니다!}

ḟŒ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}

분할 Aa5 그룹으로들.

A
aA
+`Aa
aAA

이진수에서 단항으로 변환 A하고 1과 a0으로 취급합니다. Aa원래 5 초가 있었기 때문에 알파벳에서 원하는 위치에 따라 5 a초가 더해 A집니다.

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

a다음 수에 따라 마지막을 늘리십시오 A.

^
$+¶

원래 입력 앞에 붙습니다.

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

_s를 다음에 해독 된 문자로 바꿉니다 .

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

익명 람다, ⎕IO(인덱스 원점)이이라고 가정 합니다 0.

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

온라인으로 사용해보십시오!

{... ⋄... } 이 문 기능; ⍵주장이며 ⋄진술을 분리한다

 ⊢ 인수 (무 연산 기능)
 '_'= 밑줄 (즉, 부울 매핑 기능)와 같은
 _← 해당 기능을 지정하지_

 A[... ]@_⍵ 다음과 같은 문자를 넣어 A 에서 인수에 밑줄의 위치
  ⎕A 대문자 lphabet  할당하는 것을  을 소문자 ( 819 ≈ 큰 , 아니 왼쪽 인자 수단 즉, 소문자, 크지 포함)  앞에 추가 대문자 알파벳; 이것은 우리에게  논쟁의 모든 문자 교차점을 제공 합니다.  대문자 알파벳의 구성원 인 논쟁의 글자 들; 비트 대문자 ... r에 eshape 그 다음 행 번호 및 5 개 개의 컬럼 :  인자에 밑줄 마스크  합이; 밑줄 수
  A←A
  819⌶
  A,
  ⍵∩
  A∊⍨
  ()5⍴ 
   _⍵
   +/
  ⍉ 전치 (각 행을 비트 위치가 아닌 숫자로 처리하기 위해)
  2⊥ 기본 2
 819⌶ 소문자 로 평가

스칼라 , 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
}                                        //

자바 스크립트 (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

온라인으로 사용해보십시오!

Jonathan Allan과는 다른 접근법. 편집 : 그래서, 음, Jonathan Allan과 동일한 바이트 축소를 생각했기 때문에 그의 이름을 다시 언급하는 것은 상처받지 않습니다.

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]

자바 스크립트 (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 바이트를 절약했습니다! 덕분에 53 바이트 절약@ovs 절약했습니다!

밑줄이없는 문자열로 인한 버그로 인해 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
]

자바 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}

온라인으로 사용해보십시오!

apt, 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.

파이썬 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 = 입력 ()

문자열에서 첫 번째 _의 색인을 찾아서 저장합니다.

f = u.find ( '_')

모든 비 알파 문자의 문자열을 제거합니다

m = ''. join ([c.isalpha () 인 경우 u의 c에 c))

알파 문자열을 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 ([o의 경우 o의 경우 1) o의 경우 '1'인 경우 '1'), 2) +65)의 경우 [m [h : h + 5]의 l len (l) == 5 인 경우 h 범위 (0, len (m), 5)]의 h

첫 번째 _ 뒤의 모든 문자를 찾고 해당 위치의 배열 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 (목록 ​​(u [f :]))]

* 답을 인쇄하십시오 *

print ( ''. join (u) .lower ())

하스켈 , 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

펄 5 -p , 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

온라인으로 사용해보십시오!