Mettre en œuvre ce chiffre clé

Objectif

Utilisez l'algorithme (expliqué dans la section Algorithme) pour implémenter un certain chiffre.

Le programme doit lire les entrées de STDIN ou l'équivalent disponible le plus proche, utiliser l'algorithme pour générer le texte chiffré et une clé.

Le texte chiffré et la clé seront écrits dans STDOUT ou l'équivalent disponible le plus proche. N'importe quel format est autorisé, tant qu'il génère le texte chiffré et la clé.

Algorithme

Convertissez les caractères de la chaîne en valeurs ASCII respectives. Par exemple:

Hello -> 72 101 108 108 111

Ensuite, vous devrez générer une clé tant que la chaîne avec des nombres aléatoires compris entre 0 et 9.

Hello -> 62841

Ajoutez les entiers de la séquence de nombres aléatoires aux valeurs ASCII de la chaîne. Dans les exemples ci-dessus, 72 deviendrait 78 et 101 deviendrait 104.

72 + 6 = 78, 101 + 2 = 103, 108 + 8 = 116, etc

Ensuite, reconvertissez les nouvelles valeurs en caractères. Dans les exemples ci-dessus, le texte Helloest devenu Ngtpp.

Exemples

(Ce ne sont que des exemples de ce à quoi pourrait ressembler la sortie . La sortie peut varier et variera.)

Hello World

Lfrlu)_supg
41606984343

This will be encoded

Zhjs$~koo gj$iuhofgj
60104723305544750226

Règles

• Vous pouvez supposer que l'entrée ne contiendra que des caractères dans la plage az, AZ et les espaces.
• Les soumissions doivent être des programmes ou des fonctions complets.
• Les soumissions seront notées en octets.
• Les failles standard sont interdites.
• C'est le code-golf, donc le code le plus court l'emporte.

(C'est l'un de mes premiers défis, s'il y a quelque chose qui ne va pas, n'hésitez pas à me dire comment je pourrais l'améliorer.)

Gelée , 12 9 octets

⁵ṁX€’Ṅ+OỌ

Essayez-le en ligne!

Comment ça fonctionne

⁵ṁX€’Ṅ+OỌ  Main link. Argument: s (string)

⁵             Set the return value to 10.
 ṁ            Mold; create an array of 10's with the length of s.
  X€          Pseudo-randomly pick a integer between 1 and 10, for each 10.
    ’         Decrement, so the integers fall in the range [0, ..., 9].
     Ṅ        Print the key, as an array, followed by a linefeed.
      +O      Add the integers to the ordinals (code points) of s.
        Ọ     Unordinal; convert back to characters.

Python 3, 130 octets

Merci à @Rod d'avoir signalé un bug

from random import*
def f(x):l=10**len(x);k=str(randint(0,l-1)+l)[1:];print(''.join(chr(ord(i)+int(j))for i,j in zip(x,k))+'\n'+k)

Une fonction qui prend l'entrée via un argument sous forme de chaîne et imprime dans STDOUT.

Comment ça fonctionne

from random import*  Import everything from the random module
def f(x):            Function with input string x
l=10**len(x)         Define l for later use as 10^length(x)
randint(0,l-1)+l     Generate a random integer in the range [0, l-1] and add l, giving a
                     number with l+1 digits...
k=str(...)[1:]       ...convert to a string and remove the first character, giving a key of
                     length l that can include leading zeroes, and store in k
for i,j in zip(x,k)  For each character pair i,j in x and k:
chr(ord(i)+int(j))    Find the UTF-8 code-point (same as ASCII for the ASCII characters),
                      add the relevant key digit and convert back to character
''.join(...)         Concatenate the characters of the ciphertext
print(...+'\n'+k)    Add newline and key, then print to STDOUT

Essayez-le sur Ideone

Pyth - 16 octets

En attente d'une décision de l'OP sur les formats de sortie.

sCM+VCMQKmOTQjkK

Suite de tests .

En fait, 17 octets

;`X9J`M;(O¥♂cΣ@εj

Essayez-le en ligne!

Explication:

;`X9J`M;(O¥♂cΣ@εj
;                  dupe input
 `X9J`M            for each character in input copy:
  X9J                discard the character, push a random integer in [0, 9]
       ;           duplicate the offset array
        (O         bring input to top of stack, ordinal array
          ¥♂c      pairwise addition with offset array, turn each ordinal into a character
             Σ     concatenate
              @εj  concatenate the copy of the offset array

CJam - 14 octets

Quand j'ai vu le calcul du code ascii, je savais que je devais écrire une réponse CJam.

q_{;Amr}%_@.+p

Essayez-le en ligne ici .

MATL, 13 octets

"10r*]v!kGy+c

La sortie ressemble à ceci:

9 5 8 2 1
Qjtnp

Essayez-le en ligne!

Explication:

"    ]          % For each character:
 10             % Push a 10 onto the stack
   r            % Push a random float in [O, 1)
    *           % Multiply. This essentially the same thing as pushing a number in [0, 10)
      v!k       % Join all of these together, and take the floor
         G      % Push the input again
          y     % Duplicate the array of random numbers
           +    % And add these together. Since MATL treats strings as an array of chars, we don't need to explicitly convert types
            c   % Display as string

PowerShell v2 +, 79 77 octets

param($n)-join(($x=[char[]]$n|%{0..9|Random})|%{[char]($_+$n[$i++])});-join$x

Prend des entrées $n, boucle sur chaque caractère et obtient un Randomélément de 0..9chaque itération. Stocke ces nombres (sous forme de tableau) dans $x. Pipes ce tableau dans une autre boucle. Chaque itération, prend l'élément actuel $_, l'ajoute au caractère positionnel découpé en $n(transtypage implicite char-to-int), puis re-cast comme [char]. Laisse ça sur le pipeline. C'est encapsulé en parens et -joinédité ensemble pour former le mot. Cela reste sur le pipeline. De plus, le numéro $xest également -joinédité ensemble et laissé sur le pipeline. Ceux-ci sont implicitement imprimés avec un Write-Outputà la fin de l'exécution, ce qui entraîne leur impression par défaut avec une nouvelle ligne.

Exemple

PS C:\Tools\Scripts\golfing> .\implement-this-key-cipher.ps1 'Hello World!'
Lhoot(Yt{mf"
433358259121

C #, 252 247 245 232 216 octets

La taille est assez mauvaise par rapport aux autres solutions mais néanmoins ...

using System;using System.Linq;class p{static void Main(){var c="";var i=Console.ReadLine();var r=new Random();for(int b=0;b++<i.Count();){int d=r.Next(10);Console.Write((char)(i[b]+d));c+=d;}Console.Write("\n"+c);}}

Ceci est ma deuxième réponse à un codegolf et je suis un débutant en ce qui concerne le C #, donc j'apprécierais de savoir comment le raccourcir :)

Non golfé:

using System;
using System.Linq;

class p
{
    static void Main()
    {
        var c = "";
        var i = Console.ReadLine();
        var r = new Random();
        for (int b = 0; b++ < i.Count();)
        {
            int d = r.Next(10);
            Console.Write((char)(i[b] + d));
            c += d;
        }
        Console.Write("\n" + c);
    }
}

• 5 octets enregistrés grâce à @FryAmTheEggman
• 2 octets enregistrés grâce à @theLambGoat
• 7 octets enregistrés en supprimant staticde la classe p
• 24 octets enregistrés grâce à @milk

CJam, 11 octets

Nq{Amr_o+}/

Essayez-le en ligne!

Comment ça fonctionne

N            Push a linefeed on the stack.
 q           Read all input from STDIN and push it on the stack.
  {      }/  For each character in the input:
   Amr       Pseudo-randomly pick an integer in [0 ... 9].
      _o     Print a copy.
        +    Add the integer to the character.
             (implicit) Print the linefeed, followed by the modified characters.

05AB1E , 18 17 octets

vžh.RDyÇ+ç`?}J¶?,

Explication

v           }      # for each char in input
 žh.RD             # push 2 copies of a random number in [0..9]
      yÇ+          # add 1 copy to the current chars ascii value
         ç`?       # convert to char, flatten and print
             J     # join stack (which contain the digits of the key)
              ¶?,  # print a newline followed by the key

Essayez-le en ligne

Python 3, 112 octets

c est une fonction qui renvoie le texte crypté et la clé

from random import*
c=lambda t:map(''.join,zip(*[(chr(a+b),str(b))for a,b in((ord(i),randint(0,9))for i in t)]))

Voici un code qui fait la même chose et qui est un peu plus lisible

def encrypt(text):
    # keep the codes of the letters in the input and a random key
    # that will be used later to encrypt this letter
    letter_and_key = ((ord(letter),randint(0,9)) for letter in text)

    # encrypt the letter and keep the key used as a string
    output_and_key = [(chr(letter_code+key), str(key))
                      for letter_code, key in letter_and_key]

    # At this point the values are kept in the format:
    # [(firstletter, firstkey), (secondletter, secondkey), ...]

    # to reorder the list to be able to output in the format "text key"
    text, key = map(''.join, zip(*output_and_key))

    # same as print(*output_and_key)
    return text, key

Production:

>>> text, key = c('Hello World')
>>> print(text, key, sep='\n')
Liuot#`oylk
44935390707

PHP, 63 86 82 octets

Edit: oublié d'imprimer la clé ...

Merci à Alex Howansky de m'avoir sauvé 4 octets.

for(;$i<strlen($a=$argv[1]);$s.=$r)echo chr(ord($a[$i++])+$r=rand(0,9));echo"
$s";

L'entrée est donnée via un argument de ligne de commande. Prend chaque caractère de la chaîne et ajoute un entier aléatoire de 0 à 9 à son code ASCII, puis reconvertit le code en ASCII. Chaque nombre aléatoire est ajouté à $s, qui est imprimé à la fin.

J, 32 octets

<@:e,:~[:<[:u:3&u:+e=.[:?[:$&10#

équivalent python:

from random import randint
def encrypt(message):
    rand_list = list(map(lambda x: randint(0, 9), range(len(message))))
    return (''.join(list(map(lambda x,y: chr(x+y), rand_list, map(ord, message)))), rand_list)

Perl, 34 octets

Comprend +1 pour -p

#!/usr/bin/perl -p
s%.%$\.=$==rand 10;chr$=+ord$&%eg

Perl, 65 octets

for(split'',$ARGV[0]){$;.=$a=int rand 9;$b.=chr$a+ord}say"$b\n$;"

Cela m'a pris un certain temps pour comprendre comment obtenir l'entrée sans une nouvelle ligne à la fin. Le prend comme argument de ligne de commande

Python 2, 84 99 octets

def f(x):y=`id(x)**len(x)`[1:len(x)+1];return''.join(map(chr,[ord(a)+int(b)for a,b in zip(x,y)])),y

Utilise la id()valeur de la chaîne pour générer des nombres aléatoires.

Essayez-le

Senva , 74 octets

Voici le programme le plus court que j'ai réalisé:

2'(`>0.>{@}0'{v}2-2'0,{@}1'{v}0'{+}{'}9%+{^}{1-}1'"{+}{~}>$10.~0'2+"0,-:>$

Une petite explication? (Remarque: BM signifie Back-Memory ):

// === Input and informations storing ===

2'  // Go to the 3rd cell (the two first will be used to store informations)
(   // Ask the user for a string (it will be stored as a suite of ASCII codes)
`   // Go the end of the string
>   // Make a new cell
0.  // Put a 0 to mark the end of the string
>   // Make a new cell, here will be stored the first random number
{@} // Store its adress in BM
0'  // Go to the 1st cell
{v} // Paste the adress, now the 1st cell contains the adress of the first random number
2-  // Subtract 2 because the string starts at adress 2 (the 3rd cell)
2'  // Go to the 3rd cell (where the string begins)

// === String encryption and displaying ===

0,  // While the current cell doesn't contain 0 (while we didn't reach the string's end)
  {@}  // Store the character's adress into the memory
  1'   // Go to the 2nd cell
  {v}  // Paste the value, now the 1st cell contains the adress of the current char
  0'   // Go to the 1st cell
  {+}  // Add the adress of the first random number to the current char adress
  {'}  // Go to this adrses
  9%+  // A random number between 0 and 10
  {^}  // Store this number in BM
  {1-} // Decrease BM (random number between 0 and 9)
  1'   // Go to the 1st cell
  "    // Go to the adress pointed by the cell (the adress of the current char)
  {+}  // Add it to the random number value
  {~}  // Display it as an ASCII character
  >    // Go to the next cell (the next character)
$   // End of the loop
10. // Set the new line's ASCII code into the current cell (which is now useless, so it can be overwritten)
~   // Display the new line
0'  // Go to the first cell
2+  // Add 2 to the adress, because we are not in the string loop : we cancel the 2 substraction
"   // Go to the pointed adress (the first random number's one)

// === Display the random numbers ===

0,  // While we didn't reach the end of the random numbers suite
    // That was why I stored numbers between 1 and 10, the first equal to 0 will be the end of the suite
  - // Decrease it (number between 0 and 9)
  : // Display the current random number as an integer
  > // Go to the next cell (the next number)
$ // End of the loop

Cela semble plus gros maintenant, vrai: p? Il est peut-être possible d'optimiser ce code, mais pour le moment c'est le plus court que j'ai trouvé.

C #, 174 octets

using static System.Console;class b{static void Main(){var c=new System.Random();var d="\n";foreach(var e in ReadLine()){var f=c.Next(10);Write((char)(e+f));d+=f;}Write(d);}}

Non golfé:

using static System.Console;

class b
{
    static void Main()
    {
        var c = new System.Random();
        var d = "\n";

        foreach (var e in ReadLine())
        {
            var f = c.Next(10);
            Write((char)(e + f));
            d += f;
        }

        Write(d);
    }
}

Assez simple, vraiment.

Perl 6: 55 ou 70 octets

En tant que fonction anonyme qui prend un paramètre de chaîne et renvoie une liste de deux chaînes (54 caractères, 55 octets) :

{my @n=^9 .roll(.ords);(.ords Z+@n)».chr.join,@n.join}

En tant que programme qui lit depuis STDIN et écrit dans STDOUT (69 caractères, 70 octets) :

my @a=get.ords;my @n=^9 .roll(@a);say (@a Z+@n)».chr.join;say @n.join