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 Code-Golf, also gewinnt der kürzeste Code! Viel Glück und hab Spaß!

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

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

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

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.

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!

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)

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

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

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.

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

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

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

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.

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

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.

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

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.

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

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

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!

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