Générer un chiffre à partir d'un nombre et d'une chaîne

Votre tâche est simple. Étant donné une chaîne set un nombre 0 <= n <= 9en entrée, insérez un caractère ASCII imprimable pseudo-aléatoire entre chaque caractère de la chaîne n. Tels que pour chaque personnage sil y a ndes caractères aléatoires entre eux. Les espaces doivent être rognés.

Contribution:

• sphrase de chaîne à chiffrer dans le chiffrement
• entier ndans la plage de0 <= n <= 9

Exemple:

Contribution:

The treasure is here
2

Production:

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

C'est du code-golf donc le code le plus court gagne! Bonne chance et amusez-vous bien!

C #, 141 131 octets

Assez similaire à la réponse Java de @ Geobit , sauf plus longtemps actuellement :(

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

Trucs lambda complets:

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 octets

ð-vy²FžQ.RJ

Essayez-le en ligne!

Explication

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

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

Rien d'extraordinaire, juste une double boucle comme vous vous en doutez. Extérieur pour boucler la chaîne, intérieur pour remplir les aléas:

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 octets

d-FQV~KHs

Essayez-le ici!

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

La fin des caractères aléatoires est correcte selon OP.

Octave, 43 octets

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

Cela prend une chaîne set un entier nen entrée. Une chaîne dans Octave est simplement un tableau de caractères. s>32est une carte logique avec 1pour tous les caractères non spatiaux. Le code ajoute une matrice avec des nlignes et le même nombre de colonnes s(s>32), contenant des nombres à virgule flottante entre 33 et 126. Il est implicitement arrondi en nombres entiers et converti en caractères ASCII lorsqu'il est concaténé avec la chaîne s. (:)'redresse cela à un tableau horizontal de caractères.

Testez-le ici!

Python 2, 123 122 118 118 114 98 octets

Mec, je souhaite que ce randomne soit pas si cher (et que nous n'ayons pas eu à filtrer les espaces). Maintenant, nous avons de grandes économies d'être autorisés à avoir des caractères de chiffrement à la fin :) Quoi qu'il en soit, voici:

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 octets

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

Pure ES6 est plus long de deux octets:

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

Voici une approche vraiment cool qui est malheureusement de 26 octets de plus:

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

R, 97 octets

Fonction sans nom prenant les entrées x(chaîne) et 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="")

Essayez-le sur R-fiddle

CJam , 21 18 octets

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

Essayez-le en ligne!

Imprime ndes caractères de fin aléatoires.

Explication

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 octets

Pure bash + coreutils , pas de structures de flux de contrôle, pas de sous-langues, pas d '"eval"

Golfé

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

Tester

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

Q / KDB +, 39 36 34 octets

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 utilisées:

s:"The treasure is here"
n:2

Celui-ci utilise l' adverbe précédent , qui applique la fonction à sa gauche entre chaque élément à droite et son prédécesseur. (Essentiellement, applique la fonction à gauche entre chaque caractère à droite.)

Générez n nombres aléatoires compris entre 40 et 126, puis convertissez-les en un caractère équivalent: (q ne semble avoir que des caractères pour ceux-ci)

`char$40+n?87

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

Exemple de sortie:

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

EDIT:
économisé 3 octets en convertissant le raze de q en (, /) en utilisant la notation k et changé de manière similaire avant `: Merci à @slackwear pour la mise à jour, rasé 2 octets :)

Java 8, 114 octets

Golfé

(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 qui accepte un entier et une chaîne. Inspiré par la réponse Java 7, double boucle en utilisant une syntaxe Java 8 Stream ( String.chars) pour économiser quelques octets.

Contribution

3, "Hello world!"

Production

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

Scala, 95 94 octets

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

Rien d'extraordinaire, à part l'utilisation de mkString sur une chaîne. Il traite la chaîne comme une liste de caractères et me permet d'insérer un séparateur entre eux. Mon séparateur est le nombre approprié de caractères alphanumériques générés aléatoirement.

> <> (Poisson), 107 106 103 octets

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

Essayez-le en ligne!

Ce n'est pas super aléatoire, mais c'est aléatoire. Placez simplement la chaîne et l'entier sur la pile (exemple: "Bonjour tout le monde!", 5).

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

Explication complète

Il s'agit d'une version légèrement plus ancienne du code, jusqu'à ce que je mette à jour l'explication. C'est à peu près la même chose, peut-être un peu plus facile à lire:

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

Nous prétendons que le paramètre de chaîne est set le paramètre entier est i.

< v}:{r&" "

Le <dit au poisson de se déplacer immédiatement vers la gauche, qui s'enroule vers " ", ce qui ajoute un espace à la pile. Ensuite, le poisson se déplace &, ce qui ajoute de l'espace au registre. rinverse la pile et {:}décale la pile vers la gauche (en mettant ila fin de la pile), copie la valeur à la fin de la pile, puis la décale vers la droite. vdit au poisson de commencer à descendre.

+1xv
+2<v
   }

xindique au poisson de se déplacer dans une direction aléatoire, entraînant finalement le poisson à droite et continue vers le bas, ou passe au-dessus 1+ou 2+avant. Ceux-ci ajoutent respectivement 1 ou 2 au nombre à la fin de la pile. Si le poisson vremonte , il frappe à nouveau et redescend. }décale la pile vers la droite, puis ayant ià la position 1 sur la pile et cette nouvelle variable à la position 0 (nous l'appellerons m).

:&:<~ v!?=&

Cette section est une fonction, appelons-la whitespaceTrimmer . Cela commence là où <est. Il supprime simplement les espaces qui se trouvent à la fin de la pile (donc au début de la chaîne) jusqu'à ce qu'il rencontre un caractère non-espace.

Donc, immédiatement, le poisson nage dans un < et doit se déplacer vers la gauche. Il s'exécute ensuite dans :&:&lequel copie la valeur à la fin de la pile, place l'espace du registre à la fin de la pile, le copie, puis le replace sur le registre.

Ensuite, le poisson frappe =?!v ~, ou plus précisément, =qui sort les deux dernières valeurs (les deux que nous venons de créer) de la pile, les compare, place un 1 à la fin de la pile si elles sont égales et un 0 sur la fin de la pile si elles sont différentes. Le fait ?apparaître la nouvelle valeur à la fin de la pile, s'il est égal à 0, il n'exécute pas l'instruction suivante, qui dans ce cas !, il exécute à la placev , ce qui ordonne au poisson de se déplacer vers le bas (en quittant la fonction).

Si c'est 1 cependant, alors il a trouvé un espace, donc il exécute le !qui est un trampoline, et cela fait que le poisson saute l'instruction suivante, qui est un v, donc le poisson continue. Devant le poisson, il voit ~qui lui dit de sortir la dernière valeur de la pile (confirmée comme étant un espace), puis le poisson continue et exécute à nouveau la fonction.

?!;a6.>ol2-

Le poisson est immédiatement averti de nager à droite de a >, puis de sortir le dernier caractère de la pile o(qui, la première fois qu'il est exécuté, est le premier caractère de s). Il obtient la longueur de la pile l, place un 2à la fin de la pile, puis -en soustrait 2 l. Il frappe ?!;ce qui, se souvenant de ce qui ?fait, fait sauter le poisson !si la pile est vide et atterrir ;, ce qui met fin au programme.

Après s'il y a encore des caractères sur la pile, nous exécutons !ce qui fait rebondir le poisson sur ;et exécute a6., qui stocke a(AKA 10), et 6à la fin de la pile, qui sont les x, ycoordonnées de ., ce qui les fait disparaître à la fin de la empiler, puis téléporter le poisson 10, 6et exécuter l'instruction à droite de cette position (car le poisson nage à droite).

C'est moins compliqué qu'il n'y paraît lorsque vous réalisez que la yposition 6 est la ligne en dessous de celle-ci. xla position 10 est alors v, et à droite de celle-ci , qui est un no-op. Cela amène le poisson à continuer de nager à droite et à commencer l'exécution en fait au début de la ligne ...

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

C'est donc la fonction qui ajoute le texte aléatoire entre les caractères. C'est un peu bouchée, mais c'est juste parce que j'ai essayé de le rendre un peu plus aléatoire. Appelons cela genRandomChars .

Le :{{:}l1-[rvest en fait la configuration de la fonction, et moins une partie de la fonction elle-même. Le poisson nage d'abord sur :{{lequel copie la valeur à la fin de la pile, puis la déplace deux fois vers la gauche. Si vous vous souvenez que ic'était à la position 1 sur la pile, alors vous sauriezi c'est maintenant à la fin de la pile.

Le poisson nage ensuite sur les :}copies iet déplace la pile vers la droite, en la plaçant iau début et à la fin de la pile. l1-[demande au poisson de placer la longueur à la fin de la pile, soustrayez-en 1, puis [créez une nouvelle pile, en déplaçant l-1(longueur de la pile moins 1) les valeurs vers la nouvelle pile (donc en laissant simplement isur l'ancienne pile). Ensuite, le poisson frappe simplement, rvce qui inverse à nouveau la pile (je pense que la création d'une nouvelle pile l'inverse pour une raison quelconque) et ordonne au poisson de nager à nouveau vers le bas, en commençant vraiment la fonction <ci - dessous.

Donc, actuellement, la fin de la pile a met notre temporaire i, que nous appellerons ti. Immédiatement, le poisson nage 1-}, ce qui soustrait 1 tiet le déplace au début de la pile. Ensuite, :}qui copie simplement met le déplace au début de la pile (en mettantti à la position de pile 1).

C'est là que nous avons touché cette petite chose:

v2<
<1x|!
^3<

C'est vraiment simple. Le !fait sauter |et exécuter le poisson x. En se souvenant de ce qui se xpasse, nous nous souvenons que cela fait bouger le poisson dans 4 directions. |est simplement un miroir, et fait revenir le poissonx . Donc, fondamentalement, le poisson placera 1, 2 ou 3 à la fin de la pile et continuera à se déplacer vers la gauche, en s'enroulant.

Le poisson s'exécute ensuite, *+oce qui provoque le saut des deux dernières valeurs de la pile, leur multiplication et le retour du résultat, puis la même chose avec addition, puis la valeur finale est sautée de la pile et sortie avec o. Notre pile est maintenant contenant encore relativement normale juste [ m, ti, s].

:}}:entraîne la scopie de la valeur à la fin de la pile (essentiellement la position 0), puis la pile est déplacée deux fois vers la droite (en la replaçant tisur le devant), puis tiest copiée. ?!vdevrait être assez facile à comprendre maintenant. Fondamentalement, si tiest 0, nous quittons la fonction avec v, sinon nous exécutons !et sautonsv (en faisant une autre boucle).

Si tiest 0 et que nous avons fini de produire des caractères légèrement aléatoires, alors nous exécutons vet voyons:

   v ~}}r]~<
.43<

Rien d'extraordinaire ici. Nous retirons tide la pile via ~. Puis ]c'est nouveau, il sort toutes nos valeurs de la pile et les place sur l'ancienne pile! En raison de la question de l' inversion on inverse avec r, puis déplacer la pile à droite deux fois avec }}~, shufting la pile à droite, nous donnant [ m, i, s], l' ~est de supprimer le supplément en double s[0]plus tôt dans la fonction que nous aurions besoin si nous faisions une boucle (mais nous ne le sommes pas, nous sortons). vdit au poisson de nager vers le bas et vers l' >34.intérieur (inversé pour montrer l'ordre d'exécution), ce qui dit au poisson de simplement nager vers la gauche et vers l'intérieur 3, 4(parce que le. c'est un saut!). 3, 4est en fait juste à droite du débutwhitespaceTrimmer, ce qui est parfait car nous partons à gauche.

En suivant toute cette logique, nous pouvons suivre le poisson jusqu'à ce que la pile soit finalement vide et que le programme se termine juste après whitespaceTrimmerson exécution.

Perl 5, 81 octets

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

J'espère que ce qui suit vous aide à comprendre ce que fait le 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 118 122 117 octets

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

Mappe le message, insère des caractères aléatoires, puis concatène le résultat.

Les instructions suggèrent que tous les espaces doivent être supprimés de la chaîne de résultat. Si seuls les espaces du message d'origine sont censés être supprimés, je peux changer cela.

Non 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 octets

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

Probablement bien plus longtemps que nécessaire, mais c'est le mien joué jusqu'à présent.

PHP, 96 octets

Prend String comme argument 1 et Number comme argument 2

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

Essayez-le en ligne

Python 3, 133 octets

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 octets

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

Exemples de sorties:

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

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

Essayez-le en ligne!

C, 102 100 octets

-2 octets pour sauter continue.

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

Non golfé:

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

Usage:

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