Cifra trífida (sem palavra-chave)


19

Introdução:

Tenho várias cifras diferentes armazenadas em um documento que compilei quando criança, escolhi algumas que achei mais adequadas para desafios (não muito triviais e nem muito difíceis) e as transformei em desafios. A maioria deles ainda está na caixa de areia, e ainda não tenho certeza se vou postar todos eles, ou apenas alguns. Aqui está o segundo (o Computer Cipher foi o primeiro que eu postei).


Para a codificação trífida (sem usar uma palavra-chave), o alfabeto (e um curinga adicional) são divididos em três tabelas 3 por 3:

table 1:     table 2:     table 3:
 |1 2 3       |1 2 3       |1 2 3
-+-----      -+-----      -+-----
1|a b c      1|j k l      1|s t u
2|d e f      2|m n o      2|v w x
3|g h i      3|p q r      3|y z  

Um texto que queremos codificar é o primeiro caractere por caractere codificado nos números da coluna da linha da tabela. Por exemplo, o texto this is a trifid cipherse torna:

        t h i s   i s   a   t r i f i d   c i p h e r
table:  3 1 1 3 3 1 3 3 1 3 3 2 1 1 1 1 3 1 1 2 1 1 2
row:    1 3 3 1 3 3 1 3 1 3 1 3 3 2 3 2 3 1 3 3 3 2 3
column: 2 2 3 1 3 3 1 3 1 3 2 3 3 3 3 1 3 3 3 1 2 2 3

Em seguida, colocamos tudo um após o outro linha por linha na tabela acima em grupos de três:

311 331 331 332 111 131 121 121 331 331 313 133 232 313 332 322 313 313 132 333 313 331 223

E esses são transformados novamente em caracteres usando as mesmas tabelas:

s   y   y   z   a   g   d   d   y   y   u   i   q   u   z   w   u   u   h       u   y   o

Uma coisa a observar, o comprimento da entrada deve ser coprime para 3. Portanto, se o comprimento for múltiplo de 3, anexamos um ou dois espaços à direita para tornar o comprimento da entrada não mais um múltiplo 3.

Desafio:

Dada uma sequência sentence_to_encipher, codifique-a como descrito acima.

Você só precisa codificar, dado sentence_to_encipherque não há necessidade de criar um programa / função de decifração também. No entanto, eu posso fazer um desafio da parte 2 para a decifração no futuro (embora eu tenha a sensação de que é trivial / semelhante ao processo de codificação).

Regras do desafio:

  • Você pode assumir sentence_to_encipherque conterá apenas letras e espaços.
  • Você pode usar letras minúsculas ou maiúsculas completas (indique qual delas você usou na sua resposta).
  • Você pode optar por acrescentar um ou dois espaços à direita quando o comprimento da entrada for 3 para que não seja mais um múltiplo de 3.
  • A E / S é flexível. Tanto a entrada como a saída podem ser uma sequência, lista / matriz / fluxo de caracteres, etc.

Regras gerais:

  • Isso é , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
  • Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Input:            "this is a trifid cipher"
Output:           "syyzagddyyuiquzwuuh uyo"

Input:            "test"
Output:           "utbk"

Input:            "output"
Possible outputs: "rrvgivx" (one space) or "rrzcc lr" (two spaces)

Input:            "trifidcipher"
Possible output:  "vabbuxlzz utr" (one space) or "vabbyzv rx ie " (two spaces)

3
Eu li isso como "sem teclado ". Isso seria um desafio delicioso!
Cort Ammon - Reinstala Monica

1
Por que o comprimento da entrada deve ser coprime para 3? Não vejo como isso importa aqui.
Fund Monica's Lawsuit

O requisito de coprime não é necessário para fazer a cifra funcionar, mas a torna muito mais segura, garantindo que os grupos de três dígitos não estejam alinhados com as divisões de linha da lista de dígitos inicial.
21418 Sparr

@NicHartley Você está certo de que, mesmo que a entrada seja divisível por 3, você ainda pode transpor a tabela. Inicialmente, eu não tinha essa regra na Sandbox, mas alguém me disse que a Wikipedia para Trifid mostra que ela deveria adicionar um ou dois espaços para tornar a codificação um pouco mais segura. Então, eu o adicionei como parte do desafio e para torná-lo mais sincronizado com a página da Wikipedia (além da palavra-chave que removi).
Kevin Cruijssen

1
@KevinCruijssen Eu ... realmente não vejo como isso a tornaria mais segura (se for o caso, forçar a entrada a não ter um determinado comprimento a tornaria menos segura, pois você pode imaginar que o último caractere está codificando um espaço), mas concordo que manter a descrição da cifra aqui alinhada com a Wikipedia é uma boa idéia. Obrigado por explicar!
Fund Monica's Lawsuit

Respostas:


6

Geléia , 29 26 25 bytes

⁶Øa;3ṗ¤,©Ṛy;⁶$L3ḍƊ¡ZFs3®y

Experimente online!

Como funciona

⁶Øa;3ṗ¤,©Ṛy;⁶$L3ḍƊ¡ZFs3®y  Main link. Argument: s (string)

⁶                          Set the return value to space.
 Øa;                       Append it to "a...z".
    3ṗ¤                    Yield the third Cartesian power of [1, 2, 3].
       ,©                  Pair the results and store the pair in the register.
                           The register now holds
                           [[[1, 1, 1], ..., [3, 3, 3]], ['a', ... ,'z', ' '].
         Ṛ                 Reverse the outer array.
           ;⁶$             Append a space to s...
              L3ḍƊ¡        if the length is divisible by 3.
          y                Transliterate according to the mapping to the left.
                   ZFs3    Zip/transpose, flatten, split into chunks of length 3.
                       ®y  Transliterate according to the mapping in the register.

Eu nunca conheço as regras sobre saídas de efeitos colaterais ... mas o arranjo ;L3ḍƊ¡⁶µ⁶Øa;3ṗ¤,ðṚyZFs3⁸ypode acabar com o µque é aceitável para 24 anos.
Jonathan Allan

Temos um consenso fraco ( + 6 / -1 ) de que isso é permitido, então obrigado!
Dennis

A saída parece estar incorreta. Não acho que o espaço anexado "grude".
Dennis

6

Carvão , 39 bytes

≔E⁺θ× ¬﹪Lθ³⌕βιθ⭆⪪E⁺÷θ⁹⁺÷θ³θ﹪鳦³§⁺β ↨³ι

Experimente online! Link é a versão detalhada do código. Explicação:

≔               Assign
   θ            Input string
  ⁺             Concatenated with
                Literal space
    ×           Repeated
         θ      Input string
        L       Length
       ﹪        Modulo
          ³     Literal 3
      ¬         Logical not
 E              Mapped over characters
             ι  Current character
           ⌕    Position found in
            β   Lowercase alphabet
              θ To variable

     θ                      List of positions
    ÷                       Vectorised integer divide by
      ⁹                     Literal 9
   ⁺                        Concatenated with
         θ                  List of positions
        ÷                   Vectorised integer divide by
          ³                 Literal 3
       ⁺                    Concatenated with
           θ                List of positions
  E                         Map over values
             ι              Current value
            ﹪               Modulo
              ³             Literal 3
 ⪪                          Split into
                ³           Groups of 3
⭆                           Map over groups and join
                   β        Lowercase alphabet
                  ⁺         Concatenated with
                            Literal space
                 §          Cyclically indexed by
                       ι    Current group
                     ↨      Converted from
                      ³     Base 3
                            Implicitly print

6

Python 2 , 180 176 174 165 163 bytes

lambda s:''.join(chr(32+(33+a*9+3*b+c)%59)for a,b,c in zip(*[iter(sum(zip(*[(c/9,c/3%3,c%3)for c in map(o,s+' '[len(s)%3:])]),()))]*3))
o=lambda c:(ord(c)%32-1)%27

Experimente online!

A entrada pode ser superior ou inferior. Saída em maiúscula


6

Pitão, 34 33 bytes

m@+G;id3csCmtj+27x+G;d3+W!%lz3zd3

Programa completo. A entrada é esperada como minúscula, a saída é uma matriz de caracteres. Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

m@+G;id3csCmtj+27x+G;d3+W!%lz3zd3   Implicit: z=input(), d=" ", G=lowercase alphabet
                           lz       Length of z
                          %  3      The above, mod 3
                        W!          If the above != 3...
                       +      zd    ... append a space to z
           m                        Map the elements of the above, as d, using:
                  +G;                 Append a space to the lowercase alphabet
                 x   d                Find the 0-based index of d in the above
              +27                     Add 27 to the above
             j        3               Convert to base 3
            t                         Discard first element (undoes the +27, ensures result is 3 digits long)
          C                         Transpose the result of the map
         s                          Flatten
        c                       3   Split into chunks of length 3
m                                   Map the elements of the above, as d, using:
     id3                              Convert to decimal from base 3
 @+G;                                 Index the above number into the alphabet + space
                                    Implicit print

Solução alternativa de 34 bytes: sm@+G;id3csCm.[03jx+G;d3+W!%lz3zd3- em vez de +27 e cauda, ​​usa .[03preenchimento com 0 a comprimento 3. Pode ser 33 se o líder sfor descartado.

Editar: salvou um byte, largando à esquerda scomo matrizes de caracteres com saída válida


5

Ruby , 153 145 138 131 131 bytes

->a{a<<" "if a.size%3<1;a.map{|c|[(b=(c.ord%32-1)%27)/9,b%9/3,b%3]}.transpose.join.scan(/.{3}/).map{|x|((x.to_i(3)+65)%91+32).chr}}

Experimente online!

Uma abordagem rápida e ingênua, trabalha com texto em minúsculas. Entradas e saídas de matrizes de caracteres.


4

Java (JDK) , 192 bytes

s->{String T="",R=T,C=T,r=T;for(int c:s){c-=c<33?6:97;T+=c/9;R+=c%9/3;C+=c%3;}for(var S:(s.length%3<1?T+2+R+2+C+2:T+R+C).split("(?<=\\G...)"))r+=(char)((Byte.valueOf(S,3)+65)%91+32);return r;}

Experimente online!

Abordagem muito ingênua. Pega uma letra minúscula char[]como entrada, mas gera a String.

Explicações

s->{                                       // char[]-accepting lambda
 String T="",                              //  declare variables Table as an empty string,
        R=T,                               //                    Row as an empty string,
        C=T,                               //                    Column as an empty string,
        r=T;                               //                    result as an empty string.
 for(int c:s){                             //  for each character
  c-=c<33?6:97;                            //   map each letter to a number from 0 to 25, space to 26.
  T+=c/9;                                  //   append the table-value to Table
  R+=c%9/3;                                //   append the row-value to Row
  C+=c%3;                                  //   append the column-value to Column
 }                                         //
 for(var S:                                //  For each token of...
     (s.length%3<1?T+2+R+2+C+2:T+R+C)      //    a single string out of table, row and column and take the space into account if the length is not coprime to 3...
      .split("(?<=\\G...)"))               //    split every 3 characters
  r+=(char)((Byte.valueOf(S,3)+65)%91+32); //   Parses each 3-characters token into a number, using base 3,
                                           //  and make it a letter or a space
 return r;                                 //  return the result
}

Créditos


1
Dois pequenos Integer.valueOfByte.valueOfR+=c<26?(char)(c+97):' ';R+=(char)(c<26?c+97:32);
campos de


4

R , 145 bytes

function(s,K=array(c(97:122,32),rep(3,3)))intToUtf8(K[matrix(arrayInd(match(c(utf8ToInt(s),32[!nchar(s)%%3]),K),dim(K))[,3:1],,3,byrow=T)[,3:1]])

Experimente online!

E / S como cadeias; adiciona um espaço. A estranha repetição de [,3:1]é porque a indexação da matriz natural de R é um pouco diferente.


Dang, você me venceu por mais de 200 bytes. Fico sempre impressionado com a sua codificação, @ Giuseppe. Eu não deve mesmo se incomodar tentar algumas vezes
Sumner18

1
@ Sumner18 bem, obrigado! Normalmente, tento deixar passar um ou dois dias antes de responder aos desafios, já que sei que existem muitos outros jogadores de R aqui, mas não pude resistir a este porque o vi no Sandbox. Você é sempre bem-vindo para trocar idéias para jogar golfe fora de nós na sala de chat R golfe . :-)
Giuseppe

3
@ Sumner18 também não há vergonha em tentar ser breve, minha primeira submissão aqui foi horrível e só fiquei melhor! Por favor continuar a postar, eu acho que é sempre bom para obter feedback para que você possa melhorar :-)
Giuseppe

3

APL + WIN, 102 bytes

⎕av[n[c⍳(⊂[2]((⍴t),3)⍴,⍉⊃(c←⊂[2]c,(,⍉9 3⍴c←9/⍳3),[1.1]27⍴⍳3)[(⎕av[n←(97+⍳26),33])⍳t←t,(3|⍴t←⎕)↓' '])]]

Explicação:

t←t,(3|⍴t←⎕)↓' ' Prompts for input and applies coprime condition

(⎕av[n←(97+⍳26),33]⍳ Indices of characters in APL atomic vector 

c←⊂[2]c,(,⍉9 3⍴c←9/⍳3),[1.1]27⍴⍳3) Create a matrix of table, row column for 27 characters

⊂[2]((⍴t),3)⍴,⍉⊃ Extract columns of c corresponding to input and re-order

c⍳ Identify Column indices of re-ordered columns

⎕av[.....] Use indices back in atomic vector to give enciphered text  

Exemplo de captura de tela do caso de teste:

⎕av[n[c⍳(⊂[2]((⍴t),3)⍴,⍉⊃(c←⊂[2]c,(,⍉9 3⍴c←9/⍳3),[1.1]27⍴⍳3)[(⎕av[n←(97+⍳26),33])⍳t←t,(3|⍴t←⎕)↓' '])]]
⎕:
'output'
rrvgivx  

Você se importaria de adicionar uma captura de tela (um ou vários) dos casos de teste? Sei que a versão WIN APL não está disponível no TIO, mas ainda gostaria de ver algum tipo de verificação, pois mal sei como interpretar o código APL apenas lendo-o e muito menos verificando-o sem executar. :)
Kevin Cruijssen

Não tenho certeza de como fazer isso, mas é assim que seria. Vou acrescentar algo a entrada acima
Graham

Normalmente, eu posso usar o Dyalog Classic no TIO, mas nesse caso o vetor atômico está em uma ordem diferente para que a indexação não funcione.
Graham

3

SAS, 305 bytes

Um 'oof' caloroso para essa monstruosidade do SAS. Há muita formatação aleatória de strings que eu pensei que poderia evitar entrar nisso; Tenho certeza de que existem maneiras melhores de fazer isso.

data;input n:&$99.;n=tranwrd(trim(n)," ","{");if mod(length(n),3)=0then n=cats(n,'{');f=n;l=length(n);array a(999);do i=1to l;v=rank(substr(n,i,1))-97;a{i}=int(v/9);a{i+l}=mod(int(v/3),3);a{i+l*2}=mod(v,3);end;f='';do i=1to l*3by 3;f=cats(f,byte(a{i}*9+a{i+1}*3+a{i+2}+97));end;f=tranwrd(f,"{"," ");cards;

A entrada é inserida nas novas linhas após a declaração dos cartões, da seguinte forma:

data;input n:&$99.;n=tranwrd(trim(n)," ","{");if mod(length(n),3)=0then n=cats(n,'{');f=n;l=length(n);array a(999);do i=1to l;v=rank(substr(n,i,1))-97;a{i}=int(v/9);a{i+l}=mod(int(v/3),3);a{i+l*2}=mod(v,3);end;f='';do i=1to l*3by 3;f=cats(f,byte(a{i}*9+a{i+1}*3+a{i+2}+97));end;f=tranwrd(f,"{"," ");cards;
this is a trifid cipher
test
output
trifidcipher

Produz um conjunto de dados que contém a saída na variável f, junto com um monte de variáveis ​​auxiliares / valores de matriz.

insira a descrição da imagem aqui

Ungolfed / explicação:

data;
input n : & $99.; /* Read a line of input, maximum 99 characters */

n=tranwrd(trim(n)," ","{"); /* Replace spaces with '{' (this is the ASCII character following 'z', so it makes it easy to do byte conversions, and lets us not have to deal with spaces, which SAS does not like) */
if mod(length(n),3)=0then n=cats(n,'{'); /* If length of n is not coprime with 3, add an extra "space" to the end */

f=n; /* Set output = input, so that the string will have the same length */
l=length(n);    /* Get the length of the input */
array a(999);   /* Array of values to store intermediate results */

do i = 1 to l; /* For each character in the input... */
    v = rank(substr(n,i,1))-97; /* Get the value of the current character, from 0-26 */

    a{i}=int(v/9);          /* Get the table of the current character and store at appropriate index, from 0-2  */
    a{i+l}=mod(int(v/3),3); /* Get the row of the current character, from 0-2 */
    a{i+l*2}=mod(v,3);      /* Get the column of the current character, from 0-2  */
end;

f='';

do i = 1 to l*3 by 3; /* For each character in the output... */
    f=cats(f,byte(a{i}*9+a{i+1}*3+a{i+2}+97)); /* Convert values back from base 3 to base 10, and convert back into ASCII value */
end;

f = tranwrd(f,"{"," "); /* Replaces our "spaces" with actual spaces for final output */

/* Test cases */
cards;
this is a trifid cipher
test
output
trifidcipher

3

JavaScript (Node.js) ,  146 141 139  136 bytes

A E / S está em minúscula.

s=>'931'.replace(/./g,d=>Buffer(s.length%3?s:s+0).map(c=>(o=(c>48?c-16:26)/d%3+o*3%27|0,++i)%3?0:(o+97)%123||32),i=o=0).split`\0`.join``

Experimente online!

Comentado

s =>                       // s = input string
  '931'.replace(/./g, d => // for each digit d = 9, 3 and 1:
    Buffer(                //   create a buffer from:
      s.length % 3 ?       //     if the length of s is coprime with 3:
        s                  //       the original input string
      :                    //     else:
        s + 0              //       the input string + an extra '0'
    )                      //
    .map(c =>              //   for each ASCII code c from this Buffer:
      ( o =                //     update o:
        ( c > 48 ?         //       if c is neither a space nor the extra '0':
            c - 16         //         yield c - 16 (which gives 81 .. 106)
          :                //       else:
            26             //         this is the 26th character (space)
        ) / d % 3 +        //       divide by d and apply modulo 3
        o * 3 % 27 | 0,    //       add o * 3, apply modulo 27, coerce to integer
        ++i                //       increment i
      ) % 3 ?              //     if i mod 3 is not equal to 0:
        0                  //       yield 0 (NUL character)
      :                    //     else:
        (o + 97) % 123     //       convert o to the ASCII code of the output letter
        || 32              //       or force 32 (space) for the 26th character
    ),                     //   end of map()
    i = o = 0              //   start with i = o = 0
  ).split`\0`.join``       // end of replace(); remove the NUL characters

Acho que você já explicou isso antes, mas como (o=...,++i)%3funciona o JS novamente? É (o,i)uma tupla ou algo assim, e os dois inteiros internos são convertidos em seu módulo-3? Como desenvolvedor Java, ainda me confunde um pouco (a,b)%c. Boa resposta embora! Eu gosto de como você converte cada terceiro dígito e remove os dois primeiros bytes nulos. +1 de mim.
Kevin Cruijssen

2
@KevinCruijssen Citando MDN : "O operador de vírgula avalia cada um de seus operandos (da esquerda para a direita) e retorna o valor do último operando. " Portanto, o módulo é aplicado apenas a ++i.
Arnauld

3

05AB1E , 25 bytes

g3Öð׫SAð«3L3㩇ø˜3ô®Að«‡

Como ninguém postou uma resposta 05AB1E ainda, achei que publicaria minha própria solução. Vejo agora que é muito parecido com a resposta de @ Dennis ♦ 'Jelly , apesar de eu ter pensado nisso de forma independente antes de lançar o desafio.

Entrada como string, saída como uma lista de caracteres. Adiciona um espaço se o comprimento for divisível por 3.

Experimente online ou verifique todos os casos de teste .

Explicação:

g3Ö         # Check if the length of the (implicit) input is divisible by 3
            # (results in 1 for truthy or 0 for falsey)
            #  i.e. "out" → 1
            #  i.e. "test" → 0
   ð×       # Repeat a space that many times
            #  i.e. 1 → " "
            #  i.e. 0 → ""
     «      # And append it to the (implicit) input
            #  i.e. "out" and " " → "out "
            #  i.e. "test" and "" → "test"
      S     # Then make the string a list of characters
            #  i.e. "out " → ["o","u","t"," "]
            #  i.e. "test" → ["t","e","s","t"]
A           # Push the lowercase alphabet
 ð«         # Appended with a space ("abcdefghijklmnopqrstuvwxyz ")
   3L       # Push list [1,2,3]
     3ã     # Cartesian repeated 3 times: [[1,1,1],[1,1,2],...,[3,3,2],[3,3,3]]
       ©    # Save that list of triplets in the registry (without popping)
           # Transliterate, mapping the letters or space to the triplet at the same index
            #  i.e. ["o","u","t"," "] → [[2,2,3],[3,1,3],[3,1,2],[3,3,3]]
            #  i.e. ["t","e","s","t"] → [[3,1,2],[1,2,2],[3,1,1],[3,1,2]]
ø           # Zip, swapping all rows/columns
            #  i.e. [[2,2,3],[3,1,3],[3,1,2],[3,3,3]] → [[2,3,3,3],[2,1,1,3],[3,3,2,3]]
            #  i.e. [[3,1,2],[1,2,2],[3,1,1],[3,1,2]] → [[3,1,3,3],[1,2,1,1],[2,2,1,2]]
 ˜          # Flatten the list
            #  i.e. [[2,3,3,3],[2,1,1,3],[3,3,2,3]] → [2,3,3,3,2,1,1,3,3,3,2,3]
            #  i.e. [[3,1,3,3],[1,2,1,1],[2,2,1,2]] → [3,1,3,3,1,2,1,1,2,2,1,2]
  3ô        # Split it into parts of size 3
            #  i.e. [2,3,3,3,2,1,1,3,3,3,2,3] → [[2,3,3],[3,2,1],[1,3,3],[3,2,3]]
            #  i.e. [3,1,3,3,1,2,1,1,2,2,1,2] → [[3,1,3],[3,1,2],[1,1,2],[2,1,2]]
®           # Push the triplets from the registry again
 Að«        # Push the lowercase alphabet appended with a space again
           # Transliterate again, mapping the triplets back to letters (or a space)
            # (and output the result implicitly)
            #  i.e. [[2,3,3],[3,2,1],[1,3,3],[3,2,3]] → ["r","v","i","x"]
            #  i.e. [[3,1,3],[3,1,2],[1,1,2],[2,1,2]] → ["u","t","b","k"]

3

Japonês , 42 bytes

;Êv3 ?UpS:U
m!bS=iC)®+27 ì3 ÅÃÕc ò3 £SgXì3

Experimente online!

O núcleo desta resposta vem de uma resposta excluída de Shaggy, mas ele nunca voltou a lidar com entradas de comprimento divisíveis por 3, portanto essa é uma versão fixa .

Explicação:

;                                 #Set C to the string "abcdefghijklmnopqrstuvwxyz"

 Ê                                #Get the length of the input
  v3 ?                            #If it is divisible by 3:
      UpS                         # Add a space
         :U                       #Otherwise don't add a space
                                  #Store the result in U

   S=iC)                          #Set S to C plus a space
m                                 #For each character in U:
 !bS                              # Get the position of that character in S
        ®        Ã                #For each resulting index:
             ì3                   # Convert to base 3
         +27    Å                 # Including leading 0s up to 3 places
                  Õ               #Transpose rows and columns
                   c              #Flatten
                     ò3           #Cut into segments of length 3
                        £         #For each segment:
                           Xì3    # Read it as a base 3 number
                         Sg       # Get the letter from S with that index

3

C # (compilador interativo do Visual C #) , 178 bytes

s=>{int[]a={9,3,1},b=(s.Length%3>0?s:s+0).Select(c=>c<97?26:c-97).ToArray();s="";for(int i=0,k,l=b.Length;i<l*3;s+=(char)(k>25?32:97+k))k=a.Sum(p=>b[i%l]/a[i++/l]%3*p);return s;}

Experimente online!

Menos jogado ... Ainda é confuso :)

// s is an input string
s=>{
  // powers of 3
  int[]a={9,3,1},
  // ensure the length of s is coprime to 3
  // and convert to numbers from 0-26
  b=(s.Length%3>0?s:s+0).Select(c=>c<97?26:c-97).ToArray();
  // reset s to collect result
  s="";
  // main loop
  for(
    // i is the main index variable
    // k is the value of the encoded character
    // l is the length
    int i=0,k,l=b.Length;
    // i continues until it is 3x the length of the string
    i<l*3;
    // convert k to a character and append
    s+=(char)(k>25?32:97+k)
  )
    // compute the trifid
    // (this is the confusing part :)
    k=a.Sum(p=>b[i%l]/a[i++/l]%3*p);
  // return the result
  return s;
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.