Tạo một mật mã cho một số và chuỗi

Nhiệm vụ của bạn rất đơn giản. Cho một chuỗi svà một số 0 <= n <= 9làm đầu vào, chèn một ký tự ASCII có thể in giả ngẫu nhiên giữa mỗi ký tự của chuỗin thời gian . Như vậy đối với mỗi nhân vật scó những nnhân vật ngẫu nhiên giữa chúng. Không gian cần được cắt tỉa.

Đầu vào:

• chuỗi scụm từ để mã hóa trong mật mã
• số nguyên ntrong phạm vi0 <= n <= 9

Thí dụ:

Đầu vào:

The treasure is here
2

Đầu ra:

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

Đây là môn đánh gôn, vì vậy đoạn mã ngắn nhất sẽ thắng! Chúc may mắn và vui vẻ!

C #, 141 131 byte

Khá giống với câu trả lời Java của @ Geobit , ngoại trừ hiện tại lâu hơn :(

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

Công cụ lambda đầy đủ:

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 byte

ð-vy²FžQ.RJ

Hãy thử trực tuyến!

Giải trình

ð-           # 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 byte

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

Không có gì lạ mắt, chỉ là một vòng lặp kép như bạn mong đợi. Bên ngoài để lặp chuỗi, bên trong để điền vào randoms:

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 byte

d-FQV~KHs

Hãy thử nó ở đây!

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

Trailing nhân vật ngẫu nhiên là tốt theo OP.

Octave, 43 byte

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

Điều này có một chuỗi svà một số nguyên nlàm đầu vào. Một chuỗi trong Octave chỉ đơn giản là một mảng các ký tự. s>32là một bản đồ hợp lý với 1bất kỳ nhà từ thiện không gian nào. Mã này nối thêm một ma trận với ncác hàng và cùng số cột như s(s>32)có, chứa các số dấu phẩy động giữa 33 và 126. Nó được làm tròn hoàn toàn thành các số nguyên và được chuyển đổi thành các ký tự ASCII khi được nối với chuỗi s. (:)'làm thẳng điều này thành một mảng các ký tự nằm ngang.

Kiểm tra nó ở đây!

Python 2, 123 122 118 114 98 byte

Man, tôi ước randomkhông quá đắt (và chúng tôi không phải lọc không gian). Bây giờ chúng tôi có khoản tiết kiệm lớn từ việc được phép có các ký tự mật mã ở cuối :) Dù sao đi nữa, đây là:

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 dài hơn hai byte:

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

Đây là một cách tiếp cận thực sự tuyệt vời dài hơn 26 byte:

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])

R, 97 byte

Hàm không tên lấy đầu vào x(chuỗi) và 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="")

Hãy thử nó trên R-fiddle

CJam , 21 18 byte

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

Hãy thử trực tuyến!

In ncác ký tự ngẫu nhiên.

Giải trình

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 byte

Bash + coreutils thuần túy , không có cấu trúc dòng điều khiển, không có ngôn ngữ phụ, không "eval"

Chơi gôn

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

Kiểm tra

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

Q / KDB +, 39 36 34 byte

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

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

Các biến được sử dụng:

s:"The treasure is here"
n:2

Điều này sử dụng trạng từ trước , áp dụng chức năng cho nó bên trái giữa mỗi mục bên phải và tiền thân của nó. (Về cơ bản, áp dụng chức năng ở bên trái giữa mỗi ký tự bên phải.)

Tạo n số ngẫu nhiên trong khoảng từ 40 đến 126 sau đó chuyển đổi chúng thành một ký tự tương đương: (q dường như chỉ có các ký tự cho các số này)

`char$40+n?87

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

Ví dụ đầu ra:

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

EDIT:
Đã lưu 3 byte bằng cách chuyển đổi ra của q thành (, /) bằng cách sử dụng ký hiệu k và thay đổi tương tự trước `: Nhờ @slackwear cho bản cập nhật, đã cạo 2 byte :)

Java 8, 114 byte

Chơi gôn

(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 chấp nhận một số nguyên và một chuỗi. Lấy cảm hứng từ câu trả lời Java 7, vòng lặp kép sử dụng một số cú pháp Luồng Java 8 ( String.chars) để lưu một vài byte.

Đầu vào

3, "Hello world!"

Đầu ra

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

Scala, 95 94 byte

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

Không có gì quá hấp dẫn, ngoài việc sử dụng mkString trên Chuỗi. Nó coi chuỗi là một danh sách các ký tự và cho phép tôi chèn một dấu phân cách giữa chúng. Dấu phân cách của tôi là số lượng ký tự chữ và số được tạo ngẫu nhiên thích hợp.

> <> (Cá), 107 106 103 byte

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

Hãy thử trực tuyến!

Nó không phải là siêu ngẫu nhiên, nhưng nó là ngẫu nhiên. Chỉ cần đặt chuỗi và số nguyên trên ngăn xếp (Ví dụ: "Hello world!", 5).

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

Giải thích đầy đủ

Đây là một phiên bản cũ hơn của mã, cho đến khi tôi cập nhật lời giải thích. Nó hầu như giống nhau, chỉ có thể dễ đọc hơn một chút:

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

Chúng ta sẽ giả vờ tham số chuỗi là svà tham số nguyên là i.

< v}:{r&" "

Nó <nói với con cá ngay lập tức di chuyển sang trái, nó quấn quanh " ", làm tăng thêm một không gian được xếp vào ngăn xếp. Sau đó, cá đi qua &, mà thêm không gian để đăng ký.rđảo ngược ngăn xếp và {:}dịch chuyển ngăn xếp sang trái (đặt ivào cuối ngăn xếp), sao chép giá trị ở cuối ngăn xếp, sau đó chuyển nó sang bên phải. vnói với cá để bắt đầu di chuyển xuống dưới.

+1xv
+2<v
   }

x bảo cá di chuyển theo một hướng ngẫu nhiên, cuối cùng dẫn đến việc cá đi đúng hướng và tiếp tục đi xuống, hoặc vượt qua 1+ hoặc 2+trước đó. Chúng thêm 1 hoặc 2 tương ứng vào số ở cuối ngăn xếp. Nếu con cá di chuyển lên trên, nó vlại đánh và đi xuống. }dịch chuyển ngăn xếp sang phải, sau đó có ivị trí 1 trên ngăn xếp và biến mới này ở vị trí 0 (chúng ta sẽ gọi nó m).

:&:<~ v!?=&

Phần này là một hàm, hãy gọi nó là whitespaceTrimmer . Nó bắt đầu ở đâu< có. Nó chỉ đơn giản là loại bỏ các khoảng trắng ở cuối ngăn xếp (vì vậy là phần đầu của chuỗi) cho đến khi nó chạy vào một ký tự không phải khoảng trắng.

Vì vậy, ngay lập tức cá bơi vào một <và phải đi sang bên trái. Sau đó nó chạy vào:&:& đó sao chép giá trị ở cuối ngăn xếp, đặt khoảng trống từ thanh ghi vào cuối ngăn xếp, sao chép nó, sau đó đặt nó trở lại vào thanh ghi.

Sau đó, cá đánh =?!v ~, hoặc cụ thể hơn,= bật ra hai giá trị cuối cùng (hai giá trị chúng ta vừa tạo) ra khỏi ngăn xếp, so sánh chúng, đặt 1 vào cuối ngăn xếp nếu chúng bằng nhau và 0 trên cuối của ngăn xếp nếu chúng khác nhau. Các? bật giá trị mới ra khỏi cuối của ngăn xếp, nếu nó là 0 nó không thực hiện lệnh kế tiếp, mà trong trường hợp này là !, nó thay vì thực thiv , mà đơn đặt hàng cá để di chuyển xuống dưới (thoát khỏi chức năng).

Tuy nhiên, nếu là 1, thì nó đã tìm thấy một khoảng trắng, vì vậy nó thực thi cái !đó là tấm bạt lò xo và khiến con cá bỏ qua hướng dẫn tiếp theo, đó là mộtv con cá, vì vậy con cá tiếp tục. Trước mặt cá, nó thấy~ nó bảo nó bật giá trị cuối cùng ra khỏi ngăn xếp (được xác nhận là khoảng trắng), sau đó con cá tiếp tục và chạy lại chức năng.

?!;a6.>ol2-

Con cá ngay lập tức được yêu cầu bơi ngay bởi a >, sau đó xuất ký tự cuối cùng trên ngăn xếp o(mà, lần đầu tiên nó chạy, là ký tự đầu tiên của s). Nó lấy chiều dài của ngăn xếp từ l, đặt a 2vào cuối ngăn xếp, sau đó -làm cho 2 bị trừ đi l. Nó đánh vào ?!;đó, ghi nhớ những gì ?làm, khiến cá bỏ qua !nếu ngăn xếp trống và hạ cánh trên; , kết thúc chương trình.

Theo sau nếu vẫn còn các ký tự trên ngăn xếp, chúng tôi thực thi !khiến cá bật lên ;và thực hiện a6., lưu trữ a(AKA 10) và 6ở cuối ngăn xếp, là x, ytọa độ cho ., chúng bật ra khỏi cuối của ngăn xếp xếp chồng lên nhau, sau đó dịch chuyển cá đến10, 6 , và thực hiện các hướng dẫn ở bên phải của postion đó (như cá đang bơi bên phải).

Điều này ít phức tạp hơn âm thanh khi bạn nhận ra yvị trí 6 là dòng bên dưới vị trí này. xvị trí 10 là sau đó v, và bên phải là vị trí không có. Điều này khiến cá tiếp tục bơi đúng và thực sự bắt đầu hành quyết ở đầu dòng ...

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

Vì vậy, đây là chức năng thêm văn bản ngẫu nhiên ở giữa các ký tự. Đó là một chút của một miệng, nhưng đó chỉ là vì tôi đã cố gắng làm cho nó thêm một chút ngẫu nhiên. Hãy gọi nó là genRandomChars .

Đây :{{:}l1-[rvthực sự là thiết lập cho chức năng, và một phần ít hơn của chính chức năng thực tế. Đầu tiên con cá bơi qua :{{đó sao chép giá trị ở cuối ngăn xếp, sau đó dịch chuyển nó sang bên trái hai lần. Nếu bạn nhớ lại rằngi là ở tư thế 1 trên stack, thì bạn sẽ biếti giờ đã ở cuối ngăn xếp.

Sau đó, cá bơi qua các :}bản sao ivà dịch chuyển chồng sang phải, đặt icả ở đầu và cuối của ngăn xếp. l1-[có con cá đặt chiều dài ở cuối ngăn xếp, trừ đi 1 từ nó, sau đó [tạo một l-1giá trị ngăn xếp mới, di chuyển (chiều dài ngăn xếp trừ 1) sang ngăn xếp mới (vì vậy chỉ cần để lại itrên ngăn xếp cũ). Sau đó, con cá chỉ đơn giản là đánh vào rvđảo ngược ngăn xếp một lần nữa (tôi nghĩ rằng việc tạo ra một ngăn xếp mới đảo ngược nó vì lý do nào đó) và ra lệnh cho cá bơi xuống một lần nữa, thực sự bắt đầu chức năng tại< bên dưới.

Vì vậy, hiện tại cuối của ngăn xếp có mvà tạm thời của chúng tôi i, chúng tôi sẽ gọi ti. Ngay lập tức con cá bơi qua 1-}, trừ đi 1 tivà di chuyển nó đến đầu ngăn xếp. Sau đó :}, chỉ cần sao chép mvà di chuyển nó đến đầu ngăn xếp (đặt tiở vị trí ngăn xếp 1).

Đây là khi chúng ta đạt được điều nhỏ nhặt này:

v2<
<1x|!
^3<

Điều này thực sự đã chết đơn giản. Các !nguyên nhân khiến cá bỏ qua |và thực hiện x. Ghi nhớ những gì xkhông, chúng tôi nhớ điều này làm cho cá di chuyển theo bất kỳ 4 hướng. |chỉ đơn giản là một tấm gương và khiến cá bơi trở lại x. Vì vậy, về cơ bản, cá sẽ đặt 1, 2 hoặc 3 vào cuối ngăn xếp và tiếp tục di chuyển sang trái, quấn quanh.

Sau đó, con cá thực hiện *+okhiến hai giá trị cuối cùng trên ngăn xếp được bật ra, nhân lên với nhau và kết quả được đẩy trở lại, sau đó cùng một điều với phép cộng, sau đó giá trị cuối cùng được bật ra khỏi ngăn xếp và xuất ra o. Chồng chúng tôi bây giờ là tương đối bình thường trở lại chỉ chứa [ m, ti,s ].

:}}:làm cho giá trị ở cuối ngăn xếp (về cơ bản là svị trí 0) bị sao chép, sau đó ngăn xếp được dịch sang phải hai lần (đặt tiở mặt trước một lần nữa), sau đó tiđược sao chép. ?!vnên bây giờ khá dễ hiểu Về cơ bản nếu tilà 0 thì chúng ta thoát khỏi hàm với v, nếu không chúng ta thực thi !và bỏ quav (thực hiện một vòng lặp khác).

Nếu tilà 0 và chúng ta đã hoàn thành xuất ra các ký tự hơi ngẫu nhiên, sau đó chúng ta thực thi vvà xem:

   v ~}}r]~<
.43<

Không có gì quá lạ mắt ở đây. Chúng tôi loại bỏ tikhỏi ngăn xếp thông qua ~. Sau đó ]là mới, nó bật tất cả các giá trị của chúng tôi ra khỏi ngăn xếp và đặt chúng vào ngăn xếp cũ! Bởi vì vấn đề đảo ngược chúng ta đảo ngược với r, sau đó chuyển stack phải hai lần với }}~, shufting chồng sang bên phải, đem lại cho chúng ta [ m, i, s], các ~là để loại bỏ các thêm nhân đôi s[0]từ trước đó trong hàm như chúng ta sẽ cần nó nếu chúng tôi đã thực hiện một vòng lặp (nhưng chúng tôi không, chúng tôi đang thoát). vbảo con cá bơi xuống và đi vào >34.(đảo ngược để hiển thị thứ tự thực hiện), nó bảo con cá chỉ đơn giản là bơi sang trái và vào 3, 4(bởi vì. là một cú nhảy!). 3, 4thực ra chỉ ở bên phải của sự khởi đầuwhitespaceTrimmer, đó là hoàn hảo bởi vì chúng tôi đang đi trái.

Theo tất cả logic này, chúng ta có thể theo dõi cá cho đến khi ngăn xếp cuối cùng trống rỗng và chương trình thoát ngay sau khi whitespaceTrimmerđược thực thi.

Perl 5, 81 byte

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

Tôi hy vọng những điều sau đây sẽ giúp bạn hiểu những gì một-liner làm:

($_, $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 byte

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

Bản đồ qua tin nhắn, chèn các ký tự ngẫu nhiên vào, sau đó ghép kết quả.

Các hướng dẫn gợi ý rằng tất cả các khoảng trắng nên được loại bỏ khỏi chuỗi kết quả. Nếu chỉ có khoảng trắng từ tin nhắn ban đầu được cho là bị tước, tôi có thể thay đổi điều đó.

Ung dung:

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

Python 3, 127 byte

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

Có lẽ cách lâu hơn cần thiết, nhưng đây là của tôi chơi golf cho đến nay.

PHP, 96 byte

Lấy Chuỗi làm đối số 1 và Số làm đối số 2

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

Dùng thử trực tuyến

Python 3, 133 byte

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 byte

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

Kết quả ví dụ:

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

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

Hãy thử trực tuyến!

C, 102 100 byte

-2 byte để bỏ qua continue.

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

Ung dung:

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

Sử dụng:

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