Gere uma cifra com um número e uma string

Sua tarefa é simples. Dada uma sequência se um número 0 <= n <= 9como entradas, insira um caractere ASCII imprimível pseudo-aleatório entre cada caractere dos ntempos da sequência . De modo que, para cada personagem, shaja ncaracteres aleatórios entre eles. Os espaços devem ser aparados.

Entrada:

• sfrase de cadeia para criptografar na cifra
• inteiro nna faixa de0 <= n <= 9

Exemplo:

Entrada:

The treasure is here
2

Resultado:

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

Isso é código-golfe, então o código mais curto vence! Boa sorte e divirta-se!

C #, 141 131 bytes

Muito parecido com a resposta Java da @ Geobit , mas atualmente há mais tempo :(

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

Material lambda completo:

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

Experimente online!

Explicação

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

Nada extravagante, apenas um loop duplo como você esperaria. Externo para fazer um loop na cadeia, interno para preencher 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 bytes

d-FQV~KHs

Experimente aqui!

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

Trailing caracteres aleatórios é bom de acordo com OP.

Oitava, 43 bytes

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

Isso leva uma string se um número inteiro ncomo entrada. Uma string no Octave é simplesmente uma matriz de caracteres. s>32é um mapa lógico 1para quaisquer caracteres não espaciais. O código anexa uma matriz com nlinhas e o mesmo número de colunas que s(s>32)possui, contendo números de ponto flutuante entre 33 e 126. É implicitamente arredondado para números inteiros e convertido em caracteres ASCII quando concatenado com a string s. (:)'endireita isso para uma matriz horizontal de caracteres.

Teste aqui!

Python 2, 123 122 118 114 98 Bytes

Cara, eu gostaria que randomnão fosse tão caro (e que não precisássemos filtrar por espaços). Agora temos uma grande economia de podermos ter caracteres cifrados no final :) De qualquer forma, aqui está:

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 bytes

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

O ES6 puro tem dois bytes a mais:

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

Aqui está uma abordagem muito interessante que, infelizmente, é 26 bytes mais longa:

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

R, 97 bytes

Função sem nome, recebendo entradas x(string) e 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="")

Experimente no R-fiddle

CJam , 21 18 bytes

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

Experimente online!

Imprime ncaracteres finais aleatórios.

Explicação

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 , sem estruturas de controle de fluxo, sem sub-idiomas, sem "eval"

Golfe

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

Teste

>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

Variáveis ​​em uso:

s:"The treasure is here"
n:2

Isso usa o anterior advérbio , que aplica a função à esquerda entre cada item à direita e seu antecessor. (Essencialmente, aplica função à esquerda entre cada caractere à direita.)

Gere n números aleatórios entre 40 e 126 e depois converta-os em um caractere equivalente: (q parece ter apenas caracteres para estes)

`char$40+n?87

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

Exemplo de saída:

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

EDIT:
salvou 3 bytes convertendo o q's raze em (, /) usando a notação k e alterou similarmente antes de `: Graças a @slackwear pela atualização, raspou 2 bytes :)

Java 8, 114 bytes

Golfe

(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 que aceita um inteiro e uma string. Inspirado na resposta do Java 7, faça um loop duplo usando alguma sintaxe do Java 8 Stream (String.chars ) para economizar alguns bytes.

Entrada

3, "Hello world!"

Resultado

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)

Nada demais, além do uso de mkString em uma String. Ele trata a string como uma lista de caracteres e me permite inserir um separador entre eles. Meu separador é o número apropriado de caracteres alfanuméricos gerados aleatoriamente.

> <> (Peixe), 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<

Experimente online!

Não é super aleatório, mas é aleatório. Apenas coloque a string e o número inteiro na pilha (exemplo: "Olá, mundo!", 5).

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

Explicação completa

Esta é uma versão um pouco mais antiga do código, até que eu atualize a explicação. É basicamente o mesmo, apenas um pouco mais fácil de ler:

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

Vamos fingir que o parâmetro string é se o parâmetro inteiro é i.

< v}:{r&" "

O <comando diz ao peixe para mover-se imediatamente para a esquerda, o que envolve " ", o que adiciona um espaço na pilha. Em seguida, o peixe viaja &, o que adiciona espaço ao registro. rinverte a pilha e {:}desloca a pilha para a esquerda (colocando ino final da pilha), copia o valor no final da pilha e depois a desloca para a direita. vdiz ao peixe para começar a se mover para baixo.

+1xv
+2<v
   }

xdiz ao peixe para se mover em uma direção aleatória, resultando no peixe indo para a direita e continuando para baixo, ou passando por cima 1+ou 2+antes. Eles adicionam 1 ou 2, respectivamente, ao número no final da pilha. Se o peixe viaja para cima, bate vnovamente e volta para baixo. }desloca a pilha para a direita, tendo ina posição 1 na pilha e essa nova variável na posição 0 (a chamaremos m).

:&:<~ v!?=&

Esta seção é uma função, vamos chamá-la whitespaceTrimmer . Começa onde o< está. Ele simplesmente remove os espaços que estão no final da pilha (portanto, o início da string) até que ele seja executado em um caractere não espacial.

Então, imediatamente, o peixe nada <e deve viajar para a esquerda. Em seguida, ele é executado:&:& qual copia o valor no final da pilha, coloca o espaço do registrador no final da pilha, copia-o e o coloca novamente no registrador.

Então o peixe acerta =?!v ~, ou mais especificamente, =que retira os dois últimos valores (os dois que acabamos de criar) da pilha, os compara, coloca um 1 no final da pilha, se eles são iguais, e um 0 em o fim da pilha, se forem diferentes. A ?aparece o novo valor para fora da extremidade da pilha, se for 0 não executar a instrução seguinte, que neste caso é !, em vez disso é executado v, o que as ordens do peixe para se deslocar para baixo (de sair a função).

Se for 1, no entanto, ele encontrou um espaço, para executar o !que é um trampolim e fazer com que o peixe pule a próxima instrução, que é a v, para que o peixe continue. Na frente do peixe, ele vê o ~que diz para retirar o último valor da pilha (confirmado como um espaço), depois o peixe continua e executa a função novamente.

?!;a6.>ol2-

O peixe é instruído imediatamente a nadar para a direita com a e >, em seguida, gera o último caractere na pilha com o(o qual, a primeira vez que isso é executado, é o primeiro caractere s). Ele obtém o comprimento da pilha l, coloca um 2no final da pilha e -faz com que 2 sejam subtraídos l. Acerta o ?!;que, lembrando o que ?faz, faz com que o peixe pule !a pilha se estiver vazia e apareça ;, o que encerra o programa.

A seguir, se ainda houver caracteres na pilha, executamos o !que faz com que o peixe salte sobre ;e execute a6., que armazena a(AKA 10) e, 6no final da pilha, quais são as x, ycoordenadas ., o que os expõe no final do empilhar e depois teleporta o peixe para10, 6 e execute a instrução à direita dessa posição (como o peixe está nadando direito).

Isso é menos complicado do que parece quando você percebe que a yposição 6 é a linha abaixo desta. xposição 10 é então v, e à direita disso é , que é um no-op. Isso faz com que o peixe continue nadando direito e realmente comece a execução no início da linha ...

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

Portanto, esta é a função que adiciona o texto aleatório entre os caracteres. É meio bocado, mas é só porque eu tentei torná-lo um pouco mais aleatório. Vamos chamar isso de genRandomChars .

Na :{{:}l1-[rvverdade, é a configuração da função e menos parte da própria função. O peixe nada primeiro sobre o :{{qual copia o valor no final da pilha e depois o desloca para a esquerda duas vezes. Se você se lembrar que iestava na posição 1 da pilha, você saberiai agora está no fim da pilha.

O peixe então nada sobre :}quais cópias ie desloca a pilha para a direita, colocando iambas no início e no final da pilha. l1-[faz com que o peixe coloque o comprimento no final da pilha, subtraia 1 e [crie uma nova pilha, movendo l-1(comprimento da pilha menos 1) os valores para a nova pilha (deixando apenas ia pilha antiga). Então o peixe simplesmente bate, o rvque inverte a pilha novamente (acho que a criação de uma nova pilha a inverte por algum motivo) e ordena que o peixe nade para baixo mais uma vez, começando verdadeiramente a função no< abaixo.

Então, atualmente, o fim da pilha tem me nosso temporário i, que chamaremos ti. Imediatamente o peixe nada 1-}, o que subtrai 1 tie o move para o início da pilha. Então, :}simplesmente copia me move-o para o início da pilha (colocando tina posição 1 da pilha).

É quando atingimos esta coisinha:

v2<
<1x|!
^3<

Isso é realmente simples demais. Isso !faz com que o peixe pule |e execute x. Lembrando o que xfaz, lembramos que isso faz o peixe se mover em qualquer 4 direções. |é simplesmente um espelho e faz com que o peixe volte a nadar x. Então, basicamente, o peixe colocará 1, 2 ou 3 no final da pilha e continuará se movendo para a esquerda, contornando.

O peixe então é executado, o *+oque faz com que os dois últimos valores na pilha sejam disparados, multiplicados juntos, e o resultado é pressionado novamente, em seguida, a mesma coisa com a adição e, em seguida, o valor final é disparado da pilha e gerado com ele o. Nossa pilha é agora relativamente normal novamente contendo apenas [ m, ti, s].

:}}:faz com que o valor no final da pilha (basicamente na sposição 0) não seja copiado, a pilha é deslocada para a direita duas vezes (colocando tina frente novamente) e depois tié copiada. ?!vdeve ser bem fácil de entender agora. Basicamente, se tifor 0, sairemos da função com v, caso contrário, executamos !e pulamos v(fazendo outro loop).

Se tifor 0 e terminamos de produzir caracteres ligeiramente aleatórios, executamos ve vemos:

   v ~}}r]~<
.43<

Nada muito chique aqui. Nós removemos tida pilha via ~. Então ]é novo, ele retira todos os nossos valores da pilha e os coloca na pilha antiga! Por causa da questão reversão nós revertemos com r, em seguida, mudar a pilha direita duas vezes com }}~, shufting a pilha para a direita, dando-nos [ m, i, s], o ~é para remover o adicional duplicado s[0]a partir no início da função que precisaríamos-lo se estávamos fazendo um loop (mas não estamos, estamos saindo). vdiz ao peixe para nadar para baixo e para dentro >34.(invertido para mostrar a ordem de execução), que diz ao peixe para nadar simplesmente para a esquerda e para dentro 3, 4(porque o. é um salto!). 3, 4é realmente apenas à direita do começowhitespaceTrimmer, o que é perfeito porque estamos viajando para a esquerda.

Seguindo toda essa lógica, podemos seguir o peixe até que a pilha esteja vazia e o programa saia logo após a whitespaceTrimmerexecução.

Perl 5, 81 bytes

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

Espero que o seguinte ajude você a entender o que o one-liner faz:

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

Mapeia a mensagem, insere caracteres aleatórios e concatena o resultado.

As instruções sugerem que todos os espaços devem ser removidos da sequência de resultados. Se apenas espaços da mensagem original devem ser removidos, eu posso mudar isso.

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

Provavelmente muito mais tempo do que o necessário, mas este é o meu golfe até agora.

PHP, 96 bytes

Toma String como argumento 1 e Number como argumento 2

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

Experimente online

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

Exemplo de saídas:

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

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

Experimente online!

C, 102 100 bytes

-2 bytes para pular 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++);
}

Uso:

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