Ihre Herausforderung besteht darin, den String mit einem Passwort zu versehen! Was ist die Passworteingabe?

Nehmen Sie eine Zeichenfolge als Eingabe. Diese Zeichenfolge enthält nur Großbuchstaben, Kleinbuchstaben, Ziffern und Leerzeichen.

Sie müssen alle Leerzeichen durch Unterstriche ersetzen und alle Zahlen in der Reihenfolge von links nach rechts an das Ende der Zeichenfolge verschieben. Ändern Sie ihn dann für jeden Buchstaben in der Zeichenfolge nach dem Zufallsprinzip in Groß- oder Kleinbuchstaben.

Beispiele (Groß- und Kleinschreibung sollte sich jedes Mal ändern):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

Kürzester Code in Bytes gewinnt!

Wer sich bei Information Security SE erkundigt, ob dies ein guter Hashalgorithmus ist, gewinnt! - Keine Sorge, SE-Overlords, ich mache nur Spaß.

Pyth, 15 Bytes

s}D`MTrRO2Xzd\_

Demonstration

s}D`MTrRO2Xzd\_
                   Implicit: z = input(), d = ' '
          Xzd\_    In z, replace ' ' with '_'.
      rR           To each character, apply r-function
        O2         Randomly 0 or 1. r 0 is lowercase, r 1 is uppercase.
 }D                Order the characters based on presence in
   `MT             The strings of the numbers 0 to 9.
s                  Concatenate into a string.

Labyrinth , 76 Bytes

 `:_64/"32}
,`    (3  :=-{
"`{"; _v2$  ;`3
"`".:@ ; ".5(`3.
<       "" `^`;>

Eine weitere Zusammenarbeit mit @ MartinBüttner und auf der verrückteren Seite des Labyrinth-Spektrums - zum ersten Mal haben wir alle vier ^>v<in einem Programm. Probieren Sie es online!

Erläuterung

Der allgemeine Algorithmus, der in einer Schleife ausgeführt wird, lautet wie folgt:

 1.   Read a char
 2.   If EOF:
 3.     Move all digits from auxiliary stack to main
 4.     Output all digits on main stack
 5.     Halt
      Otherwise:
 6.     If char is a letter (c >= 64):
 7.       If random turns left:
 8.         Output char XOR 32
          Otherwise:
 9.         Output char
        Otherwise:
10.       Shift char to auxiliary stack
11.       If char is space (c-32 == 0):
12.         Pull char back from auxiliary stack
13.         Output underscore
          Otherwise:
14.         Continue loop

Um die Erklärung kompakt zu halten, ist hier ungefähr angegeben, wie jeder Teil des Programms dem obigen Pseudocode entspricht:

Hier sind die interessanten Teile.

Zufälligkeit im Labyrinth

Es gibt nur einen Weg, um Zufälligkeit in Labyrinth zu bekommen, und zwar, wenn die IP versucht, vorwärts zu gehen, aber 1) es gibt weder einen Pfad vorwärts noch rückwärts und 2) es gibt Pfade links und rechts. In diesem Fall wählt die IP zufällig zwischen der linken und der rechten Route.

Dies ist nur mit den ^>v<Operatoren möglich, die ndie Zeile / Spalte num 1 verschieben. Zum Beispiel das Programm ( Online ausprobieren! )

" 1
""v!@
  2
   !@

Gibt entweder 1 oder 2 nach dem Zufallsprinzip aus, da die vSpalte mit dem Offset 0 (dh die Spalte, in der die IP aktiv ist) um 1 verschoben wird, was ergibt

"
""1!@
  v
  2!@

Die IP zeigt nach rechts und versucht vorwärts zu gehen (Stack-Spitze ist Null), kann aber nicht. Es kann sich auch nicht rückwärts bewegen, also wählt es nach dem Zufallsprinzip zwischen links und rechts.

Golf-Tricks

• Das Programm startet ab dem ersten Zeichen in der Lesereihenfolge. Sie werden feststellen, dass Schritt 6 tatsächlich ausgeführt wird. Wenn Sie jedoch aus einem leeren Labyrinth-Stapel herausspringen, erhalten Sie den Wert 0. Daher werden die Schritte 10 und 14 ausgeführt und verschieben eine Null in den Zusatzstapel, was effektiv ist ein No-Op.

• Der Hauptstapel ist nach jeder Iteration praktisch leer, was es uns ermöglicht, das Codelayout mit >und <auf den impliziten Nullen am unteren Rand abzugrenzen. Das >umschließt die untere Reihe um , so dass die IP bewegt sich von rechts unten nach links unten, und die <Verschiebungen der Reihe zurück. Die IP bewegt sich dann glücklich in der linken Spalte nach oben, um die Schleife fortzusetzen.

• Ziffern im Labyrinth platzen nund drücken 10*n + <digit>. Zusätzlich werden Zeichen vor der Ausgabe modulo 256 genommen. Wenn wir diese beiden zusammenfügen, können wir 95 (Unterstrich) ausgeben, indem wir `3332 (Leerzeichen) verwenden, was funktioniert, weil -3233 % 256 = 95. Auch wenn es andere Möglichkeiten gibt, 32 in 95 umzuwandeln (was ;95am einfachsten ist), können wir den Code hier mit einer negativen Zahl ein wenig mit Linkskurven komprimieren.

05AB1E , 22 21 20 Bytes

Code:

þ¹žh-s«ð'_:vyždÈiš}?

Verwendet CP-1252- Codierung.

Probieren Sie es online!

CJam , 25 Bytes

lelS'_er{58<}${2mr{eu}&}%

Probieren Sie es online!

Erläuterung

Übersetzung meiner MATL-Antwort.

l                            e# read line as a string
 el                          e# make lowercase
   S'_er                     e# replace spaces by underscores
        {58<}$               e# (stable) sort with key "is digit"
              {        }%    e# map block over the string
               2mr           e# generate 0 or 1 equiprobably
                  {eu}&      e# if it's 1, make uppercase

CJam, 23 Bytes

lS'_er{60<}${eu_el+mR}%

Teste es hier.

Erläuterung

l       e# Read input.
S'_er   e# Turn spaces into underscores.
{60<}$  e# Sort (stably) by whether the character is a digit or not. This moves digits
        e# to the end, without changing the relative order within digits or non-digits.
{       e# Map this block over the characters...
  eu    e#   Convert to upper case.
  _el   e#   Make a copy and convert to lower case.
  +     e#   Join them into one string.
  mR    e#   Randomly choose one of the characters. Of course, this entire block is a
        e#   no-op for non-letter characters.
}%

Python, 107 Bytes

from random import*
lambda s:''.join([choice(c+c.swapcase()),'_'][c<'!']for c in sorted(s,key=str.isdigit))

Eine Verbesserung gegenüber den beiden anderen Python-Antworten, weil:

• [...,'_'][c<'!']wird anstelle von s.replace(' ','_'), und verwendet
• choice(c+c.swapcase()) wird anstelle von verwendet choice([c.upper(),c.lower()])

JavaScript (ES6), 114 101 Byte

s=>s.replace(/./g,c=>c>'9'?c[`to${Math.random()<.5?"Low":"Upp"}erCase`]():c>' '?(s+=c,''):'_',s='')+s

47 Bytes, um den Fall eines Zeichens zufällig zu ordnen ...

Bearbeiten: Dank @ edc65 wurden massive 13 Bytes gespeichert.

MATL , 27 Bytes

k32'_'XEt58<2$S"@rEk?Xk]]v!

Probieren Sie es online!

k         % implicit input. Make lowercase. Non-lettters are not affected
32'_'XE   % replace spaces by underscores
t58<      % duplicate. Create logical index: true for digits, false otherwise
2$S       % sort first string according to second. Sort is stable
"         % for each character in that string
  @       %   push that character
  rEk     %   generate 0 or 1 with 1/2 probability each
  ?       %   if it's a 1
    Xk    %     make uppercase. Non-letters are not affected
  ]       %   end if
]         % end for each
v         % vertically concatenate all stack contents
!         % transpose into a row char array, i.e. a string. Implicit display

Python 3, 128 122 118 Zeichen

from random import*
s=lambda x:''.join(choice(i.upper()+i.lower())for i in sorted(x.replace(' ','_'),key=str.isdigit))

Danke an xnor für das Abschneiden von 6 Bytes.

Perl 6, 77 75 61 Bytes

{[~] |S:g/' '/_/.comb(/\D/)».&{(.lc,.uc).pick},|.comb(/\d/)}

S///ist wie, s///außer es ändert sich nicht $_an Ort und Stelle

Pyth, 17 Bytes

smrdO2o}N`UT:zd\_

Probieren Sie es hier aus!

Erläuterung

smrdO2o} N`UT: zd \ _ # z = input

            : zd \ _ # Leerzeichen durch Unterstriche ersetzen
      o # Sortieren ^ mit Tastenfunktion (N)
       } N`UT # N in "0123456789", gibt 1 für Zahlen an, damit diese nach rechts sortiert werden
 m # ordne jedes Zeichen d von ^ zu
  rdO2 # Wandelt d-Zufälle in Groß- oder Kleinbuchstaben um
s # Join-Liste wieder in eine Zeichenfolge

Mathematica, 86 Bytes

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

RandomChoice[{ToLowerCase,Capitalize}]@#/." "->"_"&/@Characters@#~SortBy~{DigitQ}<>""&

Ahhh, Stringverarbeitung Mathematica ... ist das nicht schön? Dies ist eine unbenannte Funktion, die eine Zeichenfolge akzeptiert und zurückgibt.

Aufgrund des syntaktischen Zuckers ist die Lesereihenfolge etwas lustig:

Characters@#

Teilen Sie den String in Zeichen auf, sonst können wir damit gar nichts anfangen.

...~SortBy~{DigitQ}

Sortiert die Ziffern bis zum Ende. Indem wir die Testfunktion in eine Liste einschließen, machen wir die Sortierung stabil.

...&/@...

Ordnet die linke Funktion jedem Zeichen in der Liste zu.

RandomChoice[{ToLowerCase,Capitalize}]

Wählt eine zufällige Funktion zum Ändern der Groß- / Kleinschreibung für das aktuelle Zeichen.

...@#...

Wendet es auf das aktuelle Zeichen an.

.../." "->"_"

Ersetzt Leerzeichen durch Unterstriche.

...<>""

Fügt schließlich alle Zeichen wieder zu einer Zeichenfolge zusammen.

PowerShell, 113 Bytes

-join([char[]]$args[0]-replace" ","_"|%{if($_-match"\d"){$d+=$_}else{"'$_'.To$("Low","Upp"|random)er()"|iex}})+$d

PowerShell steht für schreckliche Golfsprache. In ein Zeichenfeld aufteilen und Leerzeichen durch Unterstriche ersetzen. Nimm jeden Charakter und Prozess. Sammle Zahlen in die Variable $ d für die spätere Ausgabe. Jedes andere Zeichen wird zufällig in Groß- oder Kleinbuchstaben umgewandelt, indem ein Ausdruck mit 'char'.ToLower()oder aufgerufen wird 'char'.ToUpper(). Wenn Ziffern gesammelt wurden, hängen Sie diese am Ende an.

Julia, 88 87 78 Bytes

s->join([c<33?'_':rand([ucfirst,lcfirst])("$c")for c=sort([s...],by=isdigit)])

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Zuerst zerlegen wir die Eingabezeichenfolge in ein Array von Zeichen und sortieren das Array danach, ob jedes Zeichen eine Ziffer ist. Dadurch bleiben die Reihenfolge im Text und in den Ziffern erhalten, die Ziffern werden jedoch bis zum Ende verschoben. Dann prüfen wir für jedes Zeichen im Array, ob es sich um ein Leerzeichen handelt. Wenn ja, ersetzen Sie es durch einen Unterstrich. Andernfalls wählen Sie zufällig eines von ucfirstoder aus lcfirst, um es auf das Zeichen anzuwenden, und konvertieren Sie es in Groß- oder Kleinbuchstaben. Verbinden Sie das Array zu einem String und wir sind fertig!

Probieren Sie es hier aus

9 Bytes gespart dank Sp3000!

Perl, 51 48 Bytes

Beinhaltet +2 für -lp

Führen Sie mit der Eingabe auf STDIN aus:

perl -lp passwordify.pl <<< "Hel1lo wo4rld"

passwordify.pl:

s%\pL%$&^$"x rand 2%eg;$_=y/ 0-9/_/dr.s/\D//gr

Faktor 154 Bytes

oder 222 mit importieren kernel splitting sequences ascii combinators.random regexp

: f ( x -- y ) R/ \d/ R/ \D/ [ all-matching-subseqs ] bi-curry@ bi [ { [ >upper ] [ >lower ] } call-random ] map [ "" join ] bi@ " " "_" replace prepend ;

Ich kann nicht so gut Golf spielen, und ich bin mir nicht sicher, ob ich hier den besten Ansatz gewählt habe, dachte aber, ich würde es versuchen

Ruby, 84 Bytes

Anonyme Funktion. Das Entfernen des Leerzeichens zuvor c.downcaseverursacht aus irgendeinem Grund einen Syntaxfehler, und ich bin mir nicht sicher, warum.

->s{q="";s.gsub(/./){|c|c=~/\d/?(q+=c;p):c==" "??_:rand<0.5?c.upcase: c.downcase}+q}

Lua, 125 Bytes

Wenn Objekt auf funktional trifft, können Sie einige schöne Dinge tun, sogar in lua! Ich glaube nicht, dass ich das runtergolfen kann, es ist schon ein ziemliches Durcheinander, und ich bin schon glücklich, die meisten Python-Antworten zu schlagen: D.

s=""print((...):gsub("%d",function(d)s=s..d return""end):gsub("%s","_"):gsub("%a",1<math.random(2)and s.upper or s.lower)..s)

Ungolfed und Erklärungen

s=""                       -- Initialise the string that will contains the digits
print((...)                -- apply the following to the argument then print it
  :gsub("%d",function(d)   -- iterate over the digits
    s=s..d                 -- concatenate them in s
    return""               -- remove them from the arg
   end)
  :gsub("%s","_")          -- replace spaces by underscores
  :gsub("%a",              -- iterate over letters
    1<math.random(2)       -- pick a random integer between 1 and 2
      and s.upper          -- if it is 2, use the function upper() of object s
      or s.lower)          -- else, use the function lower() of object s
  ..s)                     -- concatenate with s

Im Ernst, 25 Bytes

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ

Probieren Sie es online!

Erläuterung:

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ
,`              `M         map over input:
  '_' (Æ                     replace spaces with underscores
        ≈                    cast to int (does nothing if cast fails)
         "ûù"J£ƒ             randomly upper- or lowercase it (does nothing if not letter)
                  ;ì;(-+   move ints to back
                        Σ  join

IPOS - nicht konkurrierend, 14 Bytes

S'_RE`N-`dE!k?

Ja, ich habe Builtins für diese Herausforderung hinzugefügt, aber diese sind nicht speziell auf dieses Problem ausgerichtet.

Das funktioniert mit Version 0.1 des Interpreters .

Beispiellauf

> python IPOS.py S'_RE`N-`dE! k? -i "pa55 w0rd"
Pa_WrD550

Erläuterung

     # Implizit: Platziere die Eingabe auf dem Stapel (C)
S # Drücke ein Leerzeichen auf den Stapel (B)
'_ # Drücke einen Unterstrich auf den Stapel (A)
R # In C B durch A ersetzen -> Unterstriche durch Leerzeichen ersetzen
     # der Stack enthält nur noch den ersetzten String (C)
E # Drücke eine leere Saite (B)
`# Starten Sie ein Befehlsliteral,
     # Der Stack dafür wird später mit einem einzelnen Zeichen (B) initialisiert
N # Lege die Ziffern 0-9 als Zeichenfolge auf den Stapel (A)
- # Entferne jedes Zeichen von B, das in A ist
`# Befehlsliteral beenden (A)
Teilen Sie C auf B, sortieren Sie die Teile mit der Taste A absteigend und fügen Sie B wieder hinzu.
     # Die Tastenfunktion A wandelt jedes Zeichen der Zeichenfolge in eine leere Zeichenfolge um, wenn es sich um eine Ziffer handelt.
     # Da das resultierende Zeichen keine Ziffer enthält, ist der Schlüsselwert die Länge.
     # Dies ordnet die Taste 0 Ziffern und die Taste 1 Nicht-Ziffern zu. Absteigend sortieren
     # order verschiebt die Ziffern nach rechts und lässt Nicht-Ziffern in der Reihenfolge, in der sie vorher waren.
E # Leere Zeichenfolge drücken
! k # Drücke den Befehl k (= Swapcase)
? # Wende ^ zufällig auf jedes Zeichen an
     # Implizit: Inhalt des Ausgabestapels

PHP, 368 Bytes

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$output AND $numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<strlen($str);$i++){
    in_array($str[$i],$numArray)?($numStr = $numStr.$str[$i]):((rand(10,100)%2==0)?$str[$i] = strtoupper($str[$i]) AND $output = $output.$str[$i]:$output = $output.$str[$i]);
}
echo $output = $output.$numStr;

Ungolfed Code:

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$len = strlen($str);
$output = "";
$numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<$len;$i++){
  if(in_array($str[$i],$numArray)){
    $numStr = $numStr.$str[$i];
  }else {
      if(rand(10,100)%2==0)
      {
        $str[$i] = strtoupper($str[$i]);
      }
      $output = $output.$str[$i];
  }
}
$output = $output.$numStr;
echo $output;

Python 2, 179 Bytes

from random import*
f=lambda s,a=[str.upper,str.lower],n='0123456789':''.join(map(lambda x:choice(a)(x),filter(lambda x:x not in n,s).replace(' ','_')))+filter(lambda x:x in n,s)

Hier gibt es wahrscheinlich viel Raum für Verbesserungen, die ich später ausarbeiten werde.

AWK, 128 Bytes

{srand();for(;++i<=split($0,a,"");){s=a[i];if(s!=s+0){o=s==" "?"_":rand()>0.5?tolower(s):toupper(s);A=A o}else{N=N s}}print A N}

Das srand()wird benötigt, um uns bei jeder Ausführung unterschiedliche Zufallszahlen zu geben.
Damit dies bei mehrzeiligen Eingängen richtig funktioniert, müssten wir so etwas wie A=N=""vor die forSchleife setzen.

Python 3.5 - 118 Bytes:

from random import*
lambda y:''.join(choice([q.upper(),q.lower()])for q in sorted(y.replace(' ','_'),key=str.isdigit))

Wie Sie sehen können, verwende ich im Grunde genommen die choiceFunktion des Zufallsmoduls , um für jeden Buchstaben in der sortierten Version des angegebenen Strings eine Zufallsfunktion (entweder .upper () oder .lower ()) auszuwählen, in der alle Ziffern zu gehen Ende. Außerdem wird jedes Leerzeichen in der sortierten Zeichenfolge durch einen Unterstrich ersetzt.

PHP, 164 158 Zeichen / Byte

Dies ist besser als die anderen PHP-Golf , weil:

• Es braucht Eingaben
• Es ist kürzer

Skript

<?$a=$b='';foreach(str_split(strtolower($argv[1]))as$c){if($c==' ')$c='_';if(preg_match("/[0-9]/",$c))$a.=$c;else$b.=(rand(0,1)?$c:strtoupper($c));}echo$b.$a;

Beispiel

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

> <> 73 Bytes

 i:"@")?v:" ")?v0) ?\rl?!;o01!.<
 v8<    8>00.! <o"_"/
8<>x<%*4/^o+*
 ^c<

Nichts verrücktes hier, es:

• druckt, _wenn es trifft 
• Nimmt den Mod 32 aus Buchstaben und fügt 8 * 8 oder 12 * 8 zufällig hinzu, bevor sie gedruckt werden
• Stapelt die Nummer und druckt sie aus, sobald das Ende der Eingabe erreicht ist

Sie können es hier ausprobieren !

Python 3, 151 Bytes

import random as r
x=input();s="";n=""
for c in x:
 if c.isdigit():n+=c
 else:s+=c.upper() if r.randint(0,1) else c.lower()
print(s.replace(" ","_")+n)