Erstellen Sie eine Chiffre

15

Erzeugen Sie eine Chiffre mit einer Zahl und einer Zeichenkette

Ihre Aufgabe ist einfach. Fügen Sie bei einer Zeichenfolge sund einer Zahl 0 <= n <= 9als Eingaben ein pseudozufälliges druckbares ASCII-Zeichen zwischen die Zeichen der Zeichenfolgenzeiten nein. So dass die für jedes Zeichen sgibt es nzufällige Zeichen zwischen ihnen. Leerzeichen sollten gekürzt werden.

Eingang:

  • Zeichenfolge s, die in der Chiffre verschlüsselt werden soll
  • Ganzzahl nim Bereich von0 <= n <= 9

Beispiel:

Eingang:

The treasure is here
2

Ausgabe:

T ! 0 h 32 e F4 t 0i r lk e hm a 7y s # 0 u * & r * h e ! 2 i H ^ s B, h ! @ E 0) r $ h e


Das ist also gewinnt der kürzeste Code! Viel Glück und hab Spaß!

jacksonecac
quelle
3
zufällig druckbares ASCII-Zeichen Hier müssen Sie definieren, was zufällig bedeutet. Sollen alle druckbaren ASCII-Zeichen die gleiche Wahrscheinlichkeit haben? Sollten sie statistisch unabhängig sein? Welche Flexibilität haben wir diesbezüglich?
Luis Mendo
3
@jacksonecac Ich bin anderer Meinung. Nur zufällig zu sagen ist nicht genug. Wenn ich zum Beispiel nur zufällige Zeichen mit geraden ASCII-Codes auswähle, ist dies zwar immer noch zufällig, wird aber wahrscheinlich nicht akzeptiert (oder?). Wenn jede nZeichenfolge aus nKopien desselben zufälligen Zeichens besteht, sind sie dennoch zufällig nicht statistisch unabhängig. Und so weiter
Luis Mendo
5
@jacksonecac "random" ist ein sehr weiter Begriff. Kann ich die Zeichen mit einer Normalverteilung auswählen, so dass Zeichen Oeher als Leerzeichen vorkommen oder ~? Wenn es einheitlich sein muss, sollten Sie dies ausdrücklich sagen. Und wenn es nicht einheitlich sein muss, sollten Sie zumindest so etwas wie die Wahrscheinlichkeit angeben, dass jedes Zeichen eine von Null verschiedene Wahrscheinlichkeit haben muss. Sie haben auch in einem frühen Kommentar erklärt , dass jeder Charakter hat eine unabhängige Verteilung haben, also , wenn dies wichtig ist, sollte es in der Herausforderung zu nennen. Es gibt ein sehr breites Spektrum an Zufälligkeiten.
Martin Ender
3
Dies ist keine wirkliche Chiffre. Vielleicht ist es steganografisch.
Greg Martin
2
Dies ist keine angemessene Antwort auf den gültigen Punkt von @MartinEnder. Eine Lösung wäre, explizit anzugeben, dass die Zeichen einheitlich und statistisch unabhängig voneinander sein müssen und die Kommentare aufhören. Eine alternative Spezifikation (die jedoch offener für Missbrauch ist) wäre, dass verzerrte Verteilungen oder solche, bei denen Zeichen voneinander abhängig sind, in Ordnung sind, solange alle Zeichen eine von Null verschiedene Wahrscheinlichkeit des Auftretens aufweisen. Im Code ist die Golfspezifikation wichtig für die Fairness. Da Sie nicht gewillt zu sein scheinen, diese gültigen Kommentare zu einer ansonsten guten Herausforderung zu äußern, stimme ich für den Abschluss.
Level River St

Antworten:

7

C #, 141 131 Bytes

Ziemlich ähnlich wie die Java-Antwort von @ Geobit , außer dass sie derzeit länger dauert :(

(I,n)=>{var R=new System.Random();var o="";int i,r;foreach(var c in I)if(c>32)for(i=r=0,o+=c;i++<n;){r=R.Next(33,127);o+=(char)r;}return o;};

Volles Lambda-Zeug:

Func<string, int, string> a = (I,n) =>
{
    var R=new System.Random();
    var o="";
    int i;
    foreach(var c in I)
        if(c>32)
            for(i=0,o+=c;i++<n;o+=(char)R.Next(33,127));
    return o;
};
Jodler
quelle
warum R=...kann man einfach direkt benutzen new System.Random().Next(...)ich denke
roman
2
@ RomanGräf msdn.microsoft.com/de-de/library/h343ddh9(v=vs.110).aspx Die Zufallsklasse von C # verwendet ohne Startwert die Systemuhr. Wenn Sie also schnell hintereinander aufrufen (z. B. innerhalb von loop there), die meisten Werte sind identisch, was in den meisten Fällen nicht funktioniert :( Glaub mir, ich versuche immer, und erinnere mich dann daran.
Yodle
7

05AB1E , 11 Bytes

ð-vy²FžQ.RJ

Probieren Sie es online!

Erläuterung

ð-           # remove spaces from input string
  v          # for each char in the string
   y         # push the char
    ²F       # input-2 number of times do:
      žQ.R   # push a random ascii character
          J  # join to string
Emigna
quelle
schließen! trimm die Räume! :)
jacksonecac
@ Jacksonecac: Verpasste diesen Teil Entschuldigung.
Behoben
gut gemacht! das funktioniert!
Jacksonecac
1
@carusocomputing: Damit werden auch nach dem letzten Buchstaben zufällige Zeichen eingefügt. Nicht nur zwischen den Buchstaben.
Emigna
1
@Emigna Nach einem kürzlichen Kommentar unter der Frage scheint das in Ordnung zu sein :)
geisterfurz007 Stoppt dieses Chaos
6

Java 7, 132 124 Bytes

String f(int n,char[]a){String o="";int i;for(char b:a)if(b>32)for(i=0,o+=b;i++<n;o+=(char)(33+Math.random()*94));return o;}

Nichts Besonderes, nur eine Doppelschleife, wie man es erwarten würde. Äußer, um die Zeichenfolge zu schleifen, inner, um Zufälligkeiten auszufüllen:

String f(int n,char[]a){
    String o="";
    int i;
    for(char b:a)
        if(b>32)
            for(i=0,
                o+=b;
                    i++<n;
                        o+=(char)(33+Math.random()*94));
    return o;
}
Geobits
quelle
Keine Notwendigkeit für k: String f(int n,char[]a){String o="";for(char b:a)if(b>32){o+=b;for(int i=0;i++<n;o+=(char)(33+Math.random()*94));}return o;}(125 Bytes)
Olivier Grégoire
Oooh richtig. Ich habe es mit einer anderen Methode benutzt. Ich habe nicht daran gedacht, es herauszunehmen, als ich mit der charBesetzung ging. Vielen Dank!
Geobits
Mein Fehler. Ich habe falsch gezählt, mein Vorschlag war auch 124 Bytes: Ich überprüfte die Spalte anstelle der Länge;)
Olivier Grégoire
Ja, mir ist aufgefallen, dass beim Vergleich der beiden :)
Geobits
5

Pyke, 12 11 9 Bytes

d-FQV~KHs

Probieren Sie es hier aus!

d-        -  remove spaces from input
  F       - for i in ^:
   QV     -  repeat (number) times:
     ~KH  -    random_from(printable)
        s -   sum(^)

Nachgestellte zufällige Zeichen sind laut OP in Ordnung.

Blau
quelle
5

Oktave, 43 Bytes

@(s,n)[s(s>32);33+94*rand(n,nnz(s>32))](:)'

Hierfür werden eine Zeichenfolge sund eine Ganzzahl nals Eingabe verwendet. Ein String in Octave ist einfach ein Array von Zeichen. s>32ist eine logische Karte 1für alle Nicht-Leerzeichen. Der Code hängt eine Matrix mit nZeilen und der gleichen Anzahl von Spalten an s(s>32), die Gleitkommazahlen zwischen 33 und 126 enthält. Sie wird implizit auf ganze Zahlen gerundet und in ASCII-Zeichen konvertiert, wenn sie mit der Zeichenfolge verknüpft wird s. (:)'Begradigt dies auf ein horizontales Array von Zeichen.

Teste es hier!

Stewie Griffin
quelle
1
Implizite Rundung! Nice
Luis Mendo
4

Python 2, 123 122 118 114 98 Bytes

Mann, ich wünschte, randomes wäre nicht so teuer (und wir müssten nicht nach Leerzeichen filtern). Jetzt haben wir große Ersparnisse, wenn wir am Ende Chiffrierzeichen haben dürfen :) Wie auch immer, hier geht's:

from random import*
f=lambda s,n:s and(' '<s[0])*eval('s[0]'+'+chr(randint(32,126))'*n)+f(s[1:],n)
Kade
quelle
4

JavaScript (Firefox 30+), 96 Byte

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32]))

Pure ES6 ist zwei Bytes länger:

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[...Array(n)].map(_=>Math.random()*95+32)))

Hier ist ein wirklich cooler Ansatz, der leider 26 Bytes länger ist:

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])
ETHproductions
quelle
Streng genommen /. *(?=.)/funktioniert das nicht für Zeichenfolgen, die in Leerzeichen beginnen oder enden, und es interessiert niemanden. (Sie dürfen jetzt sogar zufällige Zeichen nachziehen.)
Neil
@Neil Nachgestellte zufällige Zeichen sind erlaubt? Ich schätze, ich kann einfach das entfernen, das (?=.)die Leerzeichen am Ende der Zeichenfolgen entfernt.
ETHproductions
Die Spezifikation ist nicht so klar, aber ich denke, Sie sollten vermeiden, Leerzeichen einzufügen, also 94+33statt95+32
edc65
3

R 97 Bytes

Unbenannte Funktion, die Eingaben x(Zeichenfolge) und n.

function(x,n,l=nchar(x))for(i in 1:l)cat(substr(x,i,i),if(i<l)intToUtf8(sample(32:126,n)),sep="")

Probieren Sie es auf R-Geige

Billywob
quelle
3

CJam , 21 18 Bytes

lS-(ol~f{{95mrSc+\}*}

Probieren Sie es online!

Druckt nzufällige nachgestellte Zeichen.

Erläuterung

lS-        e# Read line and remove spaces.
l~         e# Read and evaluate another line.
f{         e# For each character (passing in N)...
  {        e#   Do this N times...
    95mr   e#     Push random integer in [0, 95).
    Sc+    e#     Add to space character, giving a random printable ASCII character.
  }*
}
           e# All characters remaining on the stack are printed implicitly
           e# at the end of the program.
Martin Ender
quelle
3

Bash, 124 Bytes

Pure bash + coreutils , keine Kontrollflussstrukturen, keine Untersprachen, kein "eval"

Golf gespielt

E() { N=${1// /};paste <(fold -1<<<$N) <(tr -cd "\\40-\\176"<\/dev\/urandom|head -c$(($2*${#N}-$2))|fold -$2)|tr -d '\t\n';}

Prüfung

>E "The treasure is here" 2
TkZhf(e&Rt@FrS,edha+-sJTuh.rX@eVKi+3s<7hftey8r*/e
Zeppelin
quelle
3

Q / KDB +, 39 36 34 Bytes

raze{""sv(raze x;`char$40+n?87)}prior s
(,/)({""sv((,/)x;`char$40+n?87)}':)s

(,/)({""sv((,/)x;10h$40+n?87)}':)s

Verwendete Variablen:

s:"The treasure is here"
n:2

Dabei wird das vorherige Adverb verwendet, das die Funktion links zwischen jedem Element rechts und dem Vorgänger anwendet. (Wendet die Funktion im Wesentlichen links zwischen den einzelnen Zeichen rechts an.)

Generieren Sie n Zufallszahlen zwischen 40 und 126 und konvertieren Sie sie dann in ein Zeichen, das gleichberechtigt ist: (q scheint nur Zeichen für diese zu haben)

`char$40+n?87

//Possible characters.
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Beispielausgabe:

TVghrveVp Rpti+r0sea3a9nsIjuRXrAReJ; +di=ys`{ ikhKTe4trTZesz

BEARBEITEN:
3 Bytes durch Konvertieren von qs raze in (, /) unter Verwendung der k-Notation gespeichert und in ähnlicher Weise vor `geändert: Danke an @slackwear für das Update, 2 Bytes rasiert :)

Adam J
quelle
1
kann durch Casting mit10h$
skeevey 22.11.16
2

Java 8, 114 Bytes

Golf gespielt

(n,s)->s.chars().forEach((c)->{if(c>32)for(int i=0;i<=n;)System.out.print((char)(++i==1?c:33+Math.random()*94));})

Lambda, das eine Ganzzahl und eine Zeichenfolge akzeptiert. Inspiriert von der Java 7-Antwort, doppelte Schleife mit etwas Java 8-Stream-Syntax ( String.chars), um ein paar Bytes zu sparen.

Eingang

3, "Hello world!"

Ausgabe

HfKIedb3l<-Ul%}vod"Bw\"|oa`%rH-}l/-{dMS;!B#X
Xanderhall
quelle
2

Scala, 95 94 Bytes

def c(s:String,i:Int)=s.filter(_>32).mkString(scala.util.Random.alphanumeric.take(i).mkString)

Nichts Besonderes außer der Verwendung von mkString on a String. Die Zeichenfolge wird als Liste von Zeichen behandelt, und ich kann ein Trennzeichen zwischen ihnen einfügen. Mein Trennzeichen ist die entsprechende Anzahl zufällig generierter alphanumerischer Zeichen.

Ethan
quelle
Nicht ganz beantwortet die Frage. Die Art der Random.alphanumericwird dazu führen, dass jeder Chunk gleich ist, so dass es eine lahme Chiffre ist ... Siehe dieses Beispiel:scala> c("Hello", 1) res0: String = Hbeblblbo
Jacob
Übrigens können Sie die entfernen filter. Beim Aufrufen mkStringeiner Zeichenfolge wird diese als Zeichensammlung behandelt.
Jacob
@Jacob der Filter ist die effizienteste Möglichkeit, Leerzeichen zu entfernen. Ich habe das Zufällige so belassen, wie es schien, aber wenn ich Zeit habe, werde ich eine separate Funktion für richtigen Zufallstext hinzufügen.
Ethan
2

> <> (Fisch), 107 106 103 Bytes

<v}:{r&" "
1xv+
2<v+
v}<
<~v!?=&:&:
6.>ol2-?!;a
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o-+
^3<v ~}}r]~<
.40<

Probieren Sie es online!

Es ist nicht super zufällig, aber es ist zufällig. Legen Sie einfach den String und die ganze Zahl auf den Stapel (Beispiel: "Hallo Welt!", 5).

Input: "Hello world!", 5
Output: H^\^]^eceeedldcdeclgfffhowhhfggojkkkkrdccedl]]\]\d

Vollständige Erklärung

Dies ist eine etwas ältere Version des Codes, bis ich die Erklärung aktualisiere. Es ist meistens dasselbe, nur vielleicht ein bisschen einfacher zu lesen:

< v}:{r&" "
+1xv
+2<v
   }
:&:<~ v!?=&
?!;a6.>ol2-
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Wir werden so tun, als wäre der String-Parameter sund der Integer-Parameter i.

< v}:{r&" "

Der <Befehl weist den Fisch an, sich sofort nach links zu bewegen, woraufhin " "der Stapel um ein Feld erweitert wird. Dann reist der Fisch vorbei &, was dem Register den Platz hinzufügt. rKehrt den Stapel um und {:}verschiebt den Stapel nach links (setzt idas Ende des Stapels auf), kopiert den Wert am Ende des Stapels und verschiebt ihn dann nach rechts. vsagt dem Fisch, er solle sich nach unten bewegen.

+1xv
+2<v
   }

xweist den Fisch an, sich in eine zufällige Richtung zu bewegen, was letztendlich dazu führt, dass der Fisch nach rechts und weiter nach unten geht oder über 1+oder vorüber geht 2+. Diese addieren jeweils 1 oder 2 zur Zahl am Ende des Stapels. Wenn der Fisch aufwärts reist, trifft er verneut und reist wieder abwärts. }verschiebt den Stapel nach rechts und hat dann die iPosition 1 auf dem Stapel und diese neue Variable die Position 0 (wir nennen es m).

:&:<~ v!?=&

Dieser Abschnitt ist eine Funktion, nennen wir sie WhitespaceTrimmer . Es beginnt dort, wo es <ist. Leerzeichen am Ende des Stapels (also am Anfang der Zeichenfolge) werden entfernt, bis ein Nicht-Leerzeichen angezeigt wird.

Also schwimmt der Fisch sofort in ein <und muss nach links fahren. Anschließend wird ausgeführt, in :&:&welche der Wert am Ende des Stapels kopiert wird, der Speicherplatz aus dem Register auf das Ende des Stapels platziert wird, kopiert und dann wieder auf das Register zurückgesetzt wird.

Dann trifft der Fisch =?!v ~, oder genauer gesagt, =der die letzten beiden Werte (die beiden, die wir gerade erstellt haben) aus dem Stapel entfernt, vergleicht sie, setzt eine 1 am Ende des Stapels, wenn sie gleich sind, und eine 0 an das Ende des Stapels, wenn sie unterschiedlich sind. Das ?löscht den neuen Wert vom Ende des Stapels. Wenn er 0 ist, führt es nicht den nächsten Befehl aus. In diesem Fall !führt es stattdessen den folgenden Befehl aus v, der den Fisch auffordert , sich nach unten zu bewegen (die Funktion zu verlassen).

Wenn es jedoch 1 ist, dann hat es ein Leerzeichen gefunden, so dass es das ausführt, !was ein Trampolin ist, und das den Fisch veranlasst, die nächste Anweisung zu überspringen, die a ist v, so dass der Fisch fortfährt. Vor dem Fisch sieht er, ~welcher ihn auffordert, den letzten Wert vom Stapel zu nehmen (bestätigt als Leerzeichen), dann fährt der Fisch fort und führt die Funktion erneut aus.

?!;a6.>ol2-

Der Fisch wird sofort angewiesen, direkt von a zu schwimmen >, und gibt dann das letzte Zeichen auf dem Stapel von aus o(das erste Mal, wenn dies ausgeführt wird, ist das erste Zeichen von s). Er erhält die Länge des Stapels von l, platziert a 2am Ende des Stapels und -bewirkt dann, dass 2 von subtrahiert wird l. Es trifft auf ?!;das, was ?den Fisch veranlasst, !den Stapel zu überspringen, wenn er leer ist, und landet auf dem Stapel ;, wodurch das Programm beendet wird.

Wenn sich noch Zeichen auf dem Stapel befinden, wird ausgeführt !, wodurch der Fisch über den AKA- Speicher springt ;und ausgeführt a6.wird , und am Ende des Stapels werden die Koordinaten für den aAKA- Speicher angezeigt , der sie vom Ende des AKA- Speichers abwirft stapeln, dann teleportieren Sie den Fisch zu und führen Sie die Anweisung rechts von dieser Position aus (da der Fisch richtig schwimmt).106x, y.10, 6

Dies ist weniger kompliziert als es sich anhört, wenn Sie erkennen, dass yPosition 6 die Linie unter dieser Position ist. xPosition 10 ist dann v, und rechts davon ist , was ein No-Op ist. Dies führt dazu, dass der Fisch richtig weiter schwimmt und die Ausführung tatsächlich am Anfang der Linie beginnt ...

:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Dies ist also die Funktion, die den zufälligen Text zwischen den Zeichen hinzufügt. Es ist ein bisschen mundvoll, aber das ist nur, weil ich versucht habe, es ein bisschen extra zufällig zu machen. Nennen wir das genRandomChars .

Das :{{:}l1-[rvist eigentlich das Setup für die Funktion, und weniger so einen Teil der eigentlichen Funktion selbst. Der Fisch schwimmt zuerst :{{, kopiert den Wert am Ende des Stapels und verschiebt ihn dann zweimal nach links. Wenn Sie sich erinnern, dass isich das auf Position 1 des Stapels befand, wissen Sie, dass ies sich jetzt am Ende des Stapels befindet.

Der Fisch schwimmt dann über :}die Kopien iund verschiebt den Stapel nach rechts, wobei er isowohl am Anfang als auch am Ende des Stapels platziert. l1-[Lässt der Fisch die Länge am Ende des [Stapels platzieren, zieht 1 davon ab und erstellt dann einen neuen Stapel, wobei die l-1Werte (Stapellänge minus 1) zum neuen Stapel verschoben werden (so dass nur ider alte Stapel übrig bleibt). Dann schlägt der Fisch einfach zu, rvwas den Stapel wieder umkehrt (ich denke, das Erzeugen eines neuen Stapels kehrt ihn aus irgendeinem Grund um), und befiehlt dem Fisch, noch einmal nach unten zu schwimmen, wobei die Funktion wirklich unten beginnt <.

Also hat derzeit das Ende des Stacks mund unsere temporäre i, die wir nennen werden ti. Sofort schwimmt der Fisch vorbei 1-}, der 1 abzieht tiund an den Anfang des Stapels verschiebt. Dann wird es :}einfach kopiert mund an den Anfang des Stapels verschoben ( tiPosition 1 des Stapels ).

Dies ist, wenn wir dieses kleine Ding treffen:

v2<
<1x|!
^3<

Das ist eigentlich ganz einfach. Das !bewirkt, dass der Fisch überspringt |und ausgeführt wird x. Wenn xwir uns erinnern, was passiert, bewegen sich die Fische in 4 Richtungen. |ist einfach ein Spiegel und bewirkt, dass der Fisch zurückschwimmt x. Im Grunde genommen wird der Fisch 1, 2 oder 3 auf das Ende des Stapels legen und sich weiter nach links bewegen und herumwickeln.

Der Fisch wird dann ausgeführt *+o, wodurch die letzten beiden Werte auf dem Stapel abgehoben, multipliziert und das Ergebnis zurückgeschoben werden. Dann wird das Gleiche mit Addition ausgeführt. Dann wird der Endwert vom Stapel genommen und mit ausgegeben o. Unser Stapel ist jetzt relativ normal wieder enthält nur [ m, ti, s].

:}}:bewirkt, dass der Wert am Ende des Stapels (im Grunde sPosition 0) nicht kopiert wird, dann wird der Stapel zweimal nach rechts verschoben ( tiwieder vorne platziert) und dann tikopiert. ?!vsollte mittlerweile ziemlich einfach zu verstehen sein. Im Grunde genommen verlassen tiwir die Funktion mit v, wenn sie 0 ist , andernfalls führen wir eine andere Schleife aus !und überspringen vsie.

Wenn ti0 ist und wir keine leicht zufälligen Zeichen mehr ausgeben, führen wir Folgendes aus vund sehen:

   v ~}}r]~<
.43<

Nichts Besonderes hier. Wir entfernen tivom Stapel über ~. Dann ]ist es neu, es wirft alle unsere Werte vom Stapel und legt sie auf den alten Stapel! Aufgrund der Umkehrung Problems , das wir mit umkehren r, dann den Stapel nach rechts verschieben zweimal mit }}~, shufting den Stapel nach rechts, was uns [ m, i, s], das ~ist die zusätzliche dupliziert entfernen s[0]von früher in der Funktion , wie wir es brauchen würden , wenn Wir machten eine Schleife (aber wir sind nicht, wir verlassen). vsagt den Fischen, dass sie hinunter und hinein schwimmen sollen >34.(invertiert, um die Ausführungsreihenfolge anzuzeigen), was den Fischen sagt, dass sie einfach nach links und hinein schwimmen sollen 3, 4(weil das .ein Sprung ist!). 3, 4ist eigentlich nur rechts vom anfangwhitespaceTrimmer, was perfekt ist, weil wir links unterwegs sind.

Nach all dieser Logik können wir den Fischen folgen, bis der Stapel endgültig leer ist und das Programm unmittelbar nach der whitespaceTrimmerAusführung beendet wird.

redstarcoder
quelle
Hmm, ich habe nicht gesehen, dass das Zeichen druckbar sein muss. Dies erfordert geringfügige Modifikationen, die es möglicherweise weniger zufällig und kleiner machen.
Redstarcoder
Es sieht nicht viel weniger zufällig aus. Ich glaube, es sollte in den meisten Fällen funktionieren, ich habe es noch nicht scheitern lassen. Es funktioniert sicher mit Groß- oder Kleinbuchstaben und einigen Symbolen. Ich bin mir ziemlich sicher, dass dies die Anforderungen der Herausforderung erfüllt.
Redstarcoder
2

Perl 5, 81 Bytes

($_,$n)=<>;chomp;y/ //d;$\=chop;print map{$_,map{chr 33+int rand 94}1..$n}split//

Ich hoffe, das Folgende hilft Ihnen zu verstehen, was der Einzeiler macht:

($_, $n) = <STDIN>;  # Reads in the string into $_,
                     # and the number into $n, from standard input.
                     # (<STDIN> works slightly different from <>.)
chomp($_);           # Removes the newline from the string.
$_ =~ tr/ //d;       # `Tr/`ansliterates ASCII space characters
                     # into nothing, effectively `/d`eleting them.
$\ = chop($_);       # Chop()s off the last character out of $_ and
                     # appends it to the output when print()ing.
                     # (Perl always prints $\ after you call print().)
print( map {         # Each element of [List 1] will be mapped to:
    $_,              #   -- Itself, and
                     # (When mapping, each element is available as $_.)
    map {            # (`map` resembles `foreach` but returns a list.)
        chr(         #   -- A random ASCII character, in the range
          33 + int(rand(94)) ) # from 33 (!, hex 21) to 126 (~, hex 7E)
    } 1..$n          # ...$n times! (Over the range 1 to $n, actually.)
} split(//, $_) );   # [List 1] is $_, split() into characters.
g4v3
quelle
1

Clojure, 126 123 118 122 117 Bytes

(defn c[m n](apply str(remove #(=\space %)(mapcat #(apply str %(for [_(range n)](char(rand-nth(range 32 127)))))m))))

Ordnet die Nachricht zu, fügt zufällige Zeichen ein und verkettet das Ergebnis.

Die Anweisungen schlagen vor, dass alle Leerzeichen aus der Ergebniszeichenfolge entfernt werden sollten. Wenn nur Leerzeichen aus der Originalnachricht entfernt werden sollen, kann ich das ändern.

Ungolfed:

(defn cipher [message n]
  (apply str
    (remove #(= \space %)
        (mapcat #(apply str %
                     (for [_ (range n)]
                       (char (rand-nth (range 32 127)))))
                message))))
Karzigenat
quelle
1

Python 3, 127 Bytes

import random
a,b=input(),input()
print(''.join([x+''.join([chr(random.randint(33,126))for c in range(int(b))]) for x in a]))

Wahrscheinlich viel länger als nötig, aber das ist meins, das bisher golfen hat.

Vedvart1
quelle
1
Das fügt zufällige Zeichen vor dem ersten Zeichen hinzu und Leerzeichen werden nicht abgeschnitten. Ich denke, beide Dinge verstoßen gegen die Regeln.
Stewie Griffin
1

PHP, 96 Bytes

Nimmt String als Argument 1 und Number als Argument 2

for(;($s=str_replace(' ','',$argv[1]))[$j]>'';)echo$i++%($argv[2]+1)?chr(rand(33,127)):$s[$j++];

Probieren Sie es online aus

Krypto
quelle
1

Python 3, 133 Bytes

from random import *
c=int(input())
print(''.join([i+''.join([chr(randint(33,126))for i in range(c)])for i in input().strip(' ')])[:-c])
sonrad10
quelle
1

Node.js, 88 Bytes

(s,n)=>s.replace(/./g,c=>c!=" "?c+crypto.randomBytes(n).toString`base64`.substr(0,n):"")

Beispielausgaben:

f("The treasure is here", 2)
// THphdwekAtMArbSeU1aDTsZWuqnr2yek1iyUsKshqXewvrVCeTi

f("The treasure is here", 2)
// TYshlcep6t4Iru7e29aQ1sl/uvQrlzeSJihysDhhOLe1urpte1m

Probieren Sie es online!

Florent
quelle
1

C 102 100 Bytes

-2 Bytes zum Überspringen continue.

i;f(char*s,int n){do{while(*s==32)++s;putchar(*s);i=n;while(i--)putchar(32+rand()%95);}while(*s++);}

Ungolfed:

i;
f(char*s,int n){
 do{
  while(*s==32)++s;
  putchar(*s);
  i=n;
  while(i--)
    putchar(32+rand()%95);
 }while(*s++);
}

Verwendung:

main(){
  char a[]="A   A A";
  f(a,3);
}
Karl Napf
quelle