Generar un cifrado dado un número y una cadena

Tu tarea es simple. Dada una cadena sy un número 0 <= n <= 9como entradas, inserte un carácter ASCII imprimible pseudoaleatorio entre cada carácter de los ntiempos de la cadena . De tal manera que para cada personaje de shay ncaracteres aleatorios entre ellos. Los espacios deben ser recortados.

Entrada:

• sfrase de cadena para cifrar en el cifrado
• entero nen el rango de0 <= n <= 9

Ejemplo:

Entrada:

The treasure is here
2

Salida:

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

Este es el código de golf, por lo que gana el código más corto. ¡Buena suerte y diviertete!

C #, 141 131 bytes

Bastante similar a la respuesta Java de @ Geobit , excepto que actualmente es más larga :(

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

Cosas completas de lambda:

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

Pruébalo en línea!

Explicación

ð-           # 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, 132124 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 lujoso, solo un doble bucle como cabría esperar. Exterior para hacer un bucle de la cuerda, interior para rellenar los 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

Pruébalo aquí!

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

Los caracteres aleatorios finales están bien según OP.

Octava, 43 bytes

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

Esto toma una cadena sy un entero ncomo entrada. Una cadena en Octave es simplemente una matriz de caracteres. s>32es un mapa lógico 1para cualquier personaje no espacial. El código agrega una matriz con nfilas y el mismo número de columnas que s(s>32)tiene, que contiene números de coma flotante entre 33 y 126. Se redondea implícitamente a enteros y se convierte a caracteres ASCII cuando se concatena con la cadena s. (:)'endereza esto a una matriz horizontal de caracteres.

¡Pruébalo aquí!

Python 2, 123 122 118 114 98 Bytes

Hombre, desearía que randomno fuera tan caro (y que no tuviéramos que filtrar espacios). Ahora tenemos grandes ahorros al permitirnos tener caracteres de cifrado al final :) De todos modos, aquí tienes:

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

Pure ES6 es dos bytes más largo:

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

Aquí hay un enfoque realmente genial que lamentablemente es 26 bytes más largo:

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

R, 97 bytes

Función sin nombre que toma entradas x(cadena) y 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="")

Pruébalo en R-Fiddle

CJam , 21 18 bytes

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

Pruébalo en línea!

Imprime ncaracteres finales aleatorios.

Explicación

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 , sin estructuras de flujo de control, sin sub-idiomas, sin "eval"

Golfed

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

Prueba

>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

Variables en uso:

s:"The treasure is here"
n:2

Esto usa el adverbio anterior , que aplica la función a la izquierda entre cada elemento a la derecha y su predecesor. (Esencialmente, aplica la función a la izquierda entre cada carácter a la derecha).

Genere n números aleatorios entre 40 y 126 y luego conviértalos a un carácter de caracteres: (q parece tener solo caracteres para estos)

`char$40+n?87

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

Salida de ejemplo:

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

EDITAR:
ahorró 3 bytes al convertir el rastro de q en (, /) usando la notación k y cambió de manera similar antes de `: Gracias a @slackwear por la actualización, afeitó 2 bytes :)

Java 8, 114 bytes

Golfed

(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 acepta un entero y una cadena. Inspirado por la respuesta de Java 7, doble bucle usando alguna sintaxis de Java 8 Stream ( String.chars) para guardar algunos bytes.

Entrada

3, "Hello world!"

Salida

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 demasiado elegante, además del uso de mkString en una cadena. Trata la cadena como una lista de caracteres y me permite insertar un separador entre ellos. Mi separador es el número apropiado de caracteres alfanuméricos generados aleatoriamente.

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

Pruébalo en línea!

No es súper aleatorio, pero es aleatorio. Simplemente coloque la cadena y el entero en la pila (Ejemplo: "¡Hola, mundo!", 5).

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

Explicación completa

Esta es una versión un poco más antigua del código, hasta que actualizo la explicación. Es casi lo mismo, solo que quizás sea un poco más fácil de leer:

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

Fingiremos que el parámetro de cadena es sy el parámetro entero es i.

< v}:{r&" "

El <le dice al pez que se mueva inmediatamente hacia la izquierda, lo que se envuelve " ", lo que agrega un espacio caracterizado a la pila. Luego, el pez viaja &, lo que agrega el espacio al registro. rinvierte la pila y la {:}desplaza hacia la izquierda (colocando iel extremo de la pila), copia el valor al final de la pila y luego la desplaza hacia la derecha. vle dice al pez que comience a moverse hacia abajo.

+1xv
+2<v
   }

xle dice al pez que se mueva en una dirección aleatoria, lo que finalmente hace que el pez vaya a la derecha y continúe hacia abajo, o pase por encima 1+o de 2+antemano. Estos suman 1 o 2 respectivamente al número al final de la pila. Si el pez viaja hacia arriba, golpea de vnuevo y viaja hacia abajo. }desplaza la pila a la derecha, luego tiene la iposición 1 en la pila y esta nueva variable en la posición 0 (la llamaremos m).

:&:<~ v!?=&

Esta sección es una función, llamémosla whitespaceTrimmer . Comienza donde el< está el. Simplemente elimina los espacios que están en el extremo de la pila (por lo tanto, el comienzo de la cadena) hasta que se encuentra con un carácter que no es espacio.

Entonces, inmediatamente el pez nada hacia a <y debe viajar hacia la izquierda. Luego se topa con:&:& y copia el valor en el extremo de la pila, coloca el espacio desde el registro al final de la pila, lo copia y luego lo vuelve a colocar en el registro.

Luego, el pez golpea =?!v ~, o más específicamente, =que saca los dos últimos valores (los dos que acabamos de crear) de la pila, los compara, coloca un 1 en el extremo de la pila si son iguales y un 0 en Al final de la pila si son diferentes. La ?hace estallar el nuevo valor fuera de la final de la pila, si es 0 no se ejecuta la siguiente instrucción, que en este caso es !, en su lugar se ejecuta v, que las órdenes de los peces a moverse hacia abajo (salida de la función).

Sin embargo, si es 1, entonces ha encontrado un espacio, por lo que ejecuta el !que es un trampolín, y eso hace que el pez omita la siguiente instrucción, que es a v, por lo que el pez continúa. Frente al pez, ve ~qué le dice que saque el último valor de la pila (confirmado como un espacio), luego el pez continúa y ejecuta la función nuevamente.

?!;a6.>ol2-

Inmediatamente se le dice al pez que nade a la derecha por a >, luego muestra el último carácter en la pila o(que, la primera vez que se ejecuta, es el primer carácter de s). Obtiene la longitud de la pila l, coloca un 2al final de la pila y luego -hace que se reste 2 l. Golpea lo ?!;que, al recordar lo que ?hace, hace que el pez se salte !si la pila está vacía y aterriza ;, lo que finaliza el programa.

A continuación, si todavía hay caracteres en la pila, ejecutamos lo !que hace que el pez rebote sobre ;y ejecute a6., que almacena a(AKA 10), y 6al final de la pila, que son x, ycoordenadas para ., que los saca del final de la pila. apilar, luego teletransporta al pez 10, 6y ejecuta la instrucción a la derecha de esa posición (ya que el pez nada a la derecha).

Esto es menos complicado de lo que parece cuando te das cuenta de que la yposición 6 es la línea debajo de esta. xla posición 10 es entonces v, y a la derecha de eso es , que es un no-op. Esto hace que el pez continúe nadando bien y realmente comience la ejecución al comienzo de la línea ...

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

Entonces esta es la función que agrega el texto aleatorio entre los caracteres. Es un poco bocado, pero eso es solo porque intenté hacerlo un poco más al azar. Llamemos a esto genRandomChars .

En :{{:}l1-[rvrealidad, es la configuración de la función, y menos parte de la función en sí. El pez nada primero, lo :{{que copia el valor al final de la pila, luego lo desplaza hacia la izquierda dos veces. Si recuerdas que iestaba en la posición 1 de la pila, sabrías que iahora está al final de la pila.

Luego, el pez nada sobre :}las copias iy desplaza la pila hacia la derecha, colocando iambas al principio y al final de la pila. l1-[hace que el pez coloque la longitud en el extremo de la pila, reste 1 de ella, luego [cree una nueva pila, moviendo los l-1valores (longitud de la pila menos 1) a la nueva pila (por lo tanto, simplemente abandonando ila pila anterior). Luego, el pez simplemente golpea, lo rvque invierte la pila nuevamente (creo que crear una nueva pila la invierte por alguna razón), y ordena que el pez nade hacia abajo una vez más, comenzando verdaderamente la función en el< inferior.

Entonces, actualmente el final de la pila tiene my nuestro temporal i, que llamaremos ti. Inmediatamente el pez nada 1-}, lo que resta 1 tiy lo mueve al comienzo de la pila. Luego, :}que simplemente lo copia my lo mueve al comienzo de la pila (poniendoti en la posición 1 de la pila).

Esto es cuando golpeamos esta pequeña cosa:

v2<
<1x|!
^3<

Esto es realmente muy simple. Esto !hace que el pez salte |y se ejecute x. Recordando lo que xhace, recordamos que esto hace que los peces se muevan en 4 direcciones. |es simplemente un espejo y hace que el pez nade de regreso ax . Básicamente, el pez colocará 1, 2 o 3 en el extremo de la pila, y continuará moviéndose hacia la izquierda, envolviendo.

Luego, el pez se ejecuta, lo *+oque hace que los dos últimos valores de la pila se eliminen, se multipliquen juntos, y el resultado se vuelva a presionar, luego lo mismo con la suma, luego el valor final se extrae de la pila y se genera o. Nuestra pila es ahora relativamente normal de nuevo que contiene solo [ m, ti,s ].

:}}:hace que el valor en el extremo de la pila (básicamente la sposición 0) no se copie, luego la pila se desplaza hacia la derecha dos veces (colocándose tien el frente nuevamente), luego tise copia. ?!vdebería ser bastante fácil de entender por ahora. Básicamente, si ties 0, salimos de la función con v, de lo contrario, ejecutamos !y omitimosv (haciendo otro ciclo).

Si ties 0 y hemos terminado de generar caracteres ligeramente aleatorios, ejecutamos vy vemos:

   v ~}}r]~<
.43<

Nada muy lujoso aquí. Eliminamos tide la pila a través de ~. ¡Entonces ]es nuevo, saca todos nuestros valores de la pila y los coloca en la pila anterior! Debido al problema de reversión invertimos con r, a continuación, cambiar la pila de la derecha dos veces con }}~, shufting la pila a la derecha, que nos da [ m, i, s], el ~es eliminar el extra duplicado s[0]desde principios de la función a medida que lo necesitaría si estábamos haciendo un bucle (pero no estamos, estamos saliendo). vle dice al pez que nade hacia abajo y hacia adentro >34.(invertido para mostrar el orden de ejecución), que le dice al pez que simplemente nade hacia la izquierda y hacia adentro 3, 4(¡porque .es un salto!). 3, 4en realidad está justo a la derecha del principiowhitespaceTrimmer, lo cual es perfecto porque estamos viajando a la izquierda.

Siguiendo toda esta lógica, podemos seguir al pez hasta que la pila esté finalmente vacía y el programa salga justo después de whitespaceTrimmerejecutarse.

Perl 5, 81 bytes

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

Espero que lo siguiente te ayude a entender lo que hace el one-liner:

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

Asigna mapas sobre el mensaje, inserta caracteres aleatorios y luego concatena el resultado.

Las instrucciones sugieren que todos los espacios se deben quitar de la cadena de resultados. Si solo se supone que se eliminan los espacios del mensaje original, puedo cambiar eso.

Sin golf:

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

Probablemente mucho más de lo necesario, pero este es el mío hasta ahora.

PHP, 96 bytes

Toma String como argumento 1 y Number como argumento 2

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

Pruébalo en línea

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

Nodo.js, 88 bytes

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

Salidas de ejemplo:

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

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

Pruébalo en línea!

C, 102 100 bytes

-2 bytes para omitir continue.

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

Sin golf:

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