Mettre en œuvre ce chiffre clé

13

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

m654
la source
5
Ce défi me semble bon, à l'exception de quelques réflexions. 1. Une fonction est-elle autorisée au lieu d'un programme complet? Une question connexe est la suivante: les valeurs peuvent-elles être renvoyées au lieu d'être imprimées? 2. Vous avez dit que les preferably with the format (ciphertext)\n(key).«fonctionnalités préférées» et le golf de code ne se mélangent pas très bien. Vous devez rendre cela obligatoire ou autoriser d'autres formats de sortie. 3. La clé doit-elle être imprimée sans espaces? Qu'en est-il de l'impression sous forme de liste, par exemple [0, 5, 2, ...]?
James
La clé peut-elle avoir des zéros non significatifs?
TheBikingViking
1
Beau premier défi mais je ne suis pas sûr des formats IO stricts. Les fonctions sont généralement autorisées et les réponses peuvent généralement être lues à partir de l'une des méthodes d'E / S acceptées. Cela comprend la sortie d'un tableau avec les éléments
Downgoat
1
Les chiffres de la clé doivent-ils être générés avec une distribution uniforme?
Dennis
1
Euh ... 101 + 2 est 103, pas 104. :-)
YetiCGN

Réponses:

5

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.
Dennis
la source
5

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

TheBikingViking
la source
votre générateur de clés ne génère pas de clés commençant par 0. l'augmentation des limites par un facteur 10 et la suppression du 1er chiffre devraient corriger: m=10**len(x);k=str(randint(m,m*10))[1:];et vous enregistrez même un octet dans le processus c:
Rod
@Rod Merci d'avoir signalé le bogue. Cependant, cela n'économisera aucun octet, car il randintest inclusif, ce qui signifie que vous devriez le faire m*10-1. Je viens de penser à un moyen de le réparer pour le même nombre d'octets.
TheBikingViking
3

Pyth - 16 octets

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

sCM+VCMQKmOTQjkK

Suite de tests .

Maltysen
la source
J'ai décidé du format.
m654
3

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
Mego
la source
2

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 .

Maltysen
la source
2

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
James
la source
Je ne sais pas si c'est le bon format ...
Leaky Nun
@Leaky Nun J'ai un peu changé les règles.
m654
@ m654 Où avez-vous dit qu'il peut y avoir des espaces entre les valeurs?
Leaky Nun
@LeakyNun À l'origine, il y avait une règle contre eux, mais je l'ai supprimée.
m654
1
Bonne idée d'utiliser la boucle. Il est en fait plus court que la version à entrées multiples de rouYr
Luis Mendo
2

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
AdmBorkBork
la source
2

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
Tom Doodler
la source
1
L'astuce n'est pas de comparer avec d'autres langages;) Je ne connais pas particulièrement bien le golf C #, mais pouvez-vous faire b++<i.Count()et laisser la troisième clause vide? De plus, je ne pense pas que vous ayez besoin d'une nouvelle ligne de fin, donc le dernier appel à WriteLinepourrait être à la Writeplace.
FryAmTheEggman
Je ne connais pas non plus bien C # mais je pense que vous pouvez déplacer le = r.Next (10) jusqu'à la déclaration de d et économiser sur un ensemble de parenthèses en écriture. Ou l'aléatoire ne renvoie-t-il pas un entier donc vous ne pouvez pas faire ça?
theLambGoat
Je pense que je peux le faire, laissez-moi vérifier
Tom Doodler
Vous pouvez remplacer les types par var. c'est-à-dire var c=au lieu de string c=raser quelques octets.
lait
Pourquoi ne pas laisser le résultat de Console.ReadLine()comme chaîne? i.Lengthest plus court que i.Count(), vous n'aurez pas besoin de System.Linq. la chaîne a un indexeur de caractères. En créant de nouveaux objets au hasard dans la boucle est moins octets: new Random().Next(10).
lait
2

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.
Dennis
la source
2

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

Emigna
la source
2

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
vagabondage
la source
Bienvenue sur ce site!
James
1

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.

Chat d'affaires
la source
Vous devez également imprimer la clé.
Alex Howansky
Vous pouvez mettre l' $s.=$rafter la 2ème semi dans la boucle for, en économisant un octet car vous pouvez vider sa semi-fin. Ensuite, votre boucle ne sera qu'une seule instruction afin que vous puissiez couper les accolades, en économisant 2 octets supplémentaires. Ensuite, à la fin, vous pouvez mettre l' $sintérieur de la chaîne entre guillemets en gardant l' .opérateur pour un octet de plus. :)
Alex Howansky
@AlexHowansky: C'est très vrai. Merci
Business Cat
1

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)
ljeabmreosn
la source
1

Perl, 34 octets

Comprend +1 pour -p

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

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

theLambGoat
la source
Votre solution a quelques problèmes. L'entrée n'est pas lue sous STDIN, $;ne démarre pas vide, donc elle imprime l'ancien contenu et le rand ne peut jamais en générer 9. Ils sont faciles à corriger et l'utilisation de STDIN rendra votre code plus court :-)
Ton Hospel
@TonHospel Habituellement, les exigences d'entrée sont lâches et les arguments sont acceptables sur STDIN et tout en prenant l'entrée de STDIN est plus court, avoir à supprimer le retour à la ligne le rend plus long. Et tandis que rand génère des nombres <9, la méthode int de Perl arrondit plutôt que des étages, donc tout> = 8,5 devrait finir comme 9
theLambGoat
Les exigences d'entrée sont généralement lâches, mais ce n'était pas le cas ici. Obtenir non saut de ligne de STDIN est facile: <>=~/./g. Et non, inten perl tronque vers 0, il ne s'arrondit pas. perl -wle 'print int 8.6'sorties8
Ton Hospel
0

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

atlasologue
la source
Vous devez sortir la clé ainsi que le texte chiffré.
TheBikingViking
@TheBikingViking ne sait pas comment j'ai raté ça. Merci - fixe
atlasologist
Je pense que cela a également le même problème qu'une version antérieure de ma réponse Python; il ne produit jamais de clés avec des zéros non significatifs.
TheBikingViking
@TheBikingViking Fixed again
atlasologist
changer map(chr,[ord(a)+int(b)for a,b in zip(x,y)])pour map(lambda x,y:chr(ord(x)+int(y)),x,y)? cela devrait sauver quelque chose
ljeabmreosn
0

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é.

ClementNerma
la source
0

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.

Scepheo
la source
0

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
smls
la source