Les mots courants doivent toujours être évités pour être utilisés comme mots de passe. Ce défi consiste à coder un programme très simple qui communique un mot de passe donné ( M odifier U ntil N ot G uessed E asily).

Contribution

Un mot, qui est une chaîne écrite dans l'alphabet abcdefghijklmnopqrstuvwxyz. Peu importe que les lettres soient en minuscules ou en majuscules.

Munging

1. Remplacez toute séquence répétée d'une même lettre par elle-même, précédée du nombre de fois que la lettre a été répétée ( LLLLavec 4L)
2. Changez le premier aavec@
3. Changez le premier bavec8
4. Changez le premier cavec(
5. Changez le premier davec6
6. Changez le premier eavec3
7. Changez le premier favec#
8. Changez le premier gavec9
9. Changez le premier havec#
10. Changez le premier iavec1
11. Changez la seconde iavec!
12. Changez le premier kavec<
13. Changez le premier lavec1
14. Changez la seconde laveci
15. Changez le premier oavec0
16. Changez le premier qavec9
17. Changez le premier savec5
18. Changez la seconde savec$
19. Changez le premier tavec+
20. Changez le premier vavec>
21. Changez la seconde vavec<
22. Changez le premier wavecuu
23. Changez la seconde wavec2u
24. Changez le premier xavec%
25. Changez le premier yavec?

La règle 1 doit être appliquée le nombre de fois nécessaire jusqu'à ce qu'il ne soit plus possible de l'appliquer davantage. Après cela, le reste des règles est appliqué.

Sortie Le mot munged

Exemples

• codegolf -> (0639o1#
• programming -> pr09r@2m1ng
• puzzles -> pu2z135
• passwords -> p@25uu0r6$
• wwww -> 4uu
• aaaaaaaaaaa -> 11a
• lllolllolll -> 3103io3l
• jjjmjjjj -> 3jm4j

Il s'agit de code-golf , veuillez donc rendre votre programme le plus court possible!

Rien dans ce post ne doit être utilisé comme idées de mot de passe ou comme partie des pratiques de mot de passe.

Java 8, 237 321 319 280 247 241 240 237 octets

s->{for(int a[]=new int[26],i=0,l=s.length,t,x;i<l;i+=t){for(t=0;++t+i<l&&s[i]==s[t+i];);System.out.print((t>1?t+"":"")+(++a[x=s[i]-65]>2?s[i]:"@8(63#9#1J<1MN0P9R5+U>u%?ZABCDEFGH!JKiMNOPQR$TU<2XYZ".charAt(x+26*~-a[x])+(x==22?"u":"")));}}

+84 octets car les règles ont changé. ( EDIT: Enfin, revenons à mes 237 octets initiaux. ) Remplacer WWWWpar 222West facile en Java, mais 4Wpas ... Si seulement Java avait un moyen d'utiliser le groupe de capture regex pour quelque chose. . Obtenir la longueur avec "$1".length(), remplacer la correspondance elle-même par "$1".replace(...), convertir la correspondance en un entier avec new Integer("$1"), ou utiliser quelque chose de similaire à Retina (c.-à-d.s.replaceAll("(?=(.)\\1)(\\1)+","$#2$1") ) ou JavaScript (ie s.replaceAll("(.)\\1+",m->m.length()+m.charAt(0))) serait ma première chose que j'aimerais voir en Java dans le futur pour bénéficier du codegolfing ..>.> Je pense que c'est la 10ème fois que je déteste Java ne peut rien faire avec le match de groupe de capture ..
-78 octets grâce à @ OlivierGrégoire .

Les E / S sont en majuscules.

Explication:

Essayez-le ici.

s->{                           // Method with String parameter and no return-type
  for(int a[]=new int[26],     //  Array with 26x 0
          i=0,                 //  Index-integer, starting at 0
          l=s.length,          //  Length
          t,x;                 //  Temp integers
      i<l;                     //  Loop (1) over the characters of the input
      i+=t){                   //    After every iteration: Increase `i` by `t`
    for(t=0;++                 //   Reset `t` to 1
        t+i<l                  //   Inner loop (2) from `t+i` to `l` (exclusive)
        &&s[i]==s[t+i];        //   as long as the `i`'th and `t+i`'th characters are equal
    );                         //   End of inner loop (2)
    System.out.print(          //   Print:
     (t>1?t+"":"")             //    If `t` is larger than 1: print `t`
     +(++a[x=s[i]-65]>2?       //    +If the current character occurs for the third time:
       s[i]                    //      Simply print the character
      :                        //     Else:
       "@8(63#9#1J<1MN0P9R5+U>u%?ZABCDEFGH!JKiMNOPQR$TU<2XYZ".charAt(x
                               //      Print the converted character at position `x`
        +26*~-a[x])            //       + 26 if it's the second time occurring
       +(x==22?"u":"")));      //      And also print an additional "u" if it's 'W'
  }                            //  End of loop (1)
}                              // End of method

JavaScript (ES6), 147 octets

s=>[[/(.)\1+/g,m=>m.length+m[0]],..."a@b8c(d6e3f#g9h#i1k<l1o0q9s5t+v>x%y?i!lis$v<".match(/../g),["w","uu"],["w","2u"]].map(r=>s=s.replace(...r))&&s

Cas de test

f=
s=>[[/(.)\1+/g,m=>m.length+m[0]],..."a@b8c(d6e3f#g9h#i1k<l1o0q9s5t+v>x%y?i!lis$v<".match(/../g),["w","uu"],["w","2u"]].map(r=>s=s.replace(...r))&&s

;["codegolf","programming","puzzles","passwords","aabaa","www","lllolllolll","jmnpruz"]
.forEach(t=>console.log(t,"->",f(t)))

.as-console-wrapper{max-height:100%!important}

Explication

Exécute une série de remplacements sur la chaîne d'entrée s, dans l'ordre spécifié par le défi. Chaque élément de la série est un tableau ou une chaîne, avec deux éléments, qui est ensuite spread ( ...r) et transmis à s.replace().

s=>[
    [/(.)\1+/g, m=>m.length + m[0]],// first replacement: transform repeated letters
                                    // into run-length encoding

                                    // string split into length-2 partitions and
                                    // spread into the main array
    ..."a@b8c(d6e3f#g9h#i1k<l1o0q9s5t+v>x%y?i!lis$v<".match(/../g),
                                    // next replacements: all single-char replacements.
                                    // "second" versions are placed at the end so they
                                    //    replace the second instance of that char

    ["w","uu"],["w","2u"]           // last replacements: the two "w" replacements
]
.map(r=> s = s.replace(...r))       // run all replacements, updating s as we go
&& s                                // and return the final string

05AB1E , 69 octets

-9 octets grâce à Emigna

γvygD≠×yÙ}J.•k®zĀÒĀ+ÎÍ=ëµι
•"@8(63#9#1<1095+>%?!i$<"ø'w„uu„2u‚â«vy`.;

Essayez-le en ligne!

Perl 5 , 152 + 1 ( -p) = 153 octets

s/(.)\1+/(length$&).$1/ge;%k='a@b8c(d6e3f#g9h#i1j!k<l1mio0q9r5s$t+u>v<x%y?'=~/./g;for$i(sort keys%k){$r=$k{$i};$i=~y/jmru/ilsv/;s/$i/$r/}s/w/uu/;s/w/2u/

Essayez-le en ligne!

Probablement pas le plus golfé possible, mais ça marche.

-6 octets grâce aux ovs

-77 octets grâce à NieDzejkob et Jonathan French

Python 3 , 329 323 octets 246 octets

import re;n=input()
for a in re.finditer('(\w)\\1+',n):b=a.group();n=n.replace(b,str(len(b))+b[0],1)
for A,B,C in[('abcdefghikloqstvxyw','@8(63#9#1<1095+>%?','uu'),('ilsvw','!i$<','2u')]:
	for a,b in zip(A,list(B)+[C]):n=n.replace(a,b,1)
print(n)

Essayez-le en ligne!

Rétine , 166 124 octets

(.)\1+
$.&$1
([a-y])(?<!\1.+)
¶$&
¶w
uu
T`l¶`@8(63#9#1j<\1mn0\p9r5+u>\w%?_`¶.
([ilsvw])(?<!\1.+)
¶$&
¶w
2u
T`i\lsv¶`!i$<_`¶.

Essayez-le en ligne!Explication:

(.)\1+
$.&$1

Remplacez une série de lettres répétées par la longueur et la lettre.

([a-y])(?<!\1.+)
¶$&

Faites correspondre la première occurrence des lettres aà yet marquez-les avec un espace réservé.

¶w
uu

Correction de la première occurrence de w.

T`l¶`@8(63#9#1j<\1mn0\p9r5+u>\w%?_`¶.

Corrigez la première occurrence de toutes les autres lettres de aà yet supprimez les espaces réservés.

([ilsvw])(?<!\1.+)
¶$&

Marquer le ( à l' origine) deuxième occurrence des lettres i, l, s, vou wavec un espace réservé.

¶w
2u

Correction de la deuxième occurrence de w.

T`i\lsv¶`!i$<_`¶.

Correction de la deuxième occurrence des quatre autres lettres.

Haskell , 221 218 213 octets

($(f<$>words"w2u li i! s$ v< a@ b8 c( d6 e3 f# g9 h# i1 k< l1 o0 q9 s5 t+ v> wuu x% y?")++[r]).foldr($)
f(a:b)(h:t)|a==h=b++t|1>0=h:f(a:b)t
f _ s=s
r(a:b)|(p,q)<-span(==a)b=[c|c<-show$1+length p,p>[]]++a:r q
r s=s

Essayez-le en ligne!

Des abus foldrpour exécuter la chaîne à travers une séquence de transformations de chaîne à l'envers. La séquence "commence" avec rlaquelle se fait le remplacement du nombre de répétitions en utilisant spanpour casser la queue de la chaîne lorsqu'elle cesse d'être égale à la tête. Si la première partie n'est pas vide, c'est une répétition, nous imprimons donc la longueur +1. Ensuite, nous curry un argument enf pour chaque remplacement de caractère dans l'ordre (inverse). Les remplacements sont codés comme une chaîne unique, le premier caractère étant le caractère à remplacer et le reste comme la chaîne (puisque les remplacements w sont plusieurs caractères) pour aller à sa place. J'ai mis ces chaînes codées dans une grande chaîne séparée par des espaces afin de wordspouvoir la décomposer en une liste pour moi.

EDIT: Merci @Laikoni de m'avoir sauvé 5 octets! C'était une utilisation intelligente de laquelle $je ne pensais pas. Je ne connaissais pas non plus cette <-astuce.

Lua , 173 octets

s=...for c,r in("uua@b8c(d6e3f#g9h#i1i!jjk<l1limmnno0ppq9rrs5s$t+v>v<wuuw2ux%y?zz"):gmatch"(.)(.u?)"do s=s:gsub(c..c.."+",function(p)return#p..c end):gsub(c,r,1)end print(s)

Essayez-le en ligne!

Non golfé et expliqué:

s = ...


--This string contains every character to replace, followed by
--the character(s) it should be replaced with.
--
--It also contains all characters for which repeated sequences
--of them should be replaced by "<number><character>". That is,
--all letters in the alphabet. This way, a single loop can do
--both the "replace repeated characters" and "encode characters"
--operations, saving a for loop iterating over the alphabet.
--
--Characters that shouldn't be replaced will be replaced with
--themselves.
--
--In order to avoid matching half of the "replace u with u"
--command as the replace part of another command, "uu" is placed
--at the beginning of the string. This ensures that only the
--2-character replacements for "w" get an extra "u".

cmdstring = "uua@b8c(d6e3f#g9h#i1i!jjk<l1limmnno0ppq9rrs5s$t+v>v<wuuw2ux%y?zz"


--Iterate over all the search/replace commands.
--The character to replace is in the "c" variable, the string to
--replace it with is in "r".
--
--Due to the dummy search/replace commands (i.e. "mm") placed
--in the string, this loop will also iterate over all letters
--of the alphabet.

for c,r in cmdstring:gmatch("(.)(.u?)") do
	
	--First, replace any occurences of the current letter
	--multiple times in a row with "<number><letter>".
	s = s:gsub(c..c.."+", function(p)
		return #p .. c
	end)
	
	--Then, replace the first occurence of the letter
	--with the replacement from the command string.
	s = s:gsub(c, r, 1)
end

print(s)

C # (.NET Core), 317 , 289 , 279 octets

p=>{string r="",l=r,h=r,c="a@b8c(d6e3f#g9h#i1i!k<l1lio0q9s5s$t+v>v<wuw2x%y?";int i=0,n=p.Length,d,a=1;for(;i<n;i++){h=p[i]+"";if(h==p[(i==n-1?i:i+1)]+""&&i!=n-1)a++;else{d=c.IndexOf(h);if(d>=0&&d%2<1){l=c[d+1]+"";h=l=="u"?"uu":l;c=c.Remove(d,2);}r+=a>1?a+""+h:h;a=1;}}return r;};

Essayez-le en ligne!

J'espère que c'est correct de recevoir un tableau de caractères en entrée et non une chaîne.

Non golfé :

string result = "", casesCharReplacement = result, currentChar = result, cases = "a@b8c(d6e3f#g9h#i1i!k<l1lio0q9s5s$t+v>v<wuw2x%y?";
int i = 0, n = pas.Length, casesIndex, charAmounts = 1;

// For every char in the pass.
for (; i < n; i++)
{
    currentChar = pas[i] + "";
    // if the next char is equal to the current and its not the end of the string then add a +1 to the repeated letter.
    if (currentChar == (pas[(i == n - 1 ? i : i + 1)] + "") && i != n - 1)
        charAmounts++;
    else
    {
        // Finished reading repeated chars (N+Char).
        casesIndex = cases.IndexOf(currentChar);
        // Look for the replacement character: only if the index is an even position, otherwise I could mess up with letters like 'i'.
        if (casesIndex >= 0 && casesIndex % 2 < 1)
        {
            casesCharReplacement = cases[casesIndex + 1]+"";
            // Add the **** +u
            currentChar = casesCharReplacement == "u"?"uu": casesCharReplacement;
            // Remove the 2 replacement characters (ex: a@) as I won't need them anymore.
            cases = cases.Remove(casesIndex, 2);
        }
        // if the amount of letters founded is =1 then only the letter, otherwise number and the letter already replaced with the cases.
        result += charAmounts > 1 ? charAmounts + ""+currentChar : currentChar;
        charAmounts = 1;
    }
}
return result;

C ++, 571 495 478 444 octets

-127 octets grâce à Zacharý

#include<string>
#define F r.find(
#define U(S,n)p=F s(S)+b[i]);if(p-size_t(-1)){b.replace(i,1,r.substr(p+n+1,F'/',n+p)-p-2));r.replace(p+1,F'/',p+1)-p,"");}
#define V(A)i<A.size();++i,c
using s=std::string;s m(s a){s b,r="/a@/b8/c(/d6/e3/f#/g9/h#/i1//i!/k</l1//li/o0/q9/s5//s$/t+/v>/wuu//w2u/x%/y?/";int c=1,i=0;for(;V(a)=1){for(;a[i]==a[i+1]&&1+V(a)++);b+=(c-1?std::to_string(c):"")+a[i];}for(i=0;V(b)){auto U("/",1)else{U("//",2)}}return b;}

la "/a@/b8/c(/d6/e3/f#/g9/h#/i1//i!/k</l1//li/o0/q9/s5//s$/t+/v>/wuu//w2u/x%/y?/"chaîne est utilisée pour passer d'un caractère à d'autres. 1 /signifie que le premier "caractère suivant" doit être remplacé par ce qui suit le suivant /, 2 signifie que le deuxième "caractère suivant" doit être remplacé par ce qui suit.

Essayez-le en ligne

R , 224 219 octets

function(s,K=function(x)el(strsplit(x,"")),u=rle(K(s)))
Reduce(function(x,y)sub(K('abcdefghiiklloqsstvvwwxy')[y],c(K('@8(63#9#1!<1i095$+><'),'uu','2u',K('%?'))[y],x),1:24,paste0(gsub("1","",paste(u$l)),u$v,collapse=""))

Essayez-le en ligne!

Méchant, mais l'essentiel est la substitution itérative dans le Reduce. subne modifie que la première occurrence de la correspondance.

Merci à JayCe d'avoir souligné un beau golf!

Perl 5 , 123 octets

Code de 122 octets + 1 pour -p.

Développé indépendamment de la réponse de @ Xcali , mais en utilisant un processus très similaire.

s/(.)\1+/$&=~y!!!c.$1/ge;eval"s/$1/$2/"while'a@b8c(d6e3f#g9h#i1i!k<l1lio0q9s5t+v>v<x%y?'=~/(.)(.)/g;s/s/\$/;s/w/uu/;s;w;2u

Essayez-le en ligne!

Python 2 , 220 216 194 190 190 188 octets

import re
S=re.sub(r'(.)\1+',lambda m:`len(m.group(0))`+m.group(1),input())
for a,b in zip('abcdefghiiklloqsstvvxyww',list('@8(63#9#1!<1i095$+><%?')+['uu','2u']):S=S.replace(a,b,1)
print S

Essayez-le en ligne!

Python 3 , 187 octets

import re
S=re.sub(r'(.)\1+',lambda m:str(len(m.group(0)))+m.group(1),input())
for a,b in zip('abcdefghiiklloqsstvvxyww',[*'@8(63#9#1!<1i095$+><%?','uu','2u']):S=S.replace(a,b,1)
print(S)

Essayez-le en ligne!

Pip , 103 102 octets

aR:`(.)\1+`#_.B
Fm"abcdefghiiklloqsstvvwwxy"Z"@8(63#9#1!<1i095$+><WU%?"I#Ya@?@maRA:ym@1aR'W"uu"R'U"2u"

Essayez-le en ligne!

Explication

Le code effectue trois étapes de transformation:

aR:`(.)\1+`#_.B  Process runs of identical letters

a                1st cmdline argument
 R:              Do this replacement and assign back to a:
   `(.)\1+`       This regex (matches 2 or more of same character in a row)
           #_.B   Replace with callback function: concatenate (length of full match) and
                  (first capture group)
                  Note: #_.B is a shortcut form for {#a.b}

Fm"..."Z"..."I#Ya@?@maRA:ym@1  Do the bulk of rules 2-25

  "..."                        String of letters to replace
       Z"..."                  Zip with string of characters to replace with
Fm                             For each m in the zipped list:
                   @m           First item of m is letter to replace
                a@?             Find its index in a, or nil if it isn't in a
               Y                Yank that into y
             I#                 If len of that is truthy:*
                     aRA:        Replace character in a at...
                         y        index y...
                          m@1     with second item of m

aR'W"uu"R'U"2u"  Clean up substitution
                 In the previous step, the replacements each had to be a single character.
                 This doesn't work for uu and 2u, so we use W and U instead (safe, since
                 uppercase letters won't be in the input) and replace them here with the
                 correct substitutions.
aR'W"uu"         In a, replace W with uu
        R'U"2u"  and U with 2u
                 and print the result (implicit)

* Nous devons tester si a@?m@0est nul. Il ne suffit pas de vérifier sa véracité, car 0 est un indice légitime qui est falsey. Pip n'a pas de méthode intégrée courte pour tester si une valeur est nulle, mais tester sa longueur fonctionne assez bien dans ce cas: tout nombre aura une longueur d'au moins 1 (véridique), et nil aura une longueur de zéro (falsey).