A função de descriptografia

Question

Você deve escrever um programa que pega uma string criptografada e descriptografá-la de acordo com regras específicas e depois imprimi-la. A descriptografia ocorrerá por meio da realização de duas operações.

Exemplo de argumento de entrada 1 (a string criptografada)

HGJILKBADCFE

Operação 1:

Troque a primeira metade da corda pela segunda metade, o que deve deixar você com:

BADCFEHGJILK

Operação 2:

Troque cada dois caracteres entre si, como trocar o caractere 1 por 2, 3 por 4, etc., o que deve deixar você com a string descriptografada:

ABCDEFGHIJKL

Diretrizes:

• O argumento de entrada 1 conterá apenas letras maiúsculas

• O comprimento do argumento de entrada 1 será entre 2 e 100 caracteres

• O comprimento do argumento de entrada 1 será sempre um número par

• De preferência, a entrada será obtida da linha de comando (como abaixo).

• Outro caso de teste MPORQTSVUXWZYBADCFEHGJILKNé a entrada, a saída éABCDEFGHIJKLMNOPQRSTUVWXYZ

Minha tentativa

import sys
_,a=sys.argv
b=len(a)//2
s=a[b:]+a[:b]
print(''.join(x+y for x,y in zip(s[1::2],s[::2])))

Answer 1

J , 15 bytes

[:,_2|.\-:@#|.]

Experimente online!

Implementação direta da fórmula.

---

Um pouco mais interessante (não é útil para J golfing, mas talvez para outro idioma) é que o algoritmo pode ser resolvido com uma soma de varredura:

1. Primeiro pegue um 1seguido por -1 3, com -1 3repetido até o comprimento da lista.
2. Scan soma essa lista.
3. Gire os números pela metade do comprimento da lista.
4. Classifique o original de acordo com esses números.

Veja o TIO para uma demonstração em J.

Answer 2

Ruby -p , ⁴⁸ 47 bytes

$_=$_[l= ~/$//2,l]+$_[0,l];gsub /(.)(.)/,'\2\1'

Experimente online!

A operação 1 é tratada pela divisão $_(a variável global predefinida que contém a entrada) em duas substrings de comprimento igual; ~/$/dá o comprimento da entrada. Em seguida, gsub /(.)(.)/,'\2\1'conclui a Operação 2 trocando cada par de personagens. (Com a -pbandeira, gsubsem um receptor que atua implicitamente $_.)

Answer 3

05AB1E , 13 12 bytes

D2äRJ2ι`s.ιJ

Experimente online!

-1 graças a uma dica de golfe de @Kevin, vi em outra resposta

Explicado

D2äRJ2ι`s.ιJ

• Duplique a entrada ( D)
• Divida-o em 2 pedaços ( 2ä)
• Inverta a lista e junte-a em uma única string ( RJ)
• Desintercalar essa string em cada segundo caractere ( 2ι)
• Empurre todos os itens da string não intercalada para a pilha (`` `)
• Intercalar esses itens ( .ι)
• E entrar na lista resultante ( J)

Answer 4

APL + WIN, 24 22 bytes

-2 bytes graças a Jo King

Solicita a entrada de string:

,⌽n⍴⊖(⌽n←⌽2,.5×⍴s)⍴s←⎕

Experimente online! Cortesia de Dyalog Classic

Answer 5

R , 78 80 79 bytes

Editar: +2 bytes graças a Dingus por detectar bugs e -1 byte graças a pajonk

n=nchar(s<-scan(,''));o=1:n;cat(substring(s,p<-(o+n/2-2+2*o%%2)%%n+1,p),sep='')

Experimente online!

Entrada fornecida por meio do console R (que pode ser considerada a 'linha de comando' para o espaço de trabalho R).
R também pode ser chamado de um shell (não R), usando o Rscriptfront-end auxiliar, o que permitiria que argumentos de linha de comando seguissem diretamente a chamada, caso em que um programa modificado poderia ter 87 bytes e ser chamado usando Rscript decrypt.r HGJILKBADCFE.

Calcula as posições das letras decodificadas e, em seguida, gera a sequência reorganizada.

Comentado:

 n=nchar(                   # n = number of characters in...
         s<-scan(,''));     # s = the input.
 o=1:n;                     # o = sequence from 1 to n
 p=                         # p = positions of decoded characters:
   (o+n/2-1                 #   - reverse the first & second halves of o
                            #     by adding n/2-1
                            #     (will be fixed with final modulo below) 
         +2*o%%2-1)         #   - then add 2 at every odd position
                            #     and subtract 1 from all, so in effect
                            #     adding to odds & subtracting from evens
                   %%n      #   - all modulo n
                      +1    #   - add 1 to get 1-based indices
 cat(                       # output:
   substring(s,p,p),sep='') #   characters of s from positions p to p

Answer 6

Jelly , 7 bytes

ŒHṚFs2U

Experimente online!

Equivalentemente 7 bytes ṙLH$s2U,.

Explicação

ŒHṚFs2U  Main Link
ŒH       Split into two halves of similar length
  Ṛ      Reverse the order (swap the two halves)
   F     Flatten back into a single string
    s2   Slice into chunks of length 2
      U  Reverse each chunk
         Output is implicitly as one string

O outro ṙotata por $( Half do Length da corda) e então faz a mesma coisa para a segunda parte do desafio.

Answer 7

Python 3 , 75 bytes

Exatamente como solicitado: entrada da linha de comando, saída para STDOUT.

import sys
_,s=sys.argv
i=1
while s[i:]:print(end=s[i-len(s)//2]);i+=3|i%-2

Experimente online!

---

Python 2 , 52 bytes

Se pudermos usar uma função:

f=lambda s,i=1:s[i:]and s[i-len(s)/2]+f(s,i+3-i%2*4)

Experimente online!

---

A ideia de tudo isso é que o índice do \$i\$'o caractere de saída em uma string de comprimento \$n\$ é:

$$ i - \frac{n}{2} + (-1)^i $$

Sujeito à semântica usual de indexação do Python. Se reescrevermos de forma iterativa, o \$i\$'o caractere de saída é:

$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3 - 4(i\%2) $$

Mais curto com certa precedência é:

$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3|(i\%-2) $$

Answer 8

Python 2 , 50 bytes

f=lambda s,i=0:s[i:]and s[(i^1)-len(s)/2]+f(s,i+1)

Experimente online!

Tomando emprestadas idéias de Sísifo , o i'ésimo caractere da saída é o caractere no índice (i^1)-len(s)/2da entrada. Aqui, i^1é XOR com 1, que vira o último pedaço e assim swaps mesmo / pares de ímpares 0<->1, 2<->3, 4<->5, ...

Aqui está uma alternativa não recursiva para o mesmo comprimento, embora produza uma lista de caracteres que não tenho certeza se é permitida.

lambda s:[s[(i^1)-len(s)/2]for i in range(len(s))]

Experimente online!

Answer 9

C (gcc) , 73 72 70 bytes

Economizei 2 bytes graças a Dominic van Essen !!!

i;l;f(char*s){for(i=1;(l=strlen(s))/i;)putchar(s[(i+l/2-++i%2*2)%l]);}

Experimente online!

Insere uma string e produz a descriptografia.

Explicação

Mapeia o índice (começando em \$0\$ao final), da string de entrada, \$s\$de comprimento \$l\$, para o lugar correto deslocando-o sobre \$\frac{l}{2}+1\$lugares e depois volta \$2\$para índices ímpares. Usando este \$\mod{l}\$dá o índice correto de \$s\$ para o próximo caractere de saída.

Answer 10

JavaScript (Node.js) , 71 65 bytes

s=>(s.slice(l=s.length/2)+s.slice(0,l)).replace(/(.)(.)/g,'$2$1')

Experimente online!

Economizou 6 bytes graças a @Shaggy.

Solução original de 71 bytes:

s=>(l=>s.slice(l)+s.slice(0,l))(s.length/2).replace(/(\w)(\w)/g,'$2$1')

Coisas muito simples aqui - usei uma função interna porque tive que cercar as slicechamadas de qualquer maneira - isso economiza 4 bytes.

Answer 11

Brachylog , 8 bytes

ḍ↔cġ₂↔ᵐc

Experimente online!

Como funciona

ḍ↔cġ₂↔ᵐc
ḍ        split in two halves
 ↔       reverse
  c      join
   ġ₂    group with length two
     ↔ᵐ  reverse each
       c join 

Answer 12

Python 3 , 91 bytes

a=input();x=len(a)//2;b=a[x:]+a[:x];c=''
for i in range(0,len(b),2):c+=b[i+1]+b[i]
print(c)

Experimente online!

Answer 13

Pip , 21 bytes

RV_M(JRV(a<>#a/2)<>2)

Experimente online!

Explicação

RV_M(JRV(a<>#a/2)<>2)
        (a<>#a/2)     split input into parts of size length/2
     JRV              reverse the list, and join it to string
                 <>2  split the joined string into parts of size 2
RV_M                  reverse each of those parts
                      implicit output

Answer 14

C (gcc) , 78 76 78 74 bytes

Obrigado ao roofcat pelo -4!

Editar: Revertido para usar adição em vez de OR para evitar problemas de precedência do operador.

Em vez de dividir a string, a função começa no meio da string e envolve toda a string que foi processada. Para inverter todos os outros caracteres, o índice inverte a posição 1s do contador.

f(s,i,j)char*s;{for(i=strlen(s),j=0;write(1,s+(i/2+j++/2*2+j%2)%i,j<i););}

Experimente online!

Se o programa absolutamente deve tirar da linha de comando: 82 bytes

main(i,s,j)char**s;{for(i=strlen(*++s),j=0;write(1,*s+(i/2+j++/2*2+j%2)%i,j<i););}

Experimente online!

Answer 15

Stax , 10 bytes

ü♠yαæ♠╟«ºñ

Execute e depure-o

Que intérprete online maravilhoso.

O link é para a versão descompactada do código.

Explicação

;%h/r$2/Frp ; copy input % get it's length h halve it / split input into parts of that size r reverse $      join to string
      2/    split into parts of size 2
        F   for each element in the resulting array:
         rp reverse, and print without newline.

Answer 16

K (ngn / k) , 17 bytes

,/|'0N 2#,/|2 0N#

Experimente online!

Answer 17

Fator , 89 bytes

: d ( s -- s ) halves swap [ >array ] bi@ append 2 group [ reverse ] map concat >string ;

Experimente online!

Answer 18

R , 64 63 bytes

m=matrix;intToUtf8(m(m(utf8ToInt(scan(,"")),,2)[,2:1],2)[2:1,])

Experimente online!

Adotou uma abordagem diferente da de Dominic van Essen , que jogou um byte de golfe. Usa remodelagem / indexação da matriz para fazer a reversão.

Ungolfed:

s <- utf8ToInt(scan(,""))		# read input and convert to a list of byte values
m <- matrix(s,,2)			# convert to a Nx2 matrix, filling down by columns
m <- m[,2:1]				# reverse the columns of the matrix (flip the halves)
m <- matrix(m,2)			# convert to an Nx2 matrix, filling down by the columns
m <- m[2:1,]				# reverse the rows (swap adjacent characters)
intToUtf8(m)				# convert back to string

Answer 19

bash + sed, 57 bytes

Aceita a entrada como um argumento de linha de comando.

<<<"${1:${#1}/2}${1:0:${#1}/2}" sed 's/\(.\)\(.\)/\2\1/g'

Experimente online!

Answer 20

Burlesco , 17 bytes

iRsa2./!!2co)<-++

Experimente online!

Descrição:

iR               # Generate all rotations of the input string
  sa             # Duplicate and get length (which equals string length)
    2./          # Divide by two
       !!        # And grab the string that's been rotated that many times
         2co     # Split the rotated string into chunks of two
            <-   # Reverse each chunk
              ++ # Join together and implicitly output

Answer 21

Japt -P , 9 bytes

éUÊz)ò mw

Tente

éUÊz)ò mw     :Implicit input of string U
é             :Rotate right by
 UÊ           :  Length of U
   z          :  Floor divided by 2
    )         :End rotate
     ò        :Partitions of length 2
       m      :Map
        w     :  Reverse
              :Implicitly join and output

Answer 22

Carvão , 13 bytes

⭆⪪⪫⮌⪪θ⊘Ｌθω²⮌ι

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

        θ       Input string
       Ｌ        Length
      ⊘         Halved
    ⪪θ          Split input string into substrings of this length
   ⮌            Reverse
  ⪫      ω      Join together
 ⪪        ²     Split into substrings of length 2
⭆               Map over substrings and join
            ι   Current substring
           ⮌    Reversed
                Implicitly print

Answer 23

Retina 0.8.2 , 36 bytes

((.)+?)((?<-2>.)+)$ $3$1 (.)(.) $2$1

Experimente online! Explicação: O primeiro estágio usa um grupo de balanceamento .NET para corresponder o mínimo de caracteres possível $1e ainda corresponder ao mesmo número de caracteres $3. $#2incrementos para cada caractere correspondido $1e decrementos para cada caractere correspondido, $3mas não pode diminuir abaixo de zero, portanto, $1é forçado a consumir a primeira metade da string para permitir que o final da string seja alcançado. O segundo estágio então inverte pares de personagens adjacentes. (Também arte ASCII).

Answer 24

MathGolf , 10 bytes

h½/xy2/mx~

Experimente online.

Explicação:

h           # Get the length of the (implicit) input-string (without popping)
            #  i.e. "HGJILKBADCFE" → "HGJILKBADCFE" and 12
 ½          # Halve this length
            #  → "HGJILKBADCFE" and 6
  /         # Split the string into parts of that size
            #  → ["HGJILK","BADCFE"]
   x        # Reverse this pair
            #  → ["BADCFE","HGJILK"]
    y       # Join it back together to a string
            #  → "BADCFEHGJILK"
     2/     # Split it into parts of size 2
            #  → ["BA","DC","FE","HG","JI","LK"]
       m    # Map over each pair:
        x   #  Reverse the pair
            #  → ["AB","CD","EF","GH","IJ","KL"]
         ~  # Pop and push all strings separated to the stack
            #  → "AB", "CD", "EF", "GH", "IJ", and "KL"
            # (after which the entire stack joined together is output implicitly)
            #  → "ABCDEFGHIJKL"

Answer 25

Vermelho , 89 bytes

func[s][move/part s tail s(length? s)/ 2
rejoin collect[foreach[b a]s[keep rejoin[a b]]]]

Experimente online!

Answer 26

Lua , 67 bytes

a=...b=#a//2print(((a:sub(b+1)..a:sub(1,b)):gsub('(.)(.)','%2%1')))

Experimente online!

Primeiro, a string é cortada em duas usando subfunções e depois concatenada de volta na ordem inversa. Então, gsubé usado para trocar pares de caracteres.

Answer 27

Wolfram Language (Mathematica) , 64 51 bytes

#[[#+UnitStep@#&@Array[#+(-1)^#&,L=Tr[1^#],-L/2]]]&

Experimente online!

Solução Python do porto de Sísifo

Answer 28

CJam , 13 bytes

q2/::\_,2//:\

Experimente online!

Answer 29

Perl 5 -pF , 40 bytes

for$p("."x(@F/2),"."){s/($p)($p)/$2$1/g}

Experimente online!

Answer 30

Poético , 472 bytes

DECODING THINGS:A BRIEFING
o,o,hello!i am agent Q
nah,Q`s chosen by an infamous phoney
a misprint!oh,sorry!am i sorry
i am agent J.W,tech/A.I hacker
i see a piece o code,i am trying at a means on how i decode it
what i am doing:i am laying all A-Z clearly along a pathway
midway,put in zeros(O,O)cause J.W needs it to split em
i shift em in tandem,i get B,A
lastly,if it leaves you a letter,it is moved
o,then i am doing A-Z again,it is taken to a shift
ah ha!spying is EZ

Experimente online!