VIC 암호 인코더 작성

18

그만큼 VIC 암호는 지금까지 고안된 가장 복잡 연필과 종이 암호 중 하나입니다. 코드 명 "VICTOR"인 소련 스파이 Reino Häyhänen이 1950 년대에 사용했던 주요 원칙은 난독 화를 통한 보안입니다. 많은 난독의.

당신의 임무는 메시지를 받아 VIC 암호를 사용하여 인코딩 할 프로그램이나 함수를 작성하는 것입니다. 나는 또한 여기에 VIC 암호 디코더 챌린지를 게시했습니다 . 다음 지시 사항이 명확하지 않은 경우 주저하지 말고 의견을 제시하십시오. 지침은 이 사이트에서 적용됩니다 .

VIC 암호 인코딩

예비

다섯 개의 입력이 필요합니다 :

  • 평문 메시지
  • 귀하의 언어에서 가장 일반적인 글자를 포함하는 짧은 키워드 또는 문구
  • 따옴표 나 노래의 줄과 같은 핵심 문구 (최소 20 자)
  • 날짜 (또는 6 자리 이상의 다른 숫자)
  • 개인 상담원 번호

실제로,이 마지막 네 개는 발신자 또는 수신자의 에이전트 번호가 인코딩에 사용되는지 여부를 포함하여 발신자와 수신자가 미리 합의해야합니다.

내 메시지 예는 다음과 같습니다. We are discovered. Take what you can. Burn everything else. Move to Safehouse Foxtrot 3.

우리는 영어로 인코딩 할 것입니다 (원하는 언어와 알파벳을 사용할 수는 있지만) A, E, I, N, O, R, S, T. 영어 알파벳에서 가장 일반적인 글자는 입니다. 키워드를 사용하겠습니다SENATORI .

저의 주요 문구는 Richard Feynman의 인용입니다. "첫 번째 원칙은 당신이 스스로를 속이지 않아야한다는 것입니다. 그리고 당신은 가장 쉬운 사람입니다."

날짜로 2016 년 7 월 31 일을 형식으로 사용합니다 3172016 )을 사용합니다.이 설명은이 설명을 쓴 날입니다.

내가 선택한 개인 번호는 9입니다.

단계 요약

  1. 다음 단계에서 사용할 중간 키를 파생하십시오.
  2. 스 트래들 링 바둑판을 구성하고 적용하십시오.
  3. 첫 번째 조옮김 테이블을 구성하고 적용하십시오.
  4. 두 번째 (중단 된) 전치 테이블을 구성하고 적용하십시오.
  5. 메시지 표시기 그룹을 삽입하여 메시지를 마무리하십시오.

서브 메커니즘

우리가 문제의 고기에 들어가기 전에 설명해야 할 두 가지 : 연쇄 추가 및 연속 과정.

지연 피보나치 생성기라고도하는 체인 추가는 시작 숫자 시퀀스를 수행하고, 캐리지없이 처음 두 자리 숫자를 더한 다음 (함께 추가 한 다음 mod 10) 결과를 끝에 추가합니다. 예를 들면 다음과 같습니다.

79081
7 + 9 = 6

790816
9 + 0 = 9

7908169
0 + 8 = 8

79081698
8 + 1 = 9

790816989
1 + 6 = 7

7908169897
... and so on

순차 화는 본질적으로 일련의 문자 또는 숫자를 취하여 알파벳 / 숫자 순서로 레이블을 지정합니다. 중복은 왼쪽에서 오른쪽으로 표시됩니다. 예를 들면 다음과 같습니다.

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

여기서는 제로 인덱싱을 사용하지만 원하는 인덱스를 사용하십시오.

1. 중간 키

(10)의 두 그룹으로 키 구문의 처음 20 개 문자를 분할하고 우리가 호출하는, 개별적으로 각각 sequentialize S1하고 S2.

    THEFIRSTPR
S1: 8201357946

    INCIPLEIST
S2: 2603751489

임의의 5 자리 메시지 식별자를 선택하십시오 M(원하는 경우 입력 중 하나 일 수 있음).

M = 47921

(빼기 차입하지 않고, 빼기 mod 10) 키 날짜의 처음 다섯 자리 3172016에서를 M:

M      47921
date - 31720
     = 16201

체인은 10 자리가 될 때까지 결과를 추가합니다 :

1620178218

이러한 숫자를 추가 S1운반하거나하지 않고 mod 10, 얻을 G:

     1620178218
S1 + 8201357946
G  = 9821425154

위 S2의 순서 0123456789를 작성하십시오. 순서 0123456789에서 각 숫자를 찾아서 G바로 아래의 숫자로 바꾸십시오 S2. 결과는 T입니다.

   0123456789
S2 2603751489

G  9821425154
T  9806705657

체인 추가를 사용 T하여 60 자리 로 확장하십시오 .

9806705657

becomes

980670565778637511245490262369939288595822106344304316978734

이 마지막 50 자리 숫자 (각 10 자리 숫자의 5 행)가 U블록을 형성합니다 .

T  9806705657
U  7863751124
   5490262369
   9392885958
   2210634430
   4316978734

U블록 의 마지막 두 자리수가 아닌 숫자 는 개별적으로 에이전트의 개인 번호에 추가되어 두 전치의 너비를 제공합니다.p 하고 q.

9 + 3 = 12 (p, 첫 번째 전치 너비) 9 + 4 = 13 (q, 두 번째 전치 너비)

T이 시퀀스를 순차적 으로 사용하여 U블록 의 열을 위에서 아래로 새 자릿수 행으로 복사하십시오 V.

T     9806705657
seqT  9804612537

U     7863751124
      5490262369
      9392885958
      2210634430
      4316978734

V     69911 56837 12548 26533 30206 13947 72869 49804 84323 75924

첫 번째 p숫자를 순차적으로 변환하여 첫 번째 조옮김의 키를 얻고 K1다음 q숫자는 두 번째 키 를 얻습니다 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

마지막으로, 스 트래들 링 바둑판의 열 헤더 U를 얻기 위해 블록 의 마지막 행을 순차적으로 지정하십시오 C.

U5  4316978734
C   3105968724

2. 스 트래들 링 체커 보드

먼저, 체커 보드 예제를 제공 한 다음이를 생성하는 원리를 설명하겠습니다.

  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 #

첫 글자는 짧은 키워드 SENATORI입니다. 키워드는 중복되지 않은 문자열 일 수 있지만 바둑판의 맨 위 행을 정의하므로 현명하게 선택하십시오. 키워드 위에는가 있고 C다른 행은 원하는 순서대로 알파벳의 나머지 부분입니다. 필자의 경우, 나머지 라틴 알파벳, 문장 부호 .및 숫자 구분 기호로 바둑판을 채웠다 #. 기본적으로 바둑판은 멋진 대체 암호입니다. 예를 들어 "E"는로 대체 1되고 "W"는로 대체됩니다27 .

이 바둑판으로 일반 텍스트 메시지를 인코딩 한 후에는 먼저 임의의 위치에서 메시지를 나누고 모두 대문자로 만들어 메시지의 시작 부분을 덜 분명하게 만들어야합니다. 다른 원래 시작을 나타 내기 위해 두 개의 완전 정지를 사용합니다..

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

된다

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

우리는 바둑판으로 인코딩하여 다음을 제공합니다.

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

메시지 길이를 5로 나눌 수없는 경우 메시지를 채울 몇 가지 null 문자를 추가합니다. 우리 메시지는 109 자리 숫자이므로 "4"라는 하나의 null을 추가합니다.

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

참고 : 예제 메시지에는 숫자가 포함되어 있지 않으므로 여기에서 #3#인코딩 된 것으로 지정할 수 44344있습니다.

3. 첫 번째 조옮김

K1(중간 키 섹션에서) 기록한 다음 이전 단계의 인코딩 된 메시지를 키 아래에 같은 길이의 행으로 작성하여 전치 테이블을 작성 하십시오.

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

숫자 순서대로 숫자 열을 가져 와서 다음을 얻습니다.

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

4. 두 번째 조옮김

첫 번째 조옮김은 비교적 간단했습니다. 그러나 이것은 혼란스러운 전치입니다. 중단 패턴은 테이블 너비와 키에 의해 결정됩니다. 이 예에서 우리는 110 자리 숫자와 13 자리 열을가집니다. 즉, 전체 행 8 개와 남은 부분 6 개가 있습니다. 첫 번째 행을 채우기 시작하지만 열 0에서 멈추고 다음과 같이 계속하십시오.

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

그런 다음 마지막 몇 칸을 나머지 숫자로 채 웁니다.

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

이제 첫 번째 조옮김에서와 똑같은 방식으로 열을 읽습니다.

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

그리고 모든 것을 5 자리 그룹으로 나눕니다.

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

5. 메시지 마무리

마지막 단계는 임의의 메시지 식별자를 47921메시지 자체에 삽입하는 것입니다. 주요 날짜의 마지막 숫자 6는 그룹이 끝까지의 거리를 나타냅니다.

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

이 도전에 대한 메모

  • 메시지, 문자 키워드, 키워드, 날짜 및 개인 번호 등 최소 5 개의 입력이 제공됩니다. 임의의 메시지 식별자와 메시지를 채우는 데 필요한 널 (null) 인 두 개의 추가 입력을 포함 할 수 있습니다. 그렇지 않으면 함수가 자체적으로 임의의 숫자를 생성 할 수 있습니다.
  • 올바른 숫자와 문자 수 (5 자리 메시지 식별자, 키 구문의 경우 최소 20 자리 등)와 함께 모든 입력이 유효하다고 가정 할 수 있습니다. 문자열 (메시지 및 키워드)에 버전에서 허용 된 문자열을 제외한 모든 구두점과 공백이 이미 제거되었으며 숫자에 이미 숫자가 표시되어 있다고 가정 할 수 있습니다.
  • 첫 번째 키워드에는 중복 문자가 없어야하며 코드에서는 중복 문자가 없다고 가정 할 수 있습니다.
  • 인코딩하는 데 사용하는 언어는 언어가 이미 존재하고 알파벳이 이미 존재하고 응답에 사용할 언어를 지정하는 한 중요하지 않습니다.
  • 스 트래들 링 바둑판에 어떤 알파벳을 사용하든, 바둑판을 채우기 위해 기호를 추가하거나 제거 할 수 있습니다. 사용하는 기호를 지정하십시오 (예 : 문장 부호, 별도의 "메시지 시작"기호, 일반적인 단어 기호). 숫자 기호가 다른 것을위한 슬롯을 사용하여 숫자 기호를 완전히 버리고 숫자를 철자하거나 바둑판에 각 숫자를 포함시킬 수 있습니다. 답변에 사용한 바둑판을 지정하십시오.
  • 출력은 공백으로 구분 된 5 자리 그룹 문자열, 5 자리 정수 목록 또는 이와 유사한 형식이어야합니다.
  • 제로 인덱싱과 0123456789예제를 사용했습니다. 사용한 것을 지정하면 1- 인덱싱 및 1234567890또는 다른 시스템을 사용할 수 있습니다.

다음은 Ideone의 구현 예입니다. 입니다.

이 글은 긴 글이며 수작업으로 작성 했으므로이 글에 혼란스러운 부분이 있거나 계산 및 조옮김에 오류가있는 경우 알려주십시오. 행운과 좋은 골프!

code-golf  cryptography 
— 셜록 9
소스
1
adding the first two digits without adding운반을 의미합니까?
— isaacg
@isaacg 그렇습니다. 편집했습니다.
— Sherlock9
당신은 당신이 무슨 뜻인지에 명확히 수 without borrowing와 without carrying? 당신에게 평균 추가 및 빼기 모드 수행 10, 즉 (6+7) mod 10 = 3와 (6-8) mod 10 = 8?
— R. Kap
@ R.Kap 그래, 명확히 해줄 게.
— Sherlock9
우리합니까 가 구별 번호?
— R. Kap

답변:

10

Python 3 , 1423 1348 1324 1316 1300 1286 1250 1249 1209 1206 1204 바이트

이것은 내가 지금까지 해 본 것 중 가장 긴 골프이며, 한 문자 변수 이름이 부족하다고 심각하게 걱정 한 유일한 골프입니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

나는 추가 문자를 대문자 라틴 알파벳으로 인코딩하고있어 .하고 #, 0 인덱싱을 사용하여 0123456789변환 할 때 g에 t. 내 바둑판은 다음 예제와 유사한 형식입니다.

  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

편집하다: TuukkaX의 제안 덕분에 -63 바이트는 한 글자 변수로 자주 사용되는 일부 기능을 단축시킵니다. -12 바이트 만들기a, g, t더 작게 .

편집 : 한 번만 사용되는 중간 키의 변수 이름을 제거하여 -24 바이트를 만듭니다.a, g, s, S, k, K .

편집 : -74 바이트 통합H(), T() and C() .

편집 : -1 변화의 자신의 제안에 대한 닉 A와 바이트 덕분 ord(s[i])+ord(s[i+1])에 sum(map(ord,s[i:i+2])). 2 번의 +=[a]호출을 에서 -2 바이트를 변경 했습니다 +=a,. 어떻게 변화에서 -13 바이트 G()의 최소의 인덱스를 발견 s. -2 바이트가에서 (으)로 변경 y=(y+1)%v되었습니다 y=-~y%v. 에 -15 바이트를 할당 k.index()했습니다 K. 에 -4 바이트를 할당 10했습니다 W. 할당에서 -5 바이트1-I(d[-1]) 로 X내부 V. C()메인 루프 재 작성에서 -3 바이트 재구성에서 -2 바이트 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:])

풀기 :

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:])
— 셜록 9
소스
2
파이썬 3은 유니 코드 문자를 변수 FYI로 허용합니다.
— Paul
로 변경하면 내가 믿는 한 문자 ord(seq[i])+ord(seq[i+1])가 sum(map(ord,seq[i:i+2]))저장됩니다.
3

C, 2880 2769 2766 2762 2743 2741 2739 2699 2458 바이트

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

이럴수가. 이것은 내가 골프를 본 적이 있는 가장 긴 프로그램 입니다. 이것은 또한 실제로 전역 범위에 대한 단일 문자 변수 이름이 부족한 첫 번째 문자이므로 몇 문자를 사용하여 이동해야했습니다 (변수를 다시 선언 할 수 없다는 사실은 도움이되지 않습니다). 골프 팁은 매우 높이 평가됩니다.

언 골프

골프 버전과 달리 경고없이 컴파일합니다. 골프 버전에 대한 사소한 변경 사항은이 골프 용 버전에 반영되지 않습니다.

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

노트

  • 다음과 유사한 바둑판을 사용하여 메시지를 인코딩합니다.

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

  • 이는 적용 가능한 모든 문자열이 대문자로 제공된다고 가정합니다. 메시지에는 마침표를 제거하고 #s로 구분 된 모든 숫자를 제외한 모든 문장 부호가 있어야 하며, 핵심 문구는 모든 문장 부호를 제거 해야합니다 .

  • 결과 인코딩 된 메시지는 공백으로 구분 된 5 자리 그룹의 문자열로 STDOUT에 출력됩니다.

  • 입력 메시지는 영어로 작성해야합니다.

  • 필자가 사용한 몇 가지 기능을 결합했지만 더 많은 2 글자 변수 이름을 사용하여 최종 프로그램을 몇 가지 기능보다 더 길게 만들어야했습니다.

  • 현재 키워드 (최소한 영어로 된)에 항상 동일한 문자 집합이 포함되어 있다고 가정 하지 않으므로 중복을 제거하고 바둑판을 조작하는 등의 방법으로이를 보완 할 수 있습니다.이 기능은 OP, 그래서 현재 여분의 불필요한 바이트를 차지하고 있습니다. 골프 버전으로 업데이트되었습니다.

— R. 캅
소스
2

자바 스크립트 (ES6), 946 938 953 바이트

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}

주말에 아직 JS 항목이 없다는 것을 알았으므로 여기에 마지막 순간이 있습니다. 이것을 구현하고 골프를 타는 것은 그것이 재미 있었던 것처럼 미쳤다!

데모 스 니펫

코드 스 니펫 표시

편집 : -8 바이트

기능 주위에 추가 괄호가 있음을 인식했습니다. S,J,A,Q

편집 : +15 바이트

방법에 대한 논리를 업데이트 message id최종 메시지에 배치 (현재 1- 인덱싱되며 0은 출력에 포함되지 않음).

언 골프

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

노트

  • 다음과 유사한 바둑판을 사용하여 메시지를 인코딩합니다.

      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 #

  • 모든 문자열은 대문자로 제공됩니다. 메시지는 영숫자 라틴어 (플러스 .및 #)이며 구두점 (마침표 제외)을 모두 제거해야합니다. 모든 숫자는 이미 #s 로 표시되어 있어야합니다 . 핵심 문구는 구두점 / 공백을 모두 제거해야합니다.

  • 결과 메시지는 5 자리 문자열의 배열로 반환됩니다.

향상

  • 바이트를 절약하기 위해 "모든 언어"를 남용하는 방법이 있다고 생각합니다. 더 많은 시간을 보낸다면 언어가 하 와이어와 비슷한 12 자 밖에되지 않는 언어라고 생각합니다.

  • 골프 제안은 언제나 환영합니다.

— SLuck49
소스
이것이 작동하는지 확인할 수 있도록 스 니펫을 추가해 주시겠습니까? 그렇다면 현상금을 수여 할 수 있습니다.
— R. Kap
@ R.Kap 물론, 데모 스 니펫을 추가했습니다
— SLuck49
흠 ... 데모에서, 대신에 끝에서 떨어져 있는 message identifier것 같습니다 . 또한, 귀하의 ungolfed 버전에서 동일한는 것 같다 으로부터 멀리 시작 대신 말. 76Id6
— R. Kap
@ R.Kap 그래, 내가 처음 게시했을 때 버그가있었습니다. 골프에 관해서는, 나는 인덱스가 0 인 것으로 가정했습니다. 그렇지 않으면 1당신은 어디에서 message identifier가야 한다고 말 0하겠습니까? 내가 알아야 할 것을 바꿀 수 있습니다.
— SLuck49
나는에 그런 말 것 0가 message identifier출력에서 제외되어야한다.
— R. Kap
1

클로저, 1197 1212 바이트

오, 나는 지쳤다.

업데이트 : 메시지의 필요한 임의 분할 위치를 추가하면 ungolfed 버전은 주어진 예제와 동일한 위치를 사용하므로 알고리즘을 쉽게 확인할 수 있습니다.

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

샘플 입력 및 테스트 사례 :

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

언 골프 드 :

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

B작업 정의와 동일한 바둑판에서 대체 구현 이 있습니다. 그러나 제출에는 사용되지 않은 알파벳이 열별로 채워지지 않고 두 번째 행에 채워진 다음 세 번째에 채워지는 다른 문자가 사용됩니다.

— 니코 니르
소스
Clojure 솔루션을 작성하는 것을 고려했지만 질문을 읽는 동안 머리가 폭발했습니다. 작성하는데 시간이 얼마나 걸렸습니까?
— Carcigenicate
유튜브를봤을 때 3 시간 정도 이 작업은 아주 쉽게 시작되었지만 두 번째 "중단 된 조옮김"을 구현해야 할 때 포기했습니다. 이제 coords두 번 생성되어 먼저 삼각형 모양을 생성 한 다음 누락 된 좌표를 채 웁니다. 또한 "N의 곱셈 길이로 채우기"는 N-1 요소를 연결하고 N의 길이로 분할하는 것보다 더 우아한 솔루션을 가질 수 있습니다.
— NikoNyrh
오 젠장,에서 하드 코딩 된 스플릿 포인트를 변경하는 것을 잊어 버렸습니다 (split-at 49 mymsg).49는 (rand-int(count mymsg))정답이 1200 바이트를 약간 넘을 것입니다. zzz
— NikoNyrh
제길. 아마 c 답변보다 적을 것입니다.
— Carcigenicate
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.