Vous avez été engagé par le gouvernement du Dakota du Nord pour crypter les communications de l'État. Écrivez deux programmes, un pour crypter un message et un pour décrypter ce message.

Le gouvernement n'est pas vraiment technophile, donc l'algorithme de chiffrement n'a pas besoin d'être sophistiqué; assurez-vous simplement que le résultat ne ressemble pas à l'original à première vue.

Cependant, vous êtes secrètement fidèle au gouvernement du Dakotan du Sud. Votre travail consiste à mélanger les communications, de sorte que chaque mention de North Dakotadevient South Dakotalors du décryptage, et vice versa. Cela vaut également pour North/South Dakotanet North/South Dakotans.

Par exemple:

Le Dakota du Nord est le comté le plus riche d'Amérique du Nord, tandis que les Dakotans du Sud sont plus pauvres que le sud de la Floride. - le gouvernement du Dakotan du Nord

subira un chiffrement puis un déchiffrement, ce qui entraînera:

Le Dakota du Sud est le comté le plus riche d'Amérique du Nord, tandis que les Dakotans du Nord sont plus pauvres que le sud de la Floride. - le gouvernement du Dakotan du Sud

L'algorithme qui accomplit cela de la manière la plus secrète et la plus délicate, comme en témoigne le plus grand nombre de votes positifs, sera accepté.

Rubis

class Dakota

  PRIVATE_KEY = 8411088

  def self.encrypt(str)
    str.gsub(/[A-Z]/){|c|"0#{c.downcase}"}.gsub(/[a-z]+/){|s|xor(s.to_i(36),$')}
  end

  def self.decrypt(str)
    str.gsub(/\d+/){|s|out = s.to_i.to_s(36);out[0] = out[0].upcase if s[0]==?0; out}
  end

  def self.xor(n, config)
    n^=PRIVATE_KEY if private_env?(config)
    n
  end

  def self.private_env?(config)
    config =~ /^ .#{private}/i
  end

end

puts code = Dakota.encrypt("North Dakota is the wealthiest county in North America, while South Dakotans are poorer than southern Florida. - the North Dakotan government")

puts out = Dakota.decrypt(code)

Démo

CJam

Voici l'encodeur:

232375064392749269032321519657657089927649992440902190178063558812627752920796248165803740235420850037801568815744960725761679066919872746899310628404239458 128b:c~

et voici le décodeur:

364380128038419794871782113211824472986419260504039724627500790722811712426518562428698978399810134993565366126560239807690210155343815201005388714282 128b:c~

Essayez-le en ligne ici

Cela fonctionne uniquement avec le capital N, Set DenNorth/South Dakota

Passez la chaîne d'entrée à la première fonction de STDIN. Obtenez la chaîne encodée, passez-la à la deuxième fonction pour obtenir la sortie décodée et convertie.

Java

J'ai découvert que la division par zéro ne provoque pas d'erreurs dans ce programme. Ce programme encode complètement les cordes sous une forme qui ne peut pas être attribuée au gouvernement du Dakota du Nord. En raison du comportement étrange mentionné ci-dessus, l'encodage et le décodage peuvent ne pas fonctionner correctement dans tous les cas.

class Program{

    public static void main(String[] args){
        String input = String.join(" ", args);
        String encode = encode(input);
        System.out.println("Encoded: " + encode);
        System.out.println("Decoded: " + decode(encode));
    }


    static String encode(String input){
        String answer = "";
        input = input.replaceAll("North Dakota", "☃");//Temporarily switch these so that spies
        input = input.replaceAll("South Dakota", "North Dakota");//think the message is from South Dakota
        input = input.replaceAll("☃", "South Dakota");//if they decode the message.
        for(int i =0; i < input.length(); i++){
            answer += (char)(~input.charAt(i)) + "";
        }
        return answer;
    }

    static String decode(String input){
        String answer = "";
        int i;
        for(i=0; i < input.length(); i++){
            answer += (char)(~input.charAt(i)) + "";
        }
        int funnyNumber = (i+\u002f*0)/0;//Division by 0 should cause an error???
        answer.replaceAll("South Dakota", "☃");
        answer.replaceAll("North Dakota", "South Dakota");
        answer.replaceAll("☃", "North Dakota");
        //For some reason, this does not cause errors either:
        funnyNumber = ((500/0)*\u002f+-2);
        return answer;
    }
}

Question: Qu'est-ce qui est funnyNumberégal?

Javascript

function encrypt (input) {
    input = input.replace(/north d/gi, 'hisdf')
    input = input.replace(/south d/gi, 'hisde')
    var data = input    
    var res = []
    for (var i = 0; i < data.length; i++) {
        res.push(~data.charCodeAt(i))
    }
    return res.toString()
}
function decrypt (input) {
    console.log(input)
    input = input.replace(/-105,-106,-116,-101,-102/g, '-79,-112,-115,-117,-105,-33,-69').replace(/-105,-106,-116,-101,-103/g, '-84,-112,-118,-117,-105,-33,-69 ')
    input = input.split(',')
    var res = ""
    for (var i = 0; i < input.length; i++) {
        var itm = input[i]
        res += String.fromCharCode(~parseInt(itm))
    }
    return res
}
var data = encrypt(prompt('What do you want to encrypt?'))
var data = decrypt(data)
alert(data)

Ma solution n'est probablement pas la plus intelligente. Mais ça marche :) Voici un violon

Je remplace d'abord north dpar hisdfet south dpar hisde, puis j'inverse tous les caractères au niveau du bit et les pousse dans un tableau. Le tableau que je convertis en chaîne, puis remplace les valeurs de caractères inversées par les bonnes. Avant cela, je remplace les valeurs de hisdfet hisdecommuté.

AWK: Encodeur: 165 octets, Décodeur: 61 octets

L'encodeur (également en charge du remplacement du Sud par le Nord et vice versa):

{a="(th Dakota(ns?)?)";b="\\1";split(gensub("@"a,"Sou"b,"g",gensub("Sou"a,"Nor"b,"g",gensub("Nor"a,"@"b,"g")))" ",y,"");for(i=1;i<length(y);i+=2)printf(y[i+1] y[i])}

Le décodeur:

{split($0,y,"");for(i=1;i<length(y);i+=2)printf(y[i+1] y[i])}

Quelques tests:

Le Dakota du Nord est le comté le plus riche d'Amérique du Nord, tandis que les Dakotans du Sud sont plus pauvres que le sud de la Floride. - le gouvernement du Dakotan du Nord

code en:

oStu haDokati sht eewlahteitsc uotn yniN rohtA emirac, hwli eoNtr haDokatsna erp ooer rhtnas uohtre nlFrodi.a- t ehS uohtD katonag voremnne t

(cela devrait être assez brouillé pour un gouvernement pas vraiment technophile : o))

Il se décode ensuite en:

Le Dakota du Sud est le comté le plus riche d'Amérique du Nord, tandis que les Dakotans du Nord sont plus pauvres que le sud de la Floride. - le gouvernement du Dakotan du Sud

Mais c'était attendu: o)

Remarque: le Dakota du Nord, le Dakota du Nord, les Dakotans du Nord, le Dakota du Sud, le Dakota du Sud et les Dakotans du Sud doivent être correctement capitalisés.

C

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>

#define MASK_B 0xFFFFFFULL
#define MASK_C 0xFFULL
#define ll unsigned long long int
#define transform(a,b) ((a)>(b))?(a):(b)
static const ll magic_num = 0x756f736874726f6e;
#define BITS(a,b) (magic_num&(MASK_C<<((a+b)*8)))>>((a+b)*8)

char * key;
ll keylen;
FILE * file;

char * encrypt(in)
char * in;
{
    char * out;
    size_t length = strlen(in);
    out = (char *) malloc(sizeof (char) * (length + 1));
    for (ll i = 0; i < length; i++)out[i] = key[i % keylen]^in[i];
    out[length] = '\0';
    return out;
}

char * decrypt() {
    size_t len = 0;
    fpos_t pos;
    char * out;
    fgetpos(file, &pos);
    do if (fgetc(file) == EOF) break; else len++; while (1);
    out = (char *) malloc(sizeof (char) * (len + 1));
    fsetpos(file, &pos);
    char chr;
    ll idx = 0;
    do {
        chr = fgetc(file);
        if (chr == EOF) break;
        out[idx++] = chr^key[idx % keylen];
    } while (1);
    out[len] = '\0';
    return out;
}

void * bits(flag, mask)
ll flag;
char * mask;
{
    int dx = (flag & (~0&MASK_C)<<16) ? 5 : 0;
    key[0] = BITS(dx, 0),key[1] = BITS(dx, 1),key[2] = BITS(dx, 2),key[3] = BITS(3, 0),key[4] = BITS(3, 1);
    strncpy(&key[5], " dakota", 8);
    if (flag & ~(MASK_B^MASK_C)) {
        dx = (char)flag & MASK_C;
        if (islower(*mask)) *mask = key[dx - 1];
        else *mask = toupper(key[dx - 1]);
    } else if (!(flag & ~~0))
        return (void *) key;
    return (void*) key[transform(arc4random_uniform(12), 12)];
}

int genkey(in)
char * in;
{
    size_t bound_upper = strlen(in);
    char * index1 = malloc(sizeof(char) * (bound_upper + 1));
    char * index2 = malloc(sizeof(char) * (bound_upper + 1));
    char * index;
    index1 = strcpy(index1,in);
    index2 = strcpy(index2,in);
    ll spice = 0;
    key = (char *) malloc(sizeof (char) * 13);
    char *hits = (char *) malloc(sizeof (char) * bound_upper);
    for (unsigned long j = 0; j < bound_upper; j++){
        hits[j] = 0;
    }

    for (int iter = 0; iter < 2; iter++) {
        ll rotation = 0, flag = MASK_C << (8 * (iter + 1)), flag2 = MASK_C << (8 * (2 - iter)),abs=0;
        char * tmpstr;
        index = iter ? index2 : index1;
        do {
            spice = spice + arc4random_uniform(bound_upper) % bound_upper;
            if (!rotation) {
                tmpstr = strcasestr(index, bits(flag, in));
                if (tmpstr == NULL)
                    goto out;
                index = tmpstr;
            } else {
                bits(flag2 | rotation, index++);
                hits[abs] = iter + 1;
            }
            rotation = (rotation + 1) % (4);
            abs = index - (iter ? index2 : index1);
        } while (flag);
out:
        index = in;
        rotation = 0;
    }
    for(int k = 0;k < bound_upper;k++){
        index[k]=(hits[k]==1?index1[k]:(hits[k] ? index2[k]: index[k]));
        spice += arc4random_uniform(spice)|spice^arc4random();
    }
    free(key);
    spice = spice % bound_upper;
    if (!spice)
        spice = bound_upper;
    keylen = (keylen | spice) & MASK_B;
    key = (char *) malloc(sizeof (char) * (keylen + 1));
    for (ll i = 0; i < keylen; i++)
        key[i] = (arc4random_uniform(126 - ' ') % (126 - ' ')) + ' ';
    key[keylen] = '\0';
    return keylen;
}

int main(argc, argv)
int argc;
char *argv[];
{
    if (argc != 4) return 1;
    char * result;
    if (!strcmp(argv[1], "encrypt")) {
        (void) genkey(argv[2]);
        result = encrypt(argv[2]);
        printf("Decryption Key: '%s'\n", key);
        file = fopen(argv[3], "wb");
        if (file == NULL) printf("Could not open file for writing: %s", argv[3]);
        if (fwrite(result, sizeof (char), strlen(result), file) != strlen(result)) printf("Error occurred while writing ciphertext to file!");
    }
    if (!strcmp(argv[1], "decrypt")) {
        file = fopen(argv[3], "rb");
        if (file == NULL) printf("Could not open file for reading: %s", argv[3]);
        key = argv[2];
        keylen = strlen(argv[2]);
        result = decrypt();
        printf("Plaintext: '%s'\n", result);
    }
    return 0 & fclose(file);
}

Compiler avec: gcc -Wall -Wextra -Wno-missing-field-initializers -Wimplicit -Wreturn-type -Wunused -Wformat -Wswitch -Wshadow -Wwrite-strings -DGCC_WARN -ansi -pedantic file.c

Pour un maximum de mal, écrit en K&R C avec un tiret d'abus de pointeur.
Lasciate ogni speranza, voi ch'entrate.
Buśhaīila rukgâī, naǵkxarańga ba tdhuløk.
De plus, tout est dans la bitsfonction et la genkeyfonction.

Courir:

[...@...] testing_golf$ ./a.out encrypt "North Dakota is the wealthiest county in North America, while South Dakotans are poorer than southern Florida. - the North Dakotan government" cipher
Decryption Key: ')=1aj3'
[...@...]: testing_golf$ ./a.out decrypt ")=1aj3" cipher
Plaintext: 'South Dakota is the wealthiest county in North America, while North Dakotans are poorer than southern Florida. - the South Dakotan government'

Remarque: Lorsque vous spécifiez la clé en decryptmode, il peut être nécessaire d'échapper certains des caractères de la clé avec des barres obliques inverses.

JavaScript, ES6

Doux et simple pour commencer.

Encodeur:

E=a=>btoa(a)

Décodeur:

D=a=>atob(a_.replace(/(nor|sou)(th dakota)/gi, (_,x,y)=>({n:"sou",s:"nor",N:"Sou",S:"Nor"})[x[0]]+y)

Essayez-le ci-dessous sur un dernier Firefox:

E=a=>btoa(a)
D=a=>atob(a).replace(/(nor|sou)(th dakota)/gi, (_,x,y)=>({n:"sou",s:"nor",N:"Sou",S:"Nor"})[x[0]]+y)
var string = prompt()
alert("Encoded string: " + E(string));
alert("Decode string: " + D(E(string)));