PRATIQUES DE PRODUCTION ET ACTION ____


45

Contribution

Chaîne codée non vide composée de caractères ASCII imprimables (dans la plage 32-126), dans laquelle certaines lettres manquantes ont été remplacées par _.

Sortie

Chaîne décodée de même longueur avec toutes les lettres en minuscule, y compris les lettres manquantes.

Comment?

Edit: Comme mentionné par @Deusovi dans les commentaires, il s'agit d'une variante du chiffrement de Bacon .

  • Rassemblez toutes les lettres de la chaîne d'origine et regroupez-les par 5. Les lettres supplémentaires qui ne font pas partie d'un groupe de 5 sont ignorées.
  • Convertissez chaque groupe en binaire: minuscule = 0 , majuscule = 1 . Cela conduit à une liste d'entiers.
  • Utilisez chaque valeur N dans cette liste pour remplacer chacune _dans la chaîne d'origine par la N- ème lettre de l'alphabet (indexé par 0), dans l'ordre d'apparition.

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

En remplaçant les lettres manquantes et en reconvertissant le tout en minuscules, la chaîne d'origine est dévoilée:

programming puzzles & code golf

C'est la sortie attendue.

Clarifications et règles

  • Les lettres manquantes sont garanties pour apparaître à la fin de la chaîne. Plus formellement: il n'y aura jamais de lettre après la première _dans la chaîne d'entrée. Cependant, il peut exister d'autres caractères ASCII imprimables tels que des espaces et des signes de ponctuation.
  • Il est garanti que l’entrée ne contient aucune lettre majuscule inutile : toutes les lettres majuscules sont des bits mis à 1 qui sont nécessaires pour décoder les lettres manquantes. Tout le reste est en minuscule.
  • La chaîne d'entrée est garantie d'être valide. Surtout:
    • Il contiendra toujours suffisamment de groupes complets de 5 lettres pour décoder les traits de soulignement.
    • Les entiers codés en binaire sont garantis dans la plage [0-25] .
  • Il peut ne pas y _en avoir du tout dans la chaîne d'entrée, auquel cas il vous suffit de renvoyer l'entrée.
  • C'est du , donc la réponse la plus courte en octets gagne!

Cas de test

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.

Quelques cas de test supplémentaires:

Input : BInar_
Output: binary

Input : 12 MonKey_
Output: 12 monkeys

Input : hyPerbolIZ__
Output: hyperbolized

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

Devrions-nous considérer seulement autant de groupes de 5 qu'il y a de soulignés dans l'entrée?
Fruit Esolanging

Dans ce cas, la règle lorsqu'il n'y a pas _de chaîne d'entrée est un cas particulier.
Fruit d'Esolanging

1
Ooh, Chiffre Bacon!
Deusovi

1
@SztupY Comme The input is guaranteed not to contain any useless capital letters'il n'y avait pas de caractère de soulignement, il n'y aurait pas non plus de lettre majuscule.
Laikoni

1
@KirillL. Oui, n'importe quoi dans [32-126]. J'ai ajouté un autre cas de test.
Arnauld

Réponses:


19

05AB1E , 18 octets

Code:

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

Utilise le codage 05AB1E . Essayez-le en ligne!

Explication:

á                       # 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.


8

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

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

Essayez-le en ligne!

Explication:

  • -pFlit une ligne d'entrée dans la variable $_et, divisée en caractères, dans le tableau @F.
  • @a=grep!/\W|\d/,@Fdéfinit le tableau comme @aégal aux membres de @Fqui ne satisfont pas l'expression rationnelle \W|\d. \West tout sauf des lettres, des chiffres et _; \dest des nombres. Il en \W|\dva de même pour les lettres et _, et @atoutes les lettres et tous les _caractères. Nous ne finirons jamais par examiner les _personnages @a. (Notez que cela ne fonctionne que parce que l'entrée est garantie en ASCII.)
  • map{a gt shift@a&&16/2**$_}0..4effectue les opérations suivantes pour les opérations de 0 à 4: décale le prochain élément @a, le raccourcit et évalue s'il aest supérieur ou inférieur à cet élément (c'est-à-dire si cet élément est en majuscule). Si c'est le cas, &&n'est pas court-circuité, nous obtenons donc 16 divisé par 2 à la puissance de la valeur d'entrée (0 à 4). Sinon &&est court-circuité et nous obtenons 0. maprenvoie la liste des cinq nombres à sumqui les ajoute.
  • C'est l'élément que nous voulons dans la liste a..z, et c'est ce que nous obtenons (a..z)[…].
  • s!_!…!egconvertit chacun _à $_son tour en la lettre appropriée.
  • $_=lcse convertit $_en minuscule et l’ -pimprime.


5

Gelée ,  28 27  26 octets

-1 merci à Erik l'Outgolfer & Dylnan

Pas un défi très jelly-friendly!

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

Un lien monadique acceptant et renvoyant des listes de caractères.

Essayez-le en ligne!

Comment?

ḟŒ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?"

5

Retina , 91 90 octets

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

Essayez-le en ligne! Explication:

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

Traduisez en minuscules aet majuscules A, en supprimant tout le reste.

L`.{5}

Diviser le Aas en groupes de 5.

A
aA
+`Aa
aAA

Convertissez les valeurs binaires en unaires en considérant A1 et a0. Comme il y avait 5 Aasecondes à l'origine, il en reste 5 a, plus un nombre de Asecondes en fonction de la position souhaitée dans l'alphabet.

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

Incrémenter le dernier en afonction du nombre de As suivants .

^
$+¶

Préposer l'entrée d'origine.

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

Remplacez _les lettres s par la lettre décodée suivante.

0G`

Supprimez toutes les lettres décodées de rechange.

T`L`l

Tout en minuscule.

Retina 0.8.2 , 117 octets

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

Essayez-le en ligne! Explication:

.+
$&¶$&

Dupliquer l'entrée.

T`L`l`^.*

Minuscule la première copie.

T`l`a`.*$

Traduire les lettres minuscules aen deuxième copie.

T`L`A

Traduire les lettres majuscules en A. Ceux-ci doivent être dans la deuxième copie car la première copie était déjà en minuscule.

T`aAp`aA_`.*$

Supprimer tout le reste de la deuxième copie.

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

Divisez la deuxième copie (maintenant juste Aas) en groupes de 5.

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

Décodez les lettres et insérez-les comme avant.


5

APL (Dyalog Unicode) , SBCS 46 octets

Anonyme lambda, Assume ⎕IO(Index Origin) 0.

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

Essayez-le en ligne!

{... ... } fonction à deux déclaration; est l'argument, sépare les déclarations

 argument (fonction non-op)
'_'= où égal à un trait de soulignement (c.-à-d. une fonction de mappage booléen)
_← affecte cette fonction à_

A[... ]@_⍵ mettre les caractères suivants de A à des positions de underscores dans l'argument de
  ⎕A la majuscule A lphabet
  A← assignons à A
  819⌶ ce minuscule ( 819 ≈ gRANDE , sans aucun moyen d'argument gauche pas grand, par exemple en minuscules)
  A, précédez l'alphabet en majuscules; cela nous donne toutes les lettres
  ⍵∩ intersection de l'argument et cela; juste les lettres de l'argument
  A∊⍨ qui sont de l'alphabet majuscule; majuscules des bits
  (... )5⍴r Eshape que pour le nombre suivant de lignes et cinq colonnes:
   _⍵ le masque de soulignement dans l'argument
   +/ somme; nombre de traits de soulignement
   transposer (pour traiter chaque ligne comme un nombre plutôt que comme une position de bit)
  2⊥ évalue en
819⌶ minuscule la base 2


5

Scala , 189 octets

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

Essayez-le en ligne!

Explication:

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


4

Gelée , 26 octets

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

Essayez-le en ligne!

Approche différente de celle de Jonathan Allan. EDIT: Donc, apparemment, j’ai pensé à la même réduction d’octets que Jonathan Allan, il n’ya donc pas de mal à mentionner son nom à nouveau.



3

Propre , 180 ... 150 octets

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

Essayez-le en ligne!

Définit la fonction $ :: [Char] -> [Char]avec @ :: [Char] [Char] -> [Char]comme aide pour remplacer les caractères de soulignement et ? :: [Char] -> [Char]comme aide pour générer les caractères de remplacement.


Comment fonctionne la i<-:""pièce? Les caractères sont-ils implicitement convertis en nombres lors de leur addition ou de leur addition?
Laikoni

@ Laikoni non, il n'y a pas de conversion implicite. Vous pouvez cependant ajouter et soustraire des caractères.
urous

3

JavaScript (Node.js) , 100 octets

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

Essayez-le en ligne!

Grâce à @Arnauld, enregistre 2 octets.


1
@ Arnauld vous avez raison. édité pour /[a-z]/gimaintenant.
tsh

3

R , 153 135 113 octets

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

Essayez-le en ligne!

Emet quelques avertissements avec l'utilisation de matrixmais cela ne devrait pas affecter le résultat. Également émet des avertissements, car l' [<-affectation supprimera les objets assignés superflus par défaut.

40 octets de moins (!) Grâce aux améliorations de JayCe


Je ne pense pas que tu ,length(L)%/%5
aies

Aussi pas besoin de définir L?
JayCe

@JayCe ok bien aujourd'hui, j'ai appris que [<-les éléments qui dépasseraient la longueur des index risquent de disparaître ...
Giuseppe

Moi aussi en fait!
JayCe


3

C (gcc) , 111 109 101 100 octets

Edit: Ajout de la minuscule par le commentaire de @ FrownyFrog; merci à Lynn, Christoph et user5329483 pour leurs suggestions!

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

Essayez-le en ligne!


Vous pouvez économiser 2 octets avec i+=i+(*s<97).
Lynn

Vous pouvez supprimer jen insérant un marqueur iet en réécrivant le second pour as for(i=1;i<32;s++). Et compenser le supplément de 32 à l'extérieur pour. En tant que newbee ici, je compte sept octets de réserve.
user5329483

Trouvé un autre octet: for(i=3;i<96;s++)ramène le 65 à un nombre à un chiffre, aka 1.
user5329483

2

Go, 219 217 192 210 209 156 octets

Sauvegardé 25 octets grâce à @Lynn! 53 octets sauvés grâce à @ovs!

Devait perdre 18 octets à cause d'un bogue avec des chaînes sans caractère de soulignement :(

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

Essayez-le en ligne!


2

Stax , 22 octets

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

Exécuter et déboguer

L’approche générale consiste à remplacer "_"par une expression régulière l’ utilisation d’une fonction de rappel qui coupe les lettres des entrées pour calculer chaque caractère de remplacement.

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

Exécuter celui-ci


1

Rouge , 247 octets

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]

Essayez-le en ligne!

Plus lisible:

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
]

1

Java 10, 186 octets

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

Essayez-le en ligne.

Explication:

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


1

Japt, 25 octets

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

L'essayer


Explication

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

1

Pyth, 36 octets

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

Essayez ici

Explication

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.

1

Python 3.5 , 296 octets

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

Essayez-le en ligne

Premier code golf :)

(Je sais que ce n'est pas petit en octets, je m'amusais juste à faire un code d'une ligne)

Voici l'explication:


Entrée utilisateur

u = entrée ()


Trouve l'index du premier _ de la chaîne et le stocke

f = u.find ('_')


efface la chaîne de tous les caractères non alpha

m = ''. join ([c pour c dans u si c.isalpha ()])


Divise la chaîne alpha en un tableau avec chaque élément composé de 5 caractères

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

Puis convertit les caractères minuscules en 0 et les caractères majuscules en 1

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

et convertit la chaîne binaire en entier, ajoute 65 et la convertit en caractère

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

z = [chr (int (''. join (['0' si o.islower () sinon '1' pour o dans l]], 2) +65) pour l dans [m [h: h + 5] pour h dans l'intervalle (0, len (m), 5)] si len (l) == 5]


trouve tous les caractères après le premier _ et les place dans le tableau z à leurs emplacements respectifs (définis ci-dessus)

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

[z.insert (v, d) pour v, d dans énumérer (u [f:]) si d! = "_"]


diviser notre chaîne en une liste de caractères

u = liste (u)


coupez notre chaîne du premier _ à la fin de la liste et remplacez-la par le tableau z. Je devais également couper le tableau z à la longueur de la chaîne scindée du premier _ à la fin car j'avais un caractère supplémentaire dans l'exemple de chien paresseux (le "a" à la fin des exemples ci-dessus)

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


* imprimer la réponse *

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



Le golf ne se limite pas à tout mettre sur une même ligne. 165 octets
Jo King

Vous pouvez supprimer l'espace entre o.islower()et else, et je pense '1'et for. En outre, vous pouvez changer if d!="_"en if"_"!=d, mais le commentaire ci-dessus le fait déjà.
Zacharý

1

Haskell , 165 octets

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]

Essayez-le en ligne! Exemple d'utilisation: g"" "BInar_"rendements "binary".


1

PowerShell , 121 octets

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

Essayez-le en ligne!

Moins joué au golf:

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

0

Perl 5 -p , 78 octets

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

Essayez-le en ligne!


Je l'ai corrigé avec 3 octets supplémentaires, ce qui rend votre réponse un peu meilleure avec les règles actuelles.
Xcali

Pas mieux mais différent. Chaque langue + les options sont considérées séparément, sans entrer en concurrence avec la même langue + les autres options, telles que je les comprends.
msh210
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.