PROGRAMACIÓN DE ROMPECABEZAS Y CÓDIGO ____

45

Entrada

Una cadena codificada no vacía que consta de caracteres ASCII imprimibles (en el rango 32-126), donde se han reemplazado algunas letras faltantes _.

Salida

Una cadena decodificada de la misma longitud con todas las letras en minúsculas, incluidas las que faltan.

¿Cómo?

Editar: como lo menciona @Deusovi en los comentarios, esta es una variante del cifrado de Bacon .

  • Reúna todas las letras en la cadena original y agrúpelas por 5. Se ignoran las letras adicionales que no caben en un grupo completo de 5.
  • Convierta cada grupo en binario: minúsculas = 0 , mayúsculas = 1 . Esto lleva a una lista de enteros.
  • Use cada valor N en esta lista para reemplazar cada uno _en la cadena original con la N -ésima letra del alfabeto (0-indexado), en orden de aparición.

Ejemplo: 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'

Al reemplazar las letras que faltan y convertir todo a minúsculas, se revela la cadena original:

programming puzzles & code golf

Este es el resultado esperado.

Aclaraciones y reglas.

  • Se garantiza que las letras que faltan aparecerán al final de la cadena. Más formalmente: nunca habrá ninguna letra después de la primera _en la cadena de entrada. Sin embargo, puede haber otros caracteres ASCII imprimibles, como espacios y signos de puntuación.
  • Se garantiza que la entrada no contenga ninguna letra mayúscula inútil : todas las letras mayúsculas son bits establecidos en 1 que se requieren para decodificar las letras que faltan. Todo lo demás está en minúsculas.
  • Se garantiza que la cadena de entrada sea válida. Especialmente:
    • Siempre contendrá suficientes grupos completos de 5 letras para decodificar los guiones bajos.
    • Los enteros codificados en binario están garantizados para estar en el rango [0-25] .
  • Es posible que no haya ninguno _en la cadena de entrada, en cuyo caso solo debe devolver la entrada.
  • Este es el , por lo que gana la respuesta más corta en bytes.

Casos de prueba

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.

Algunos casos de prueba adicionales:

Input : BInar_
Output: binary

Input : 12 MonKey_
Output: 12 monkeys

Input : hyPerbolIZ__
Output: hyperbolized

Input : {[One Last Test ca__]}
Output: {[one last test case]}
Arnauld
fuente
¿Deberíamos considerar solo tantos grupos de 5 como hay guiones bajos en la entrada?
Esolanging Fruit
En ese caso, la regla cuando no hay _en la cadena de entrada es un caso especial.
Esolanging Fruit
1
Ooh, cifrado de tocino!
Deusovi
1
@SztupY Como The input is guaranteed not to contain any useless capital letter, en caso de que no haya subrayado, tampoco habrá una letra mayúscula.
Laikoni
1
@KirillL. Sí, cualquier cosa adentro [32-126]. He agregado otro caso de prueba.
Arnauld

Respuestas:

19

05AB1E , 18 bytes

Código:

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

á                       # 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.
Adnan
fuente
8

Python 2 , 113 bytes

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()

Pruébalo en línea!

Lynn
fuente
8

Perl 5 -pF -MList::Util=sum, 75 bytes

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

Pruébalo en línea!

Explicación:

  • -pFlee una línea de entrada en la variable $_y, dividida en caracteres, en la matriz @F.
  • @a=grep!/\W|\d/,@Festablece la matriz @aigual a aquellos miembros @Fque no satisfacen la expresión regular \W|\d. \Wes cualquier cosa menos letras, números y _; \dson los números Así \W|\des cualquier cosa menos letras y _, y @atiene todas las letras y _caracteres. Terminaremos nunca examinando a los _personajes @a. (Tenga en cuenta que esto solo funciona porque la entrada está garantizada ASCII).
  • map{a gt shift@a&&16/2**$_}0..4hace lo siguiente para 0 a 4: quita el siguiente elemento @a, lo acorta y evalúa si aes asciibéticamente mayor que ese elemento (es decir, si ese elemento es mayúscula). Si es así, &&no está en cortocircuito, entonces obtenemos 16 dividido por 2 para obtener la potencia del valor de entrada (0 a 4). De &&lo contrario, se cortocircuita y obtenemos 0. mapdevuelve la lista de cinco números sum, que los agrega.
  • Ese es el elemento que queremos de la lista a..z, y eso es de lo que obtenemos (a..z)[…].
  • s!_!…!egconvierte cada _en $_, a su vez, a la letra apropiada.
  • $_=lcconvierte $_a la versión en minúsculas de sí mismo e -pimprime.
msh210
fuente
5

Jalea ,  28 27  26 bytes

-1 gracias a Erik the Outgolfer & dylnan

¡No es un desafío muy amigable para las gelatinas!

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

Un enlace monádico que acepta y devuelve listas de caracteres.

Pruébalo en línea!

¿Cómo?

ḟŒ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?"
Jonathan Allan
fuente
5

Retina , 91 90 bytes

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

Pruébalo en línea! Explicación:

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

Traduce letras minúsculas ay mayúsculas a A, eliminando todo lo demás.

L`.{5}

Divide la Aas en grupos de 5.

A
aA
+`Aa
aAA

Convierta de binario a unario, tratándolo Acomo 1 y acomo 0. Dado que originalmente había 5 Aas, quedan 5 as, más un número de As dependiendo de la posición deseada en el alfabeto.

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

Incremente el último de aacuerdo con el número de As siguientes .

^
$+¶

Anteponer la entrada original.

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

Reemplace cualquier _s con la siguiente letra decodificada.

0G`

Elimine las letras decodificadas de repuesto.

T`L`l

Todo en minúscula.

Retina 0.8.2 , 117 bytes

.+
$&¶$&
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`

Pruébalo en línea! Explicación:

.+
$&¶$&

Duplicar la entrada.

T`L`l`^.*

Minúscula la primera copia.

T`l`a`.*$

Traduzca letras minúsculas a aen la segunda copia.

T`L`A

Traducir letras mayúsculas a A. Estos deben estar en la segunda copia porque la primera copia ya estaba en minúscula.

T`aAp`aA_`.*$

Eliminar todo lo demás en la segunda copia.

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

Divida la segunda copia (ahora solo Aas) en grupos de 5.

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

Decodifique las letras e insértelas como antes.

Neil
fuente
5

APL (Dyalog Unicode) , 46 bytes SBCS

Lambda anónima, se supone ⎕IO(origen del índice) para ser 0.

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

Pruébalo en línea!

{... ... función de } dos enunciados; es el argumento, separa las declaraciones

 argumento (función no operativa)
'_'= donde igual a un guión bajo (es decir, una función de mapeo booleano)
_← asigna esa función a_

A[... ]@_⍵ coloque los siguientes caracteres A en las posiciones de guiones bajos en el argumento
  ⎕A el alfabeto en mayúscula A lo
  A← asigna a A
  819⌶ minúsculas ( 819 ≈ BIg , sin argumento a la izquierda significa que no es grande, es decir, minúsculas)
  A, anteponer el alfabeto en mayúsculas; esto nos da todas las letras de
  ⍵∩ intersección del argumento y eso; solo las letras del argumento
  A∊⍨ cuáles de esos son miembros del alfabeto en mayúsculas; mayúscula pedacitos
  (... )5⍴r eshape que al siguiente número de filas y cinco columnas:
   _⍵ la máscara de subrayados en el argumento
   +/ suma que; cantidad de guiones bajos
   transponer (para tratar cada fila como un número en lugar de como una posición de bit)
  2⊥ evaluar como
819⌶ todo en minúsculas base-2

Adán
fuente
5

Scala , 189 bytes

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)}

Pruébalo en línea!

Explicación:

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
}                                        //
Xavier Guihot
fuente
4

Jalea , 26 bytes

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

Pruébalo en línea!

Enfoque diferente al de Jonathan Allan. EDITAR: Entonces, aparentemente pensé en la misma reducción de bytes que Jonathan Allan, por lo que no hace daño mencionar su nombre nuevamente.

Erik el Outgolfer
fuente
3

Limpio , 180 ... 150 bytes

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))

Pruébalo en línea!

Define la función $ :: [Char] -> [Char]con @ :: [Char] [Char] -> [Char]como ayudante para reemplazar guiones bajos y ? :: [Char] -> [Char]como ayudante para generar los caracteres de reemplazo.

Οurous
fuente
¿Cómo funciona la i<-:""pieza? ¿Los caracteres se convierten implícitamente en números al sumarlos o agregarlos?
Laikoni
@Laikoni no, no hay conversión implícita. Sin embargo, puedes sumar y restar caracteres.
Precioso
3

JavaScript (Node.js) , 100 bytes

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

Pruébalo en línea!

Gracias a @Arnauld, ahorra 2 bytes.

tsh
fuente
1
@Arnauld tienes razón. editado hasta /[a-z]/giahora.
tsh
3

R , 153 135 113 bytes

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)))}

Pruébalo en línea!

Emite algunas advertencias con el uso de, matrixpero eso no debería afectar el resultado. También emite advertencias ya que la [<-asignación eliminará los objetos asignados extraños por defecto.

40 (!) Bytes abajo gracias a las mejoras de JayCe

Giuseppe
fuente
No creo que necesites,length(L)%/%5
JayCe
¿Tampoco es necesario definir L?
JayCe
@JayCe está bien, hoy aprendí que [<-arrojará elementos más allá de la longitud de los índices ...
Giuseppe
Yo también en realidad!
JayCe
3

C (gcc) , 111 109 101 100 bytes

Editar: Se agregaron minúsculas por el comentario de @ FrownyFrog; ¡Gracias a Lynn, Christoph y user5329483 por sus sugerencias!

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;}

Pruébalo en línea!

ErikF
fuente
Puede guardar 2 bytes con i+=i+(*s<97).
Lynn
Podrías abolirlo jintroduciendo un bit marcador iy reescribiendo el segundo por as for(i=1;i<32;s++). Y compensar los 32 adicionales en el exterior. Como un novato aquí cuento un repuesto de siete bytes.
user5329483
Encontró otro byte: for(i=3;i<96;s++)reduce el 65 a un número de un solo dígito, también conocido como 1.
user5329483
2

Ir, 219 217 192 210 209 156 bytes

¡Ahorró 25 bytes gracias a @Lynn! Guardado 53 bytes gracias a @ovs!

Tuve que perder 18 bytes debido a un error con cadenas sin guiones bajos :(

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))}

Pruébalo en línea!

ollien
fuente
2

Stax , 22 bytes

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

Ejecutar y depurarlo

El enfoque general es un reemplazo de expresión regular del "_"uso de una función de devolución de llamada que corta letras de las entradas para calcular cada carácter de reemplazo.

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

Ejecute este

recursivo
fuente
1

Rojo , 247 bytes

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]

Pruébalo en línea!

Más legible:

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
]
Galen Ivanov
fuente
1

Java 10, 186 bytes

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();}

Pruébalo en línea.

Explicación:

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
Kevin Cruijssen
fuente
1

Rubí , 107 106 103 bytes

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

Pruébalo en línea!

Kirill L.
fuente
1

Japt, 25 bytes

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

Intentalo


Explicación

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
Lanudo
fuente
1

Pyth, 36 bytes

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

Pruébalo aquí

Explicación

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.
Mnemotécnico
fuente
1

Python 3.5 , 296 bytes

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())

Pruébalo en línea

Primer código de golf :)

(Sé que no es pequeño en bytes, me estaba divirtiendo haciendo un código de 1 línea)

Aquí está la explicación:


Entrada del usuario

u = input ()


Encuentra el índice del primer _ en la cadena y lo almacena

f = u.find ('_')


elimina la cadena de todos los caracteres no alfa

m = ''. join ([c para c en u si c.isalpha ()])


Divide la cadena alfa en una matriz con cada elemento que consta de 5 caracteres

Ex. ['THeqU', 'ICkbr', 'ownFO', 'xJUMp', 'soVEr', 'thela']

Luego convierte los caracteres en minúsculas a 0 y los caracteres en mayúsculas a 1

Ex. ['11001', '11000', '00011', '01110', '00110', '00000']

y convierte la cadena binaria en un número entero, agrega 65 y lo convierte en un carácter

Ex. ['z', 'y', 'd', 'o', 'g', 'a']

z = [chr (int (''. join (['0' if o.islower () else '1' para o en l]), 2) +65) para l en [m [h: h + 5] para h en el rango (0, len (m), 5)] si len (l) == 5]


encuentra todos los caracteres después del primer _ y los empuja a la matriz z en sus ubicaciones respectivas (definidas anteriormente)

Ex. ['z', 'y', '', 'd', 'o', 'g', '.', 'a']

[z.insert (v, d) para v, d en enumerate (u [f:]) if d! = "_"]


dividir nuestra cadena en una lista de caracteres

u = lista (u)


divida nuestra cadena desde el primer _ hasta el final de la lista y reemplácela con la matriz z. También tuve que cortar la matriz z a la longitud de la cadena dividida desde el primer _ hasta el final porque obtuve un carácter adicional en el ejemplo de perro perezoso (la "a" al final de los ejemplos anteriores)

u [f:] = z [: len (lista (u [f:]))]


* imprime la respuesta *

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


Travis
fuente
Jugar al golf es más que solo tener todo en una línea. 165 bytes
Jo King
Puede eliminar el espacio entre o.islower()y else, y creo que '1'y for. Además, puede cambiar if d!="_"a if"_"!=d, pero el comentario anterior ya lo hace.
Zacharý
1

Haskell , 165 bytes

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]

Pruébalo en línea! Ejemplo de uso: g"" "BInar_"rendimientos "binary".

Laikoni
fuente
1

PowerShell , 121 bytes

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

Pruébalo en línea!

Menos golfizado:

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
mazzy
fuente
0

Perl 5 -p , 78 bytes

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

Pruébalo en línea!

Xcali
fuente
Lo arreglé con 3 bytes más, lo que hace que su respuesta sea un poco mejor según las reglas actuales.
Xcali
No mejor pero diferente. Cada idioma + opciones se considera por separado, no compite con el mismo idioma + otras opciones, según tengo entendido.
msh210