Genera un codice dato un numero e una stringa

Il tuo compito è semplice. Dato una stringa se un numero 0 <= n <= 9come input, inserire un carattere ASCII stampabile pseudo-casuale tra ciascun carattere dei ntempi della stringa . Tale che per ogni personaggio di sci sono npersonaggi casuali tra di loro. Gli spazi devono essere tagliati.

Ingresso:

• sfrase stringa da crittografare nel codice
• intero nnell'intervallo di0 <= n <= 9

Esempio:

Ingresso:

The treasure is here
2

Produzione:

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

Questo è code-golf quindi vince il codice più corto! Buona fortuna e buon divertimento!

C #, 141 131 byte

Abbastanza simile alla risposta Java di @ Geobit , tranne che per il momento più lungo :(

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

Roba lambda completa:

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

Provalo online!

Spiegazione

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

Niente di speciale, solo un doppio giro come ti aspetteresti. Esterno per avvolgere la stringa, interno per riempire i 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

Provalo qui!

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

Il trascinamento di caratteri casuali va bene secondo OP.

Ottava, 43 byte

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

Questo richiede una stringa se un numero intero ncome input. Una stringa in Octave è semplicemente una matrice di caratteri. s>32è una mappa logica con 1qualsiasi carattere non spaziale. Il codice aggiunge una matrice con nrighe e lo stesso numero di colonne che s(s>32)ha, contenente numeri in virgola mobile compresi tra 33 e 126. È implicitamente arrotondato a numeri interi e convertito in caratteri ASCII quando è concatenato con la stringa s. (:)'raddrizza questo in una matrice orizzontale di caratteri.

Provalo qui!

Python 2, 123 122 118 114 98 byte

Amico, vorrei che randomnon fosse così costoso (e che non abbiamo dovuto filtrare gli spazi). Ora abbiamo grandi risparmi dalla possibilità di avere caratteri di cifratura alla fine :) Comunque, ecco qui:

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 è più lungo di due byte:

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

Ecco un approccio davvero interessante che è purtroppo più lungo di 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

Funzione senza nome che accetta input x(stringa) 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="")

Provalo su R-violino

CJam , 21 18 byte

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

Provalo online!

stampe n caratteri finali casuali.

Spiegazione

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 puro + coreutils , nessuna struttura di flusso di controllo, nessuna sotto-lingua, nessun "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';}

Test

>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

Variabili in uso:

s:"The treasure is here"
n:2

Questo utilizza il precedente avverbio , che applica la funzione a sinistra tra ogni elemento a destra e il suo predecessore. (Essenzialmente, applica la funzione a sinistra tra ogni personaggio a destra.)

Genera n numeri casuali tra 40 e 126, quindi convertili in un carattere equivalente: (q sembra avere solo caratteri per questi)

`char$40+n?87

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

Esempio di output:

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

EDIT:
salvato 3 byte convertendo la raze di q in (, /) usando la notazione k e similmente modificato prima di `: Grazie a @slackwear per l'aggiornamento, ho rasato 2 byte :)

Java 8, 114 byte

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 che accetta un numero intero e una stringa. Ispirato dalla risposta Java 7, doppio loop che utilizza una sintassi Java 8 Stream (String.chars ) per salvare alcuni byte.

Ingresso

3, "Hello world!"

Produzione

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)

Niente di eccessivamente elaborato, a parte l'uso di mkString su una stringa. Tratta la stringa come un elenco di caratteri e mi consente di inserire un separatore tra di loro. Il mio separatore è il numero appropriato di caratteri alfanumerici generati casualmente.

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

Provalo online!

Non è super casuale, ma è casuale. Posiziona semplicemente la stringa e il numero intero sullo stack (Esempio: "Hello world!", 5).

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

Spiegazione completa

Questa è una versione leggermente più vecchia del codice, fino a quando non aggiorno la spiegazione. È per lo più lo stesso, forse solo un po 'più facile da leggere:

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

Faremo finta che il parametro string sia se il parametro integer sia i.

< v}:{r&" "

Questo <dice al pesce di spostarsi immediatamente a sinistra, che si avvolge intorno " ", il che aggiunge uno spazio disegnato alla pila. Quindi il pesce viaggia &, il che aggiunge lo spazio al registro. rinverte la pila e {:}sposta la pila a sinistra (posizionandola ialla fine della pila), copia il valore alla fine della pila, quindi lo sposta a destra. vdice al pesce di iniziare a muoversi verso il basso.

+1xv
+2<v
   }

xdice al pesce di muoversi in una direzione casuale, portando alla fine il pesce che va a destra e continua verso il basso, oppure passa sopra 1+o 2+prima. Questi aggiungono rispettivamente 1 o 2 al numero alla fine della pila. Se il pesce viaggia verso l'alto, colpisce di vnuovo e torna indietro. }sposta lo stack a destra, quindi avendo la iposizione 1 nello stack e questa nuova variabile nella posizione 0 (lo chiameremo m).

:&:<~ v!?=&

Questa sezione è una funzione, chiamiamola whitespaceTrimmer . Inizia dove si <trova. Elimina semplicemente gli spazi che si trovano alla fine della pila (quindi l'inizio della stringa) fino a quando non si imbatte in un carattere non spaziale.

Quindi immediatamente il pesce nuota in un <e deve viaggiare a sinistra. Quindi si imbatte:&:& cui copia il valore all'estremità della pila, posiziona lo spazio dal registro alla fine della pila, lo copia, quindi lo posiziona nuovamente nel registro.

Quindi il pesce colpisce =?!v ~, o più specificamente, =che estrae gli ultimi due valori (i due che abbiamo appena creato) dallo stack, li confronta, posiziona un 1 alla fine dello stack se sono uguali e uno 0 su la fine della pila se sono diverse. La ?schiocca il nuovo valore l'estremità della pila, se è 0 non esegue l'istruzione successiva, che in questo caso è !, invece esegue vche ordini il pesce a scendere (uscita dalla funzione).

Se è 1, tuttavia, ha trovato uno spazio, quindi esegue quello !che è un trampolino, e questo fa sì che il pesce salti l'istruzione successiva, che è a v, quindi il pesce continua. Di fronte al pesce, vede ~quale gli dice di estrarre l'ultimo valore dallo stack (confermato come spazio), quindi il pesce continua ed esegue nuovamente la funzione.

?!;a6.>ol2-

Al pesce viene immediatamente detto di nuotare a destra da un >, quindi emette l'ultimo personaggio in pila di o(che, la prima volta che viene eseguito, è il primo personaggio di s). Prende la lunghezza della pila l, posiziona 2a alla fine della pila, quindi -fa sottrarre 2 l. Colpisce il ?!;che, ricordando cosa ?fa, fa saltare il pesce !se la pila è vuota e atterra; , che termina il programma.

In seguito, se ci sono ancora caratteri nello stack, eseguiamo ciò !che fa rimbalzare il pesce sopra ;e lo esegue a6., che memorizza a(AKA 10), e 6alla fine dello stack, che sono x, ycoordinate per le .quali li espelle alla fine del impilare, quindi teletrasportare il pesce 10, 6ed eseguire le istruzioni a destra di quella posizione (mentre il pesce sta nuotando a destra).

Questo è meno complicato di quanto sembri quando ti rendi conto che la yposizione 6 è la linea sotto questa. xla posizione 10 è quindi v, e alla sua destra , che è una no-op. Questo fa sì che il pesce continui a nuotare bene e inizi effettivamente l'esecuzione all'inizio della linea ...

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

Quindi questa è la funzione che aggiunge il testo casuale tra i caratteri. È un po 'un boccone, ma è solo perché ho cercato di renderlo un po' più casuale. Chiamiamo questo genRandomChars .

In :{{:}l1-[rvrealtà è l'impostazione per la funzione, e meno parte della funzione stessa. Il pesce prima nuota sopra il :{{quale copia il valore all'estremità della pila, quindi lo sposta due volte a sinistra. Se ricordi che iera nella posizione 1 nella pila, allora sapresti che iè ora alla fine della pila.

Il pesce quindi nuota su :}quale copia ie sposta la pila a destra, posizionando isia all'inizio che alla fine della pila. l1-[fa posizionare il pesce alla fine della pila, sottrae 1 da essa, quindi [crea una nuova pila, spostando i l-1valori (lunghezza pila meno 1) sulla nuova pila (quindi lasciando isulla pila vecchia). Quindi il pesce colpisce semplicemente il rvche inverte di nuovo lo stack (penso che la creazione di un nuovo stack lo inverta per qualche motivo), e ordina al pesce di nuotare ancora una volta verso il basso, iniziando davvero la funzione dal <basso.

Quindi attualmente la fine dello stack ha me il nostro temporaneo i, che chiameremo ti. Immediatamente il pesce nuota 1-}, sottraendo 1 da tie lo sposta all'inizio della pila. Quindi, :}che semplicemente copia me lo sposta all'inizio della pila (mettendo tinella posizione 1 della pila).

Questo è quando colpiamo questa piccola cosa:

v2<
<1x|!
^3<

Questo è in realtà semplice morto. Ciò !fa saltare |ed eseguire il pesce x. Ricordando cosa xsuccede, ricordiamo che questo fa muovere il pesce in 4 direzioni. |è semplicemente uno specchio e fa ritornare il pesce x. Quindi, fondamentalmente, il pesce posizionerà 1, 2 o 3 sull'estremità dello stack e continuerà a spostarsi a sinistra, avvolgendosi.

Il pesce quindi esegue il *+oche fa schioccare, moltiplicare insieme gli ultimi due valori nello stack e il risultato si spinge indietro, quindi la stessa cosa con l'aggiunta, quindi il valore finale viene saltato fuori dallo stack e emesso con o. Il nostro stack è ora relativamente nuovo normale contenente solo [ m, ti,s ].

:}}:fa sì che il valore all'estremità della pila (sostanzialmente la sposizione 0) non venga copiato, quindi la pila viene spostata due volte a destra (posizionandola tinuovamente sulla parte anteriore), quindi tiviene copiata. ?!vdovrebbe essere abbastanza facile da capire ormai. Fondamentalmente se tiè 0 allora usciamo dalla funzione v, altrimenti eseguiamo !e saltiamov (facendo un altro ciclo).

Se tiè 0 e abbiamo finito di emettere caratteri leggermente casuali, quindi eseguiamo ve vediamo:

   v ~}}r]~<
.43<

Niente di speciale qui. Rimuoviamo tidallo stack tramite ~. Quindi ]è nuovo, estrae tutti i nostri valori dallo stack e li posiziona nello stack precedente! A causa del problema di inversione invertiamo con r, quindi spostare la pila destra due volte con }}~, shufting lo stack a destra, dandoci [ m, i, s], il ~è quello di rimuovere l'extra duplicato s[0]dalla prima in funzione di come avremmo bisogno se stavamo facendo un ciclo (ma non lo siamo, stiamo uscendo). vdice al pesce di nuotare verso il basso e dentro >34.(invertito per mostrare l'ordine di esecuzione), che dice al pesce di nuotare semplicemente a sinistra e dentro 3, 4(perché il. è un salto!). 3, 4è in realtà proprio alla destra dell'iniziowhitespaceTrimmer, che è perfetto perché stiamo viaggiando a sinistra.

Seguendo tutta questa logica possiamo seguire il pesce fino a quando lo stack non è alla fine vuoto e il programma esce subito dopo l' whitespaceTrimmeresecuzione.

Perl 5, 81 byte

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

Spero che quanto segue ti aiuti a capire cosa fa il 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 byte

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

Esegue il mapping sul messaggio, inserisce caratteri casuali e quindi concatena il risultato.

Le istruzioni suggeriscono che tutti gli spazi dovrebbero essere rimossi dalla stringa del risultato. Se solo gli spazi del messaggio originale devono essere rimossi, posso cambiarlo.

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

Probabilmente molto più a lungo del necessario, ma questo è il mio golf finora.

PHP, 96 byte

Prende String come argomento 1 e Number come argomento 2

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

Provalo online

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

Esempi di output:

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

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

Provalo online!

C, 102 100 byte

-2 byte per saltare 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);
}