Scrivi un codificatore di cifratura VIC

18

La cifra VIC è una delle cifre più complicate mai realizzate per matita e carta. Utilizzato negli anni '50 dalla spia sovietica Reino Häyhänen, nome in codice "VICTOR", il suo principio principale è la sicurezza attraverso l'offuscamento; un sacco di confusione.

Il tuo compito è scrivere un programma o una funzione che prenderà un messaggio e lo codifichi usando il codice VIC. Ho anche pubblicato una sfida decodificatore di cifratura VIC qui . Se una delle seguenti istruzioni non è chiara, non esitare a chiedere informazioni nei commenti. Le istruzioni sono adattate da questo sito .

Codifica del codice VIC

Preparazione

Avrai bisogno di cinque input:

  • il messaggio in chiaro
  • una breve parola chiave o frase contenente le lettere più comuni nella tua lingua
  • una frase chiave, come una citazione o una riga di una canzone (almeno 20 caratteri)
  • una data (o un altro numero di almeno sei cifre)
  • un numero di agente personale

In pratica, questi ultimi quattro dovrebbero essere concordati preventivamente dal mittente e dal destinatario, incluso se il codice agente del mittente o del destinatario viene utilizzato nella codifica.

Il mio messaggio di esempio sarà: We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot 3.

Codificheremo in inglese (anche se puoi usare la lingua e l'alfabeto che preferisci) e le lettere più comuni dell'alfabeto inglese A, E, I, N, O, R, S, T. Userò la parola chiave SENATORI.

La mia frase chiave è una citazione di Richard Feynman: "Il primo principio è che non devi ingannare te stesso e sei la persona più facile da ingannare".

Come data, userò il 31 luglio 2016 (nel formato 3172016), che è il giorno in cui ho scritto questa descrizione.

Il numero personale che ho scelto per me stesso è 9.

Riepilogo dei passaggi

  1. Derivare le chiavi intermedie per l'uso nei seguenti passaggi.
  2. Costruisci e applica la scacchiera a cavallo.
  3. Costruisci e applica la prima tabella di trasposizione.
  4. Costruisci e applica la seconda tabella di trasposizione (interrotta).
  5. Finalizza il messaggio inserendo il gruppo di indicatori del messaggio.

Submechanisms

Altre due cose da spiegare prima di entrare nella carne della questione: i processi di aggiunta e sequenziamento della catena.

L'aggiunta di catena, nota anche come generatore di Fibonacci ritardato, funziona prendendo una sequenza di cifre iniziale, aggiungendo le prime due cifre senza riportarle (aggiungendole poi insieme mod 10) e aggiungendo il risultato alla fine. Per esempio:

79081
7 + 9 = 6

790816
9 + 0 = 9

7908169
0 + 8 = 8

79081698
8 + 1 = 9

790816989
1 + 6 = 7

7908169897
... and so on

Il sequenzialismo consiste essenzialmente nel prendere una sequenza di lettere o cifre ed etichettarle in base al loro ordine alfabetico / numerico. I duplicati sono etichettati da sinistra a destra. Per esempio:

E X A M P L E
    0           # A
1   0       2   # Es
1   0     3 2   # L
1   0 4   3 2   # M
1   0 4 5 3 2   # P
1 6 0 4 5 3 2   # X

3  3  0  5  8  4  2  0  4  7  5  4  8  1
      0              1                     # 0s
      0              1                 2   # 1
      0           3  1                 2   # 2
4  5  0           3  1                 2   # 3s
4  5  0        6  3  1  7        8     2   # 4s
4  5  0  9     6  3  1  7    10  8     2   # 5s
4  5  0  9     6  3  1  7 11 10  8     2   # 7
4  5  0  9 12  6  3  1  7 11 10  8 13  2   # 8s

Uso l'indicizzazione zero qui, ma indicizza come preferisci.

1. Tasti intermedi

Dividi le prime 20 lettere della frase chiave in due gruppi di 10 e sequenzialmente ciascuna individualmente, che chiameremo S1e S2.

    THEFIRSTPR
S1: 8201357946

    INCIPLEIST
S2: 2603751489

Scegli un identificatore di messaggio a 5 cifre casuale, M(questo può essere uno degli input se preferisci):

M = 47921

Sottrai, senza prendere in prestito (sottrai mod 10), le prime cinque cifre della data chiave 3172016da M:

M      47921
date - 31720
     = 16201

La catena aggiunge il risultato fino a quando non hai dieci cifre:

1620178218

Aggiungi queste cifre a S1, senza portare o mod 10, per ottenere G:

     1620178218
S1 + 8201357946
G  = 9821425154

Sopra S2, scrivi la sequenza 0123456789. Individua ogni cifra di Gnella sequenza 0123456789 e sostituiscila con la cifra direttamente sotto di essa in S2. Il risultato è T.

   0123456789
S2 2603751489

G  9821425154
T  9806705657

Utilizzare l'aggiunta catena per espandere Ta 60 cifre.

9806705657

becomes

980670565778637511245490262369939288595822106344304316978734

Queste ultime 50 cifre, in cinque file di dieci cifre ciascuna, formano il Ublocco.

T  9806705657
U  7863751124
   5490262369
   9392885958
   2210634430
   4316978734

Le ultime due cifre non uguali del Ublocco vengono aggiunte singolarmente al numero personale dell'agente per fornire le larghezze delle due trasposizioni, pe q.

9 + 3 = 12 (p, prima larghezza di trasposizione) 9 + 4 = 13 (q, seconda larghezza di trasposizione)

Sequentialize Te utilizzare questa sequenza per copiare largo delle colonne del Ublocco, dall'alto verso il basso, in una nuova fila di cifre, V.

T     9806705657
seqT  9804612537

U     7863751124
      5490262369
      9392885958
      2210634430
      4316978734

V     69911 56837 12548 26533 30206 13947 72869 49804 84323 75924

Sequenzializza le prime pcifre per ottenere la chiave per la prima trasposizione K1e le qcifre seguenti per la chiave per la seconda K2.

First 12  6  9  9  1  1  5  6  8  3  7  1  2
K1        6 10 11  0  1  5  7  9  4  8  2  3

Next 13   5  4  8  2  6  5  3  3  3  0  2  0  6
K2        8  7 12  2 10  9  4  5  6  0  3  1 11

Infine, in sequenza l'ultima riga del Ublocco da ottenere C, le intestazioni di colonna per la scacchiera a cavallo:

U5  4316978734
C   3105968724

2. Scacchiera a cavallo

In primo luogo, darò la mia scacchiera di esempio, quindi spiegherò i principi per crearlo in quel modo:

  3 1 0 5 9 6 8 7 2 4
  S E N A T O R I
2 B D G J L P U W Y .
4 C F H K M Q V X Z #

La prima riga di lettere è la nostra parola chiave breve SENATORI. La tua parola chiave può essere qualsiasi stringa senza duplicati, ma poiché definisce la riga superiore della tua scacchiera, scegli saggiamente. Sopra la parola chiave è C, e le altre righe sono il resto dell'alfabeto nell'ordine che scegli. Nel mio caso, ho riempito la scacchiera con il resto dell'alfabeto latino, un segno di punteggiatura .e un segno di demarcazione dei numeri #. In sostanza, la scacchiera è un elaborato codice di sostituzione. Ad esempio, "E" verrà sostituito con 1"W" verrà sostituito con 27.

Una volta che abbiamo codificato il nostro messaggio in chiaro con questa scacchiera, ma prima, dobbiamo rendere meno evidente l'inizio del nostro messaggio suddividendolo in una posizione casuale e rendendolo tutto maiuscolo. Per indicare l'altro inizio originale, usiamo due arresti completi..

We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot 3.

diventa

HING ELSE. MOVE TO SAFEHOUSE FOXTROT#3#.. WE ARE
DISCOVERED. TAKE WHAT YOU CAN. BURN EVERYT

Codifichiamo con la scacchiera, dandoci:

407020 1293124 496481 96 354114062831 416479869443442424 271 581 
2173436481812124 95451 274059 22628 435024 232880 14818229

Se la lunghezza del messaggio non è divisibile per 5, aggiungiamo alcuni caratteri null per completare il messaggio. Il nostro messaggio è lungo 109 cifre, quindi aggiungerò uno null: "4".

40702 01293 12449 64819 63541 14062 83141 64798 69443 44242 42715
81217 34364 81812 12495 45127 40592 26284 35024 23288 01481 82294

Nota: poiché il mio messaggio di esempio non contiene numeri, qui dirò che potresti designare, diciamo, come #3#, che è codificato come 44344qui.

3. Prima trasposizione

Crea la tabella di trasposizione scrivendo K1(dalla sezione Chiavi intermedie) seguita dal messaggio codificato del passaggio precedente, in file della stessa lunghezza, sotto la chiave:

K1   6 10 11  0  1  5  7  9  4  8  2  3

     4  0  7  0  2  0  1  2  9  3  1  2
     4  4  9  6  4  8  1  9  6  3  5  4
     1  1  4  0  6  2  8  3  1  4  1  6
     4  7  9  8  6  9  4  4  3  4  4  2
     4  2  4  2  7  1  5  8  1  2  1  7
     3  4  3  6  4  8  1  8  1  2  1  2
     4  9  5  4  5  1  2  7  4  0  5  9
     2  2  6  2  8  4  3  5  0  2  4  2
     3  2  8  8  0  1  4  8  1  8  2  2
     9  4

Prendendo le colonne numerate in ordine di numero, otteniamo:

060826428  246674580  151411542  246272922  961311401  082918141
4414434239 118451234  334422028  293488758  0417249224 794943568

4. Seconda trasposizione

La prima trasposizione era relativamente semplice. Questo, tuttavia, è una trasposizione interrotta. Il modello di interruzione è determinato dalla larghezza della tabella e dalla chiave. Nel nostro esempio, abbiamo 110 cifre e 13 colonne, il che significa che avremo 8 righe complete e 6 rimanenti. Iniziamo a compilare la prima riga, ma ci fermiamo alla colonna 0 e continuiamo come segue:

K2   8  7 12  2 10  9  4  5  6  0  3  1 11

     0  6  0  8  2  6  4  2  8              stop at 0
     2  4  6  6  7  4  5  8  0  1           continue in a triangle pattern
     5  1  4  1  1  5  4  2  2  4  6
     2  7  2  9  2  2  9  6  1  3  1  1
     4  0  1  0  8  2  9  1  8  1  4  1  4  until the end
     4  1  4  4  3  4  2  3  9  1  1        restart and stop at 1
     8  4  5  1  2  3  4  3  3  4  4  2
     2  0  2  8  2  9  3  4  8  8  7  5  8
     0  4  1                                restart and stop at 2

Quindi riempiamo gli ultimi spazi con le cifre rimanenti.

K2   8  7 12  2 10  9  4  5  6  0  3  1 11

     0  6  0  8  2  6  4  2  8  7  2  4  9
     2  4  6  6  7  4  5  8  0  1  2  2  4
     5  1  4  1  1  5  4  2  2  4  6  7  9
     2  7  2  9  2  2  9  6  1  3  1  1  4
     4  0  1  0  8  2  9  1  8  1  4  1  4
     4  1  4  4  3  4  2  3  9  1  1  9  4
     8  4  5  1  2  3  4  3  3  4  4  2  3
     2  0  2  8  2  9  3  4  8  8  7  5  8
     0  4  1  5  6  8

Ora leggiamo le colonne esattamente nello stesso modo in cui abbiamo fatto nella prima trasposizione.

71431148  42711925  861904185 22614147  45499243  28261334  80218938
641701404 025244820 645224398 271283226 94944438  064214521

E dividi tutto in gruppi di 5 cifre:

71431 14842 71192 58619 04185 22614 14745 49924 32826 13348 02189
38641 70140 40252 44820 64522 43982 71283 22694 94443 80642 14521

5. Finalizzare il messaggio

Il passaggio finale consiste nell'inserire il nostro identificatore di messaggio casuale 47921, nel messaggio stesso. La cifra finale della data chiave 6indica la distanza che il gruppo dovrebbe raggiungere dalla fine.

71431 14842 71192 58619 04185 22614 14745 49924 32826 13348 02189 38641
70140 40252 44820 64522 43982 47921 71283 22694 94443 80642 14521

Note per questa sfida

  • Ti vengono dati almeno cinque input: il messaggio, la parola chiave lettera, la frase chiave, la data e un numero personale. È possibile includere due input aggiuntivi: l'identificatore di messaggio casuale e gli null necessari per completare il messaggio, oppure la funzione può generare alcuni numeri casuali da sola.
  • Si può presumere che tutti gli input siano validi, con il numero corretto di cifre e lettere (identificativo del messaggio a 5 cifre, almeno 20 cifre per la frase chiave e così via). Puoi presumere che le tue stringhe (il messaggio e le parole chiave) abbiano già rimosso tutta la punteggiatura e gli spazi tranne quelli consentiti nella tua versione e che i numeri siano già delimitati da segni numerici.
  • La prima parola chiave non deve contenere lettere duplicate e, nel tuo codice, puoi presumere che non abbia mai lettere duplicate.
  • La lingua che usi per codificare non ha importanza, purché la lingua sia preesistente, l'alfabeto sia preesistente e specifichi quale lingua utilizzare nella tua risposta.
  • Qualunque alfabeto usi per la tua scacchiera a cavallo, puoi aggiungere o rimuovere simboli per riempire la scacchiera. Specificare per cosa si utilizzano questi simboli (ad esempio, punteggiatura, un simbolo "inizio messaggio" separato, simboli per parole comuni). Puoi rinunciare del tutto al segno del numero e precisare i numeri o includere ogni cifra nella scacchiera, usando lo slot in cui il segno del numero era per qualcos'altro. Si prega di specificare quale scacchiera hai usato nella tua risposta.
  • L'output dovrebbe essere una stringa di gruppi di cinque cifre separati da spazio, un elenco di numeri interi di cinque cifre o qualcosa di simile.
  • Ho usato l'indicizzazione zero e 0123456789nel mio esempio. Puoi utilizzare l'indicizzazione 1 e 1234567890, o qualche altro sistema nella tua risposta, purché specifichi ciò che hai usato.

Ecco un'implementazione di esempio su Ideone .

Questo è un post lungo e ho scritto la maggior parte a mano, quindi se ci sono parti confuse in questo post o errori nel mio conteggio e trasposizione, per favore fatemelo sapere. Buona fortuna e buon golf!

code-golf  cryptography 
— Sherlock9
fonte
1
adding the first two digits without addingIntendi portare?
— Isaacg,
@isaacg Sì, l'ho fatto. Modificato.
— Sherlock9,
Potresti chiarire cosa intendi con without borrowinge without carrying? Intendi aggiungere e sottrarre mod 10, ovvero (6+7) mod 10 = 3e (6-8) mod 10 = 8?
— R. Kap
@ R.Kap Sì, lasciami andare a chiarirlo.
— Sherlock9
Dobbiamo avere a numeri delimitare?
— R. Kap

Risposte:

10

Python 3 , 1423 1348 1324 1316 1300 1286 1250 1249 1209 1206 1204 byte

Questo è sicuramente il golf più lungo che abbia mai fatto, e l'unico golf in cui ero seriamente preoccupato di rimanere senza nomi di variabili a un carattere. Suggerimenti di golf benvenuti. Provalo online!

Sto codificando con l'alfabeto latino maiuscolo con caratteri aggiuntivi .e #, usando l'indicizzazione 0 e 0123456789durante la conversione gin t. La mia scacchiera è in un formato simile al seguente esempio:

  2 9 7 4 5 8 3 1 0 6    # C
  S E N A T O R I        # keyword
0 B D G J L P U W Y .    # remaining alphabet arranged in columns
6 C F H K M Q V X Z #    # . and # at the end

Modifica: -63 byte grazie al suggerimento di TuukkaX di abbreviare alcune delle funzioni usate di frequente con variabili di una lettera. -12 byte dal rendere a, g, tpiù compatto.

Modifica: -24 byte dalla creazione rimuovendo i nomi delle variabili per le chiavi intermedie che vengono utilizzate una sola volta, vale a dire a, g, s, S, k, K.

Modifica: -74 byte dal consolidamento H(), T() and C().

Modifica: -1 byte grazie a Nick A per il suggerimento di passare ord(s[i])+ord(s[i+1])a sum(map(ord,s[i:i+2])). -2 byte dalla modifica di 2 +=[a]chiamate a +=a,. -13 byte dalla modifica di come G()trovato l'indice del minimo di s. -2 byte dal passaggio y=(y+1)%va y=-~y%v. -15 byte dall'assegnazione k.index()a K. -4 byte dall'assegnazione 10a W. -5 byte da assegnare 1-I(d[-1])a Xdentro V. -3 byte dal C()ciclo principale della riscrittura . -2 byte dalla riorganizzazione T().

I=int;L=list;E=len;R=range;B=str;J=''.join;W=10
def H(s,e):
 for i in R(e-E(s)):s+=chr(48+sum(map(ord,s[i:i+2]))%32%W)
 return s
def Q(s):
 r=[0]*E(s);s=L(s)
 for z in R(E(s)):b=s.index(min(s));r[b]=z;s[b]="~"
 return r
def T(x,k,d=0):
 u=E(x);v=E(k);g=R(v);K=k.index;n=u//v+1;w=[];e=r=y=0;i=K(y);c=[]
 if d:
  while r<n:
   if r>n-1:i=min(i,(u%v or v))
   w+=L(x[e:e+i]),;e+=i;i+=1;r+=1
   if i>v:y=-~y%v;i=K(y)
  r=y=0;i=v-K(y)
  while r<n:
   w[r]+=L(x[e:e+i]);e+=i;i-=1;r+=1
   if i<1:y+=1;i+=v-K(y);r+=1
  w[-1]+=['']*(v-E(w[-1]))
  for j in g:c+=J(z[j]for z in w),
 else:c=[x[i::v]for i in g]
 s=[0]*v
 for f in g:s[k[f]]=c[f]
 return J(s)
def C(m,s,w,n):
 t={".":s[-2:],"#":s[-1]*2};j=z=0
 for x in R(26):
  v=chr(x+65)
  if v in w:t[v]=s[w.index(v)]
  else:t[v]=s[z-2]+s[j];j+=z;z=-~z%2
 r=J(i.isdigit()and i or t[i]for i in m)
 return r+n[:-E(r)%5]
def V(m,w,P,d,A,M,n):X=1-I(d[-1]);t=J(B(Q(P[W:20])[I(J(B((I(H(J(B((I(M[i])-I(d[i]))%W)for i in R(5)),W)[i])+I(Q(P[:W])[i]))%W)for i in R(W))[i])])for i in R(W));u=H(t,60)[W:];p=A+I(u[-2]);v=T(u,Q(t));z=T(T(C(m,J(B(i)for i in Q(u[40:])),w,n),Q(v[:p])),Q(v[p:p+A+I(u[-1])]),1);e=[z[5*i:5*-~i]for i in R(-(-E(z)//5))];return' '.join(e[:X]+[M]+e[X:])

Ungolfing:

def chain_add(seq, end):
    for i in range(end - len(seq)):
        seq += chr(48+sum(map(ord,seq[i:i+2]))%32%10)
    return seq

def sequent(seq):
    res = [0]*len(seq)
    seq = list(seq)
    for z in range(len(seq)):
        b = seq.index(min(seq))
        res[b] = z
        seq[b] = "~"
    return res

def transpose(text, keys, disrupt=False):
    if disrupt:
        num_rows = len(text) // len(keys) + 1
        len_last = len(text) % len(keys)
        if len_last == 0:
            len_last = len(keys)
        d_rows = []
        text_index = 0
        current_row = 0
        stop_key = 0
        stop_index = keys.index(stop_key)
        while current_row < num_rows:
            if current_row > num_rows-1:
                stop_index = min(stop_index, len_last)
            d_rows += [list(text[text_index:text_index+stop_index])]
            text_index += stop_index
            stop_index += 1
            if stop_index>len(keys):
                stop_key = (stop_key+1) % len(keys)
                stop_index = keys.index(stop_key)
            current_row += 1
        current_row = 0
        stop_key = 0
        stop_len = len(keys) - keys.index(stop_key)
        while current_row < num_rows:
            d_rows[current_row] += list(text[text_index:text_index+stop_len])
            text_index += stop_len
            stop_len -= 1
            if stop_len < 1:
                stop_key += 1
                stop_len = len(keys) - keys.index(stop_key)
                current_row += 1
            current_row += 1
        d_rows[-1] += ['']*(len(keys)-len(d_rows[-1]))
        columns = []
        for j in range(len(keys)):
            columns += [''.join(i[j]for i in d_rows)]
    else:
        columns = ['']*len(keys)
        for t in range(len(text)):
            columns[t%len(keys)] += text[t]
    res = [0]*len(keys)
    for index in range(len(keys)):
        res[keys[index]] = columns[index]
    return''.join(res)

def checkerboard(message, seq, word, null):
    trans = {".":seq[-2:], "#":seq[-1]*2};res='';j=z=0
    for x in range(26):
        v = chr(x + 65)
        if v in word:
            trans[v] = seq[word.index(v)]
        else:
            trans[v] = seq[z-2] + seq[j]
            j += z
            z = (z+1) % 2
    for i in message:
        if i.isdigit():
            res += i
        else:
            res += trans[i]
    return res + null[:-len(res)%5]

def vic_cipher(message, keyword, phrase, date, agent, m_id, null):
    s1 = sequent(phrase[:10])
    s2 = sequent(phrase[10:20])
    a = ''.join(str((int(m_id[i])-int(date[i]))%10) for i in range(5))
    g = ''.join(str((int(a[i])+int(s1[i]))%10) for i in range(10))
    t = ''.join(str(s2[int(g[i])]) for i in range(10))
    u = chain_add(t,60)[10:]
    p = agent+int(u[-2])
    q = agent+int(u[-1])
    seqT = sequent(t)
    v = transpose(u,seqT)
    k1 = sequent(v[:p])
    k2 = sequent(v[p:p+q])
    c = ''.join(str(i)for i in sequent(u[40:]))
    x = checkerboard(message,c,keyword,null)
    y = transpose(x,k1)
    z = transpose(y,k2,1)
    e = [z[5*i:5*(i+1)] for i in range(-(-len(z)//5))]
    X = 1-int(date[-1])
    return ' '.join(e[:X] + [m_id] + e[X:])
— Sherlock9
fonte
2
Python 3 consente caratteri unicode come variabili, FYI.
— Paul
Cambiare ord(seq[i])+ord(seq[i+1])per sum(map(ord,seq[i:i+2]))salvare 1 personaggio credo.
3

C, 2880 2769 2766 2762 2743 2741 2739 2699 2458 byte

#include<stdio.h>
#define m(x)malloc(x)
#define Y(x)strlen(x)
typedef int i;typedef char*c;c _(c A,i B,i D){if(D>=B){return A;}c C=m(Y(A)+2);sprintf(C,"%s%c",A,48+(A[D]+A[D+1]-96)%10);return _(C,B,D+1);}c l(c A){i J=Y(A);c P=m(J+2);for(i m=0;m<J;m++){P[m]=32;}for(i v=0;v<J;v++){char G;i R;for(i u=0;u<J;u++){R=u<1|A[u]<G?u:R;G=u<1|A[u]<G?A[u]:G;}P[R]=48+v;c V=m(J);for(i t=0;t<J;t++){V[t]=t!=R?A[t]:97;}A=V;}return P;}c S(c C,c N,c I,char U){srand(time(NULL));i M=Y(I);i O=Y(N);i R=rand()%M;c Q=m(M+1);for(i u=R;u<M;u++){Q[u-R]=I[u];}Q[M-R]=46;for(i H=0;H<R;H++){Q[H+M-R+1]=I[H];}c g=m(28);c V=m(28);strcat(V,C);sprintf(g,"%s%s",N,"BCDFGHJKLMPQUVWXYZ.#");i B=Y(N);for(i q=B;q<10;q++){for(i x=0;x<10;x++){char J[2]={C[q],C[x]};V[B]=48+atoi(J);B++;}}c w=m(M*2+4);for(i J=0;J<=M;J++){i K=0;for(i X=0;X<28;X++){if(Q[J]==g[X]){char F[3];sprintf(F,"%d",V[X]-48);strcat(w,F);K=1;}}if(K<1){w[Y(w)]=Q[J];}}i f=Y(w);if(f%5>0){c P=m(5-f%5);for(i E=0;E<5-f%5;E++){P[E]=U;}strcat(w,P);}return w;}c a(c I,c U){i M=Y(I),K=Y(U);c T=m(M);i F=0;for(i b=0;b<K;b++){for(i y=0;y<K;y++){if(U[y]==48+b){for(i u=y;u<M;u+=K){T[F]=I[u];F++;}}}}return T;}c da(c I,c K){i e=Y(I),k=Y(K);c T=m(e);for(i y=0;y<e;y++){T[y]=32;}i F,P;F=P=0;for(i u=0;u<k;u++){for(i v=0;v<k;v++){T[F]=I[P];P++;F++;if(K[v+1]-48==u){for(i C=1;C<k-v;C++){F+=k-v-C;for(i E=0;E<=v+C;E++){if(F<e&P<e){T[F]=I[P];}F++;P++;}}break;}}if(F>e){break;}}i U=0;for(i g=0;g<e;g++){U=T[g]-48<10&-1<T[g]-48?U+1:U;}for(i j=U;j<e;j++){for(i x=0;x<e;x++){if(T[x]==32){T[x]=I[j];break;}}}return a(T,K);}En(c n,c m,c k,i d,c v,c s,char u){c S1,S2;S1=m(10);S2=m(10);for(i i=0;i<20;i++){if(i<10){S1[i]=k[i];}else{S2[i-10]=k[i];}}S1=l(S1);S2=l(S2);c M=m(5);for(i i=4;i>-1;i--){M[i]=48+(s[i]-v[i])%10;}c G=_(M,5,0);for(i y=0;y<10;y++){G[y]=48+(S1[y]+G[y]-96)%10;}c N="0123456789";c T=m(10);for(i q=0;q<10;q++){for(i t=0;t<10;t++){if(N[t]==G[q]){T[q]=S2[t];}}}c Z=_(T,50,0);c U=m(50);for(i h=0;h<50;h++){U[h]=Z[h+10];}i p,q;for(i b=49;b>10;b++){if(U[b]!=U[b-1]){q=d+U[b]-48;p=d+U[b-1]-48;break;}}c V=m(50);i Ct=0;for(i j=0;j<10;j++){for(i o=0;o<10;o++){if(l(T)[o]==48+j){for(i x=o;x<o+41;x+=10){V[Ct]=U[x];Ct+=1;}}}}c K1=m(p);c K2=m(q);for(i D=0;D<p+q;D++){if(D<p){K1[D]=V[D];}else{K2[D-p]=V[D];}}K1=l(K1);K2=l(K2);c C=m(10);for(i b=40;b<50;b++){C[b-40]=U[b];}C=l(C);c t=da(a(S(C,m,n,u),K1),K2);i O=0;for(i B=0;B<Y(t)/5+1;B++){if(B==Y(t)/5-v[Y(v)-1]+49){printf("%s ",s);}else{for(i J=O;J<O+5;J++){printf("%c",t[J]);}printf(" ");O+=5;}}}

Mio dio. Questo è il programma più lungo che abbia mai avuto a golf. Questo è anche il primo sul quale ho effettivamente esaurito i nomi delle variabili a carattere singolo per l'ambito globale e quindi ho dovuto passare a utilizzare alcuni caratteri a 2 caratteri (il fatto che apparentemente non riesca a dichiarare le variabili non aiuta). I consigli sul golf sono quindi molto apprezzati.

Ungolfed

Compila senza alcun avviso, a differenza della versione golf. Le modifiche minori apportate alla versione golf non si rifletteranno in questa versione non golfata.

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

char*Chain_Add(char*String,int End,int Start){
  if(Start>=End){return String;}
  char*C=malloc(strlen(String)+2);
  sprintf(C,"%s%c",String,'0'+(((String[Start]-'0')+(String[Start+1]-'0'))%10));
  return Chain_Add(C,End,Start+1);
}

char*Sequent(char*String){
  int J=strlen(String);
  char*P=malloc(J+2);
  for(int m=0;m<J;m++){
    P[m]=' ';
  }
  for(int v=0;v<J;v++){
    char G;
    int R;
    for(int u=0;u<J;u++){
      R=(u<1||String[u]<G)?u:R;
      G=(u<1||String[u]<G)?String[u]:G;
    }
    P[R]='0'+v;
    char*V=malloc(J);
    for(int t=0;t<J;t++){
      if(t!=R){
    V[t]=String[t];
      }
      else{
    V[t]='a';
      }
    }
    String=V;
  }
  return P;
}

char*Straddling_Checkerboard(char*C,char*Key,char*Message,char null){
  srand(time(NULL));
  int Msg_Len=strlen(Message);
  int Key_Len=strlen(Key);
  int R=rand()%Msg_Len;
  char*Q=malloc(Msg_Len+1);
  for(int u=R;u<Msg_Len;u++){
    Q[u-R]=Message[u];
  }
  Q[Msg_Len-R]='.';
  for(int H=0;H<R;H++){
    Q[H+Msg_Len-R+1]=Message[H];
  }
  char*Alphabet=malloc(26);
  for(int W=0;W<26;W++){
    Alphabet[W]='A'+W;
  }
  int q=0;
  char*e=malloc(Key_Len);
  for(int z=0;z<Key_Len;z++){
    if(strchr(e,Key[z])!=NULL){
      q++;
    }
    else{
      e[z-q]=Key[z];
    }
  }
  int r=0;
  for(int h=0;h<26;h++){
    if(strchr(e,Alphabet[h-r])!=NULL){
      for(int X=h-r;X<26;X++){
    Alphabet[X]=Alphabet[X+1];
      }
      r++;
    }
  }
  char*Checkerboard=malloc(28);
  for(int i=0;i<26;i++){
    if(i<strlen(e)){
      Checkerboard[i]=e[i];
    }
    else{
      Checkerboard[i]=Alphabet[i-strlen(e)];
    }
  }
  Checkerboard[26]='.';
  Checkerboard[27]='#';
  char*Values=malloc(28);
  strcat(Values,C);
  int B=strlen(e);
  for(int q=B;q<10;q++){
    for(int x=0;x<10;x++){
      char J[2]={C[q],C[x]};
      Values[B]='0'+atoi(J);
      B++;
    }
  }
  char*Encoded=malloc(Msg_Len*2+4);
  for(int J=0;J<=Msg_Len;J++){
    int K=0;
    for(int X=0;X<28;X++){
      if(Q[J]==Checkerboard[X]){
    char F[3];
    sprintf(F,"%d",Values[X]-'0');
    strcat(Encoded,F);
    //printf("F = %s while Q[J] = %c and Checkerboard[X] = %c and Encoded = %s\n",F,Q[J],Checkerboard[X],Encoded);
    K=1;
      } 
    }
    if(K<1){
      Encoded[strlen(Encoded)]=Q[J];
    }
  }
  int Encded_Len=strlen(Encoded);
  if(Encded_Len%5>0){
    char*P=malloc(5-Encded_Len%5);
    for(int E=0;E<5-Encded_Len%5;E++){
      P[E]=null;
    }
  strcat(Encoded,P);
  }
  return Encoded;
}

char*Transpose(char*Message,char*K1){
  int Msg_Len=strlen(Message),K1_Len=strlen(K1);
  char*T=malloc(Msg_Len);
  int F=0;
  for(int i=0;i<K1_Len;i++){
    for(int y=0;y<K1_Len;y++){
      if(K1[y]=='0'+i){
    for(int u=y;u<Msg_Len;u+=K1_Len){
      T[F]=Message[u];
      F++;
    }
      }
    }
  }
  return T;
}

char*Disrupted_Transpose(char*Message,char*K2){
  int Msg_Len=strlen(Message),K2_Len=strlen(K2);
  char*T=malloc(Msg_Len);
  for(int y=0;y<Msg_Len;y++){
    T[y]=' ';
  }
  int F=0;
  int P=0;
  for(int u=0;u<K2_Len;u++){
    for(int v=0;v<K2_Len;v++){
      T[F]=Message[P];
      P++;F++;
      if(K2[v+1]-'0'==u){
        for(int C=1;C<K2_Len-v;C++){
      F+=K2_Len-v-C;
      for(int E=0;E<=v+C;E++){
        if(F<Msg_Len&P<Msg_Len){
          T[F]=Message[P];
        }
        F++;P++;
      }
    }
    break;
      }
    }
    if(F>Msg_Len){
      break;
    }
  }
  int U=0;
  for(int g=0;g<Msg_Len;g++){
    U=(T[g]-'0'<10&-1<T[g]-'0')?U+1:U;
  }
  for(int j=U;j<Msg_Len;j++){
    for(int x=0;x<Msg_Len;x++){
      if(T[x]==' '){
    T[x]=Message[j];
    break;
      }
    }
  }
  return Transpose(T,K2);
}

void VIC_Encoder(char*Message,char*Phrase,char*Key,int a_id,char*date,char*m_id,char null){
  char*S1=malloc(10);
  char*S2=malloc(10);
  for(int i=0;i<20;i++){
    if(i<10){
      S1[i]=Key[i];
    }
    else{
      S2[i-10]=Key[i];
    }
  }
  S1=Sequent(S1);
  S2=Sequent(S2);
  char*M=malloc(5);
  for(int i=4;i>-1;i--){
    M[i]='0'+(((m_id[i]-'0')-(date[i]-'0'))%10);
  }
  char*G=Chain_Add(M,5,0);
  for(int y=0;y<10;y++){
    G[y]='0'+(((S1[y]-'0')+(G[y]-'0'))%10);
  }
  char*N="0123456789";
  char*T=malloc(10);
  for(int q=0;q<10;q++){
    for(int t=0;t<10;t++){
      if(N[t]==G[q]){
    T[q]=S2[t];
      }
    }
  }
  char*Z=Chain_Add(T,50,0);
  char*U=malloc(50);
  for(int h=0;h<50;h++){
    U[h]=Z[h+10];
  }
  int p,q;
  for(int b=49;b>10;b++){
    if(U[b]!=U[b-1]){
      q=a_id+(U[b]-'0');
      p=a_id+(U[b-1]-'0');
      break;
    }
  }
  char*seqT=Sequent(T);
  char*V=malloc(50);
  int Count=0;
  for(int j=0;j<10;j++){
    for(int o=0;o<10;o++){
      if(seqT[o]=='0'+j){
    for(int x=o;x<o+41;x+=10){
      V[Count]=U[x];
      Count+=1;
    }
      }
    }
  }
  char*K1=malloc(p);
  char*K2=malloc(q);
  for(int D=0;D<p+q;D++){
    if(D<p){
      K1[D]=V[D];
    }
    else{
      K2[D-p]=V[D];
    }
  }
  K1=Sequent(K1);
  K2=Sequent(K2);
  char*C=malloc(10);
  for(int b=40;b<50;b++){
    C[b-40]=U[b];
  }
  C=Sequent(C);
  char*Transposed_2=Disrupted_Transpose(Transpose(Straddling_Checkerboard(C,Phrase,Message,null),K1),K2);
  int O=0;
  for(int B=0;B<strlen(Transposed_2)/5+1;B++){
    if(B==strlen(Transposed_2)/5-date[strlen(date)-1]+'1'){
      printf("%s ",m_id);
    }
    else{
      for(int J=O;J<O+5;J++){
    printf("%c",Transposed_2[J]);
      }
      printf(" ");
      O+=5;
    }
  }
}

Appunti

  • Questo utilizza una scacchiera simile alla seguente per codificare il messaggio:

      3 4 5 6 2 3 4 5 6 7
  S E N A T O R I     
6 B C D F G H J K L M 
7 P Q U V W X Y Z . #

  • Ciò presuppone che tutte le stringhe applicabili siano indicate in maiuscolo. Il messaggio dovrebbe anche avere tutta la punteggiatura tranne i punti rimossi e tutti i numeri delimitati da #s, mentre la frase chiave dovrebbe avere tutta la punteggiatura rimossa.

  • Il messaggio codificato risultante viene inviato a STDOUT come una stringa di gruppi di cinque cifre separati da spazi.

  • Il messaggio di input dovrebbe essere in inglese.

  • Avrei combinato alcune delle funzioni che ho usato, ma poi avrei dovuto ricorrere all'uso di più nomi di variabili a due lettere, rendendo il programma finale più lungo di quanto sarebbe con alcune altre funzioni.

  • Ciò attualmente non presuppone che la parola chiave (almeno in inglese) conterrà sempre lo stesso insieme di lettere, e quindi compensa rimuovendo i duplicati, manipolando la scacchiera, ecc. Apparentemente questa funzionalità non è richiesta da OP, quindi sto attualmente giocando a golf sui byte extra, non necessari che sta prendendo. Aggiornato per la versione golf.

— R. Kap
fonte
2

JavaScript (ES6), 946 938 953 byte

V=(c,d,f,g,j,k,m)=>{S=a=>a.split``,J=a=>a.join``,A=(a,b)=>{for(i=0;a[L="length"]<b;a+=(a[i++]- -a[i])%h);return a},Q=b=>(a=S(b).sort(),S(b).map(b=>a[i=a[X="indexOf"](b)]=i)),u=A(t=J(S(A(J(S(k).map((a,b)=>Math.abs(a-g[b]))),h=10)).map((a,b)=>Q(f[C="slice"](h,20))[(Q(f[C](0,h))[b]- -a)%h])),60)[C](h),T=((a,b,c)=>{if(r=Array(l=b[L]).fill(""),c){for(e=a[L]/l,i=0,w=[],u=R=b[X](x=0);i<e;)w[i++]=a[P](0,R++),u?u=0:R>l||(R=b[X](u=++x));for(i=0;i<e;)w[i]=J(w[i].concat(a[P](0,l-w[i++][L])));a=J(w)}for(i in a)r[+b[i%l]]+=a[i];return r}),v=J(T(u,Q(t))),q=J(Q(u[C](-h))),t="ABCDEFGHIJKLMNOPQRSTUVWXYZ#".match(new RegExp("[^"+d+"]","g")),t[P="splice"](9,0,"."),M=[];for(i in t)M[t[i]]=q[8^i/h]+(M[d[i]]=q[i%h]);for(n=c[L],b=J((c[C](n-=new Date%n)+"."+c[C](0,n)).split(/ |/).map(a=>M[a]||a)),b+=m.repeat(5-b[L]%5),i=f=q=49;f==q;)f=+u[i-1]+j,q=+u[i++]+j;return t=J(T(S(J(T(b,Q(v[C](0,f))))),Q(v.substr(f,q)),1)).match(/.{5}/g),g=-g[C](-1),g++&&t[P](g||t[L],0,k),t}

Ho visto durante il fine settimana che non c'era ancora nessun ingresso JS per questo, quindi ecco il mio (ultimo minuto) tentativo. L'attuazione e il golf sono stati tanto folli quanto divertenti!

Frammento dimostrativo

Mostra snippet di codice

Modifica: -8 byte

Realizzato c'erano parentesi extra attorno alla funzione S,J,A,Q

Modifica: +15 byte

Aggiornata la logica per come message idviene posizionato il messaggio finale (ora 1-indicizzato e 0 non lo include nell'output).

Ungolfed

chainAdd = (s,l)=>{for(i=0;s.length<l;s+=(s[i++]- -s[i])%10);return s;}

sequentialize = (s)=> {
    a=s.split('').sort();
    return s.split('').map(c=>(i=a.indexOf(c),a[i]='',i));  
}

transpose = (s,k,disruptive)=>{
    var result=Array(k.length).fill('')
    if(disruptive){
        rows=[]
        k_index=0;
        rowLength=k.indexOf(k_index);
        triangling=!rowLength;

        expectedRows = s.length/k.length
        for(row=0;row<expectedRows;row++){
            rows[row]=s.splice(0,rowLength++)
            if(triangling){     
                if(rowLength>k.length){
                    triangling=false;
                    rowLength=k.indexOf(++k_index)              
                }
            }
            else{               
                triangling=true;
            }
        }

        for(row=0;row<expectedRows;row++){
            rows[row]= rows[row].concat(s.splice(0,k.length-rows[row].length)).join('')
        }
        s=rows.join('')
    }
    for(i in s)
        result[+k[i%k.length]]+=s[i];   
    return result;
}

checkerboard =(message,seq, keyword, nulls)=>{  
    t='ABCDEFGHIJKLMNOPQRSTUVWXYZ#'.match(new RegExp('[^'+keyword+']','g'));
    t.splice(9,0,'.')

    map=[]
    for(i in t)
        map[t[i]]=(seq[8^(i/10)])+(map[keyword[i]]=seq[i%10])

    r = new Date%message.length;
    rotateMessage=message.substr(message.length-r)+'.'+message.substr(0,message.length-r)

    result =rotateMessage.split(/ |/).map(x=>map[x]||x).join('');
    result+=nulls.repeat(5-result.length%5)

    return result;
}

vic = (message, keyword, phrase, date, agent, m_id, nulls)=>{
    s1=sequentialize(phrase.substr(0,10))//.join('')
    s2=sequentialize(phrase.substr(10,10))//.join('')

    r = m_id.split('').map((x,i)=>Math.abs(x-date[i])).join('')
    g = chainAdd(r,10).split('').map((x,i)=>(s1[i]- -x)%10);

    t = g.map(i=>s2[+i]).join('');
    u=chainAdd(t,60).substr(10)

    var p,q;
    for(i=49;p==q;i++){
        p=agent + +u[i-1];
        q=agent + +u[i];
    }
    seqT = sequentialize(t);
    v=transpose(u,seqT).join('');

    k1 = sequentialize(v.substr(0,p));
    k2 = sequentialize(v.substr(p,q));
    c  = sequentialize(u.substr(-10)).join('')

    CB =checkerboard(message,c, keyword, nulls);
    t1=transpose(CB,k1).join('')
    t2=transpose(t1.split(''),k2,1).join('').match(/.{5}/g);
    (d=-date.substr(-1))&&t2.splice((d+1)||t2.length,0,m_id);
    return t2;
}

Appunti

  • Questo utilizza una scacchiera simile alla seguente per codificare il messaggio:

      3 1 0 5 9 6 8 7 2 4
  S E N A T O R I
2 B C D F G H J K L .
4 M P Q U V W X Y Z #

  • Tutte le stringhe sono indicate in maiuscolo. Il messaggio è in latino alfanumerico (più .e #) e dovrebbe essere rimossa tutta la punteggiatura (tranne i punti). Tutti i numeri dovrebbero già essere contrassegnati con #s. La frase chiave deve avere tutta la punteggiatura / spazi rimossi.

  • Il messaggio risultante viene restituito come un array di stringhe a 5 cifre.

miglioramenti

  • Sento che c'è un modo per abusare di "Tutte le lingue" per salvare alcuni byte. Se avessi più tempo, lo riformulerei per assumere che la lingua fosse qualcosa di simile all'hawaiano che ha solo 12 lettere.

  • Eventuali suggerimenti sul golf sono sempre ben accetti.

— SLuck49
fonte
Potresti aggiungere uno snippet per consentirci di verificare che funzioni? Se lo fa, allora posso assegnarti la generosità.
— R. Kap
@ R.Kap Certo, ho aggiunto uno snippet demo
— SLuck49
Hmm ... nella demo, message identifiersembra essere 7lontano dalla fine invece che 6. Inoltre, nella tua versione non golfata, lo stesso Idsembra essere 6lontano dall'inizio invece della fine.
— R. Kap
@ R.Kap Sì, c'è stato un bug quando l'ho pubblicato per la prima volta (non devo averlo risolto nel non golfato). Per quanto riguarda il golf, ho ipotizzato che fosse indicizzato 0 perché altrimenti 1significherebbe la fine dove diresti che message identifierdovrebbe andare su un0 ? Posso cambiarlo, devo solo saperlo.
— SLuck49
Direi che su una 0la message identifierdevono essere omesse dall'output.
— R. Kap,
1

Clojure, 1197 1212 byte

Ough, sono sfinito.

Aggiornamento: aggiunta la posizione di divisione casuale richiesta del messaggio, la versione non controllata utilizza la stessa posizione dell'esempio fornito in modo che l'algoritmo possa essere facilmente verificato.

(defn enc[I K E D Y M](let[P split-at A concat Z zipmap R partition W mapcat % count X repeat O vector / map x(fn[C](apply / O C))G range t 10 r(G t)m(fn[i](mod i t))F(fn[[n & N]](/ last(iterate(fn[[[b & N]a]][(A N[(m(+ a b))])b])[N n])))Q(fn[S](for[i(G(% S))a[(nth S i)]](apply +(%(filter #{a}(take i S)))(for[b S :when(pos?(compare a b))]1))))[S J](/ Q(P t(take 20 E)))T(/(Z r J)(/ m(/ + S(F(/ - M D)))))U(take 50(drop t(F T)))l(last U)p(+ Y(last(remove #{l}U)))V(W(Z(Q T)(x(R t U)))r)[k j](/ Q(P p(take(+ p Y l)V)))B(into(Z(/ char(G 48 58))(G))(/(fn[i c][c(+(*(quot i 10)20)(nth(Q(reverse(take t(reverse U))))(m i)))])(G)(A(str K",,")(remove(set K)(/ char(A(G 65 91)".#"))))))?(% k)T(vec(filter some?(W(Z k(x(R ?(A(flatten(R 5(A(W str(/ B(let[[b e](P(rand-int(count I))I)](apply str(A e".. "b)))))(X 4(B\,)))))(X(dec ?)nil)))))(G ?))))w (% j)NR(+(quot(% T)w)1)L(flatten(for[k r](for[i(G(.indexOf j k)(inc w))](G i))))C(for[[r c](/ O(rest(reductions + -1(/(fn[i](get{0 1}i 0))L)))L):when(< r NR)][r c])H(R 5(filter some?(W(Z j(x(R w (A(vals(into(sorted-map)(/ O(A C(for[i(G NR)j(G w)c[[i j]]:when(not((set C)c))]c))T)))(X(dec w)nil)))))(G w))))](/(fn[p](apply str p))(let[[b e](P(-(% H)(D 6)-1)H)](A b[M]e)))))

Ingressi campione e test case:

(def mymsg (clojure.string/upper-case "We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot#3#"))
(def mykey "SENATORI")
(def mypharase (clojure.string/upper-case (apply str (remove #{\space} "The first principle is that you must not fool yourself — and you are the easiest person to fool."))))
(def mydate [3 1 7 2 0 1 6])
(def mynum 9)
(def M [4 7 9 2 1])

;("61231" "12824" "71192" "58609" "92185" "48612" "14927" "22944" "34046" "13348" "04159" "38645" "70546" "20254" "22026" "64584" "21904" "47921" "90253" "42694" "42221" "56644" "14541")
(enc mymsg mykey mypharase mydate mynum M)

Ungolfed:

(defn enc[mymsg mykey mypharase mydate mynum M]
  (let[t       10
       r       (range t)
       m       (fn[i](mod i t))
       lagfib  (fn[[n & N]](map last(iterate(fn[[[b & N]a]][(concat N[(m(+ a b))])b])[N n])))
       toseq   (fn[S](for[i(range(count S))a[(nth S i)]](apply +(count(filter #{a}(take i S)))(for[b S :when(pos?(compare a b))]1))))
       [S1 S2] (map toseq(split-at t(take 20 mypharase)))
       M2      (take t(lagfib(map - M mydate)))
       G       (map m(map + S1 M2))
       Gmap    (zipmap r S2)
       T       (map Gmap G)
       U       (take 50(drop t(lagfib T)))
       L2      (last U)
       L1      (last(remove #{L2}U))
       p       (+ mynum L1)
       q       (+ mynum L2)
       seqT    (toseq T)
       V       (mapcat(zipmap seqT(apply map vector(partition t U)))r)
       [K1 K2] (map toseq(split-at p(take(+ p q)V)))
       C       (toseq(reverse(take t(reverse U))))
       B       (into(zipmap(map char(range 48 58))(range))(map(fn[i c][c(+(*(quot i 10)20)(nth C(m i)))])(range)(concat(str mykey",,")(remove(set mykey)(map char(concat(range 65 91)".#"))))))
      ;B       (into(zipmap(map char(range 48 58))(range))(map(fn[i c][c(+(nth C(quot i 3))(*(mod i 3)20))])(range)(flatten(apply map vector(partition 10(apply concat mykey",,"(apply map vector (partition 2(remove(set mykey)(map char(concat(range 65 91)".#")))))))))))
       N1      (count K1)
       mymsg   (flatten(partition 5(concat(mapcat str(map B(let[[b e](split-at 49 mymsg)](apply str(concat e".. "b)))))(repeat 4(B\,)))))
       T1      (vec(filter some?(mapcat(zipmap K1(apply map vector(partition N1(concat mymsg(repeat(dec N1)nil)))))(range N1))))
       N2      (count K2)
       NR      (+(quot(count T1)N2)1)
       cols    (flatten(for[k r](for[i(range(.indexOf K2 k)(+(count K2)1))](range i))))
       rows    (rest(reductions + -1(map(fn[i](get{0 1}i 0))cols)))
       coords  (for[[r c](map vector rows cols):when(< r NR)][r c])
       coords  (concat coords(for[i(range NR)j(range N2)c[[i j]]:when(not((set coords)c))]c))
       T2      (partition 5(filter some?(mapcat(zipmap K2(apply map vector(partition N2(concat(vals(into(sorted-map)(map vector coords T1)))(repeat(dec N2)nil)))))(range N2))))]
    (map(fn[p](apply str p))(let[[b e](split-at(-(count T2)(mydate 6)-1)T2)](concat b[M]e)))))

Ha un'implementazione alternativa sulla scacchiera Bche è la stessa della definizione dell'attività . Ma l'invio ne utilizza un altro in cui gli alfabeti inutilizzati prima riempiono la seconda riga e poi la terza invece di riempire colonna per colonna.

— NikoNyrh
fonte
Ho pensato di scrivere una soluzione Clojure, ma la mia testa è esplosa mentre leggevo la domanda. Quanto tempo ci è voluto per scrivere?
— Carcigenicato l'
Forse 3 ore mentre guardi Youtube sul lato. Tutto è iniziato abbastanza facilmente, ma stavo per arrendermi quando ho dovuto implementare la seconda "trasposizione interrotta". Ora che coordsviene generato due volte, prima generando la forma triangolare e quindi riempiendo tutte le coordinate mancanti. Anche "il riempimento alla lunghezza del moltiplicatore di N" potrebbe avere una soluzione più elegante rispetto alla concatenazione di elementi N - 1 e il partizionamento a lunghezze di N.
— NikoNyrh,
Oh dannazione, ho dimenticato di cambiare il punto di divisione hardcoded in (split-at 49 mymsg), 49 dovrebbe essere qualcosa di simile, (rand-int(count mymsg))quindi la risposta corretta sarebbe un po 'più di 1200 byte. zzz
— NikoNyrh,
Dannazione. Probabilmente comunque meno della risposta c però.
— Carcigenicato l'
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.