Dada uma sequência a ser codificada e um número de colunas (a chave), codifique a sequência da seguinte maneira:

^{Vou usar o exemplo Hello, world!e a chave3}

Primeiro, escreva o número de colunas:

1 2 3

Em seguida, escreva o texto começando no canto superior esquerdo, um caractere por coluna e, quando ficar sem colunas, vá para a próxima linha.

1 2 3
H e l
l o ,
  w o
r l d
!

Agora, para obter seu texto codificado, leia o texto começando no canto superior esquerdo, mas desta vez, primeiro leia uma coluna e depois a próxima, e assim por diante. Se não houver um caractere no slot, coloque um espaço.

Hl r!eowl l,od 

^{Observe que aqui há um espaço à direita.}

Este é o seu texto codificado.

Outro caso de teste é Programming Puzzles and Code Golf SEcom a chave 5:

1 2 3 4 5
P r o g r
a m m i n
g   P u z
z l e s  
a n d   C
o d e   G
o l f   S
E

O texto codificado é PagzaooErm lndl omPedef gius rnz CGS.

Mais casos de teste

"abcdefghijklmnopqrstuvwxyz", 2 -> "acegikmoqsuwybdfhjlnprtvxz"
"codegolf.stackexchange.com", 4 -> "cg.ccgoooskhemdltea. efaxnc "
"Pen Pineapple Apple Pen!!!", 7 -> "PeAeeapnnpp! pl!Ple!ie  n P "
"1,1,2,3,5,8,13,21,34,55,89", 10 -> "18,,,5115,3,2,8,2931 ,, 53 ,4 "

Lembre-se, isso é código-golfe , então o código com o menor número de bytes vence.

MATL , 4 bytes

e!1e

Experimente online!

Isso é o mais direto possível. eé um built-in que reformula uma matriz em n linhas. Então, lemos na entrada1 como uma string e formamos uma matriz com as linhas input2 :

Hl r!
eowl 
l,od 

Em seguida, transpomos para obter isso:

Hel
lo,
 wo
rld
!  

Depois disso, chamamos 1epara remodelá-lo em uma única linha e exibi-lo como uma sequência.

Como você pode ver neste programa de exemplo , a função "remodelar" adiciona convenientemente quantos zeros forem necessários para que a matriz seja um retângulo perfeito. Ao exibir como uma seqüência de caracteres, o MATL trata os zeros como espaços, portanto, ele preenche automaticamente o número necessário de espaços para nenhum trabalho extra.

Gelatina , 3 bytes

sz⁶

TryItOnline!

Quão?

sz⁶ - Main link: string, columns
s   - split string (a list of characters) into chunks of length column
 z  - transpose the resulting list of lists with filler
  ⁶ - literal ' '
    - implicit print

PHP, 85 bytes

for(;$i<$x=$argv[2];$i++)for($j=0;$j<strlen($t=$argv[1])/$x;)echo$t[$i+$j++*$x]??" ";

PHP, 90 bytes

for(;$i<$x=$argv[2];$i++)foreach(array_chunk(str_split($argv[1]),$x)as$a)echo$a[+$i]??" ";

Ruby, 78 67 65 bytes

->s,k{s.gsub!(/(.)(.{,#{k-=1}})/){$><<$1
$2.ljust k}while s=~/./}

Veja-o em eval.in: https://eval.in/668412

Ungolfed

->s,k{
  s.gsub!(/(.)(.{,#{ k -= 1 }})/) {
    $> << $1
    $2.ljust k
  } while s =~ /./
}

Pitão - 5 bytes

s.tcF

Experimente online aqui .

Python 2, 46 bytes

lambda s,n:(s[0]+(s[1:]+-len(s)%n*' ')*n)[::n]

A idéia é pegar a string de entrada, copiá-la ncom o primeiro caractere removido e, em seguida, pegar todos nos caracteres.

Vejamos, por exemplo s="abcdef", n=3, onde o comprimento é múltiplo de n:

abcdefbcdefbcdef
^  ^  ^  ^  ^  ^
a  d  b  e  c  f

O primeiro ciclo através da string leva todos os ncaracteres do primeiro. Em seguida, cada ciclo subsequente muda um índice para a direita, porque o primeiro caractere é ignorado. Para garantir que o comprimento seja múltiplo de n, a cadeia inicial é preenchida com espaços.

Japonês, 15 bytes

U+SpV f'.pV)y q

Teste online!

Japt possui um "todas as subseções de comprimento N" interno, mas nem "todas as subseções não sobrepostas" nem "todo enésimo caractere". De repente, há um buraco na minha vida ...

Explicação

U+SpV            // Take U concatenated with V spaces.
      f'.pV)     // Take every substring of 3 chars.
            y    // Transpose the resulting array.
              q  // Join on the empty string.
                 // Implicit: output last expression

Python 2, 58 bytes

lambda s,n:`sum(zip(*zip(*n*[iter(s+' '*~-n)])),())`[2::5]

Teste em Ideone .

JavaScript (ES6), 84 bytes

É uma solução recursiva.

f=(s,k,i=0,r=Math.ceil(s.length/k),c=s[i%r*k+i/r|0])=>k*r==i?'':(c?c:' ')+f(s,k,++i)

R, 92 81 bytes

function(x,n)cat(t(matrix(c(el(strsplit(x,"")),rep(" ",-nchar(x)%%n)),n)),sep="")

Experimente no R-fiddle

Isso acabou sendo uma dor de cabeça, porque R recicla automaticamente o vetor de entrada quando as linhas ou colunas especificadas na criação da matriz não são um múltiplo do comprimento da entrada. Portanto, temos que preencher o vetor com -nchar(x)%%nespaços antes de passá-lo para a função matriz.

O último passo é apenas transpor a matriz e imprimi-la.

Perl, 61 bytes

54 bytes de códigos e -F -pisinalizadores.

for$l(1..$^I){$\.=$F[$^I*$_+~-$l]//$"for 0..$#F/$^I}}{

Pega a sequência de entrada sem nova linha final e a chave deve ser colocada após o -isinalizador:

$ echo -n "Hello, World!" | perl -F -pi3 -E 'for$l(1..$^I){$\.=$F[$^I*$_+~-$l]//$"for 0..$#F/$^I}}{'
Hl r!eoWl l,od 

Mathematica, 43 40 bytes

Graças a milhas por economizar três bytes!

Join@@Thread@Partition[##,#2,{1,1}," "]&

Função sem nome, recebendo dois argumentos, uma matriz de caracteres e um número inteiro; retorna uma matriz de caracteres. A maior parte do trabalho pesado é realizada pela Threadfunção, que (neste contexto) troca linhas e colunas. Partitionprecisa ser chamado com alguns argumentos inúteis para que ele atenda ao quinto argumento " ".

Ruby, 89 bytes

->s,i{t="";i.times{|n|s.ljust(i*(s.size*1.0/i).ceil).scan(/#{?.*i}/).each{|j|t<<j[n]}};t}

Pontuação terrível, dicas apreciadas.

Perl, 87 bytes

($a,$b)=@ARGV;for$c(1..$a){for(0..(length$a)/$b){$e.=substr($a,$b*$_+$f,1)}$f++;}say$e;

Aceita dois argumentos como parâmetros e Uso:

perl -M5.010 encol.pl "Hello, World!" 3
Hl r!eoWll,od

Pitão, 40 bytes

=Zw=+Z*d+Q-*Q/lZQlZV*QlZIq%%NlZQ/NlZp@ZN

Teste aqui

Provavelmente o código Pyth mais feio de todos os tempos, mas esta é minha primeira tentativa em Pyth.

=Zw=+Z*d+Q-*Q/lZQlZV*QlZIq%%NlZQ/NlZp@ZN
         Q                               Set Q to eval(input())
=Zw                                      Initialises Z to next input string
              lZ                         Gets the length of Z
             /lZQ                        Integer divides lZ by Q
           *Q/lZQ                        Multiplies that result by Q
          -*Q/lZQlZ                      Subtracts the length of Z from that
        +Q-*Q/lZQlZ                      Adds Q to that
                                         (This is how many spaces to pad)
      *d+Q-*Q/lZQlZ                      Gets that many spaces (d is set to ' ')
   =+Z*d+Q-*Q/lZQlZ                      Appends that to Z
                    *QlZ                 Multiplies Q by lZ
                   V*QlZ                 Does a for loop for integers in that range, on N
                           %NlZ          Gets N modulo lZ
                          %%NlZQ         Gets that modulo Q
                                         This is the column of the letter at index N mod Q
                                /NlZ     Gets the column that is being printed
                        Iq%%NlZQ/NlZ     If they are equal...
                                    p@ZN Print the index of N into Z without a newline
                                         (This is implicitly modulo the length of Z)

Se alguém tiver dicas para melhorar meu golfe, por favor, deixe um comentário!

Na verdade , 12 bytes

Sugestões de golfe são bem-vindas, especialmente se você puder descobrir uma maneira de jogar golfe para preencher espaços. Experimente online!

;' *(q╪dX┬ΣΣ

Ungolfing

      Implicit input s, then n.
;     Duplicate n. Stack: n, n, s
' *   Push n spaces.
(q    Rotate s to TOS and append the spaces to the end of s.
╪     Split s into n-length substrings.
dX    Dequeue and discard any extra spaces that remain after chunking.
      This works even when we didn't need to add spaces in the first place.
┬     Transpose the remaining substrings. This returns a list of lists of chars.
Σ     Sum the transposed substrings into one list of chars.
Σ     Sum the list of chars into one string.
      Implicit return.

Outra versão de 12 bytes

Nesta versão, a ordem das entradas é revertida, mas isso pode ser alterado se isso não for permitido. Sugestões de golfe são bem-vindas. Experimente online!

│l±%' *o╪┬ΣΣ

Ungolfing

      Implicit input n first, then s.
│     Duplicate stack. Stack: s, n, s, n
l±    Push -len(s).
%     Push -len(s)%n, which gets the number of spaces we need to pad with. Call this m.
' *   Push m spaces to the stack.
o     Append the spaces to the end of s.
╪     Split s into n-length substrings.
┬     Transpose these substrings. This returns a list of lists of chars.
Σ     Sum the transposed substrings into one list of chars.
Σ     Sum the list of chars into one string.
      Implicit return.

Pyke, 10 bytes

k=.,Rc.,ss

Experimente aqui!

C #, 161 bytes

Eu sinto muitíssimo.

(s,i)=>String.Join("",Enumerable.Range(0,i).SelectMany(x=>Enumerable.Range(0,s.Length/i+1).Select(n=>(n*3+x)).Where(m=>m<s.Length).Select(o=>s.Substring(o,1))));

GolfSharp , (não competindo) 82 bytes

(s,i)=>r(0,i).m(x=>r(0,s.L()/i+1).s(n=>(n*3+x)).w(m=>m<s.L()).s(o=>s.R(o,1))).j();

Groovy, 90 bytes

{s,n->(s.padRight((int)(s.size()/n+1)*n) as List).collate(n).transpose().flatten().join()}

Preencher a entrada pelo teto do tamanho dividido em npedaços.

Obtenha a string preenchida como uma lista de caracteres.

Agrupe em n pedaços e transponha.

({s,n->(s.padRight((int)(s.size()/n+1)*n) as List).collate(n).transpose().flatten().join()})("Programming Puzzles and Code Golf SE",5)

Resulta em:

PagzaooErm lndl omPedef gius    rnz CGS

Python 3, 48 bytes

lambda c,k:''.join([c[i:-1:k]for i in range(k)])

PowerShell, 57 bytes

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[$i++%$n]+=$_}
-join$r

Script de teste:

$f = {

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[$i++%$n]+=$_}
-join$r

}

@(
    ,("abcdefghijklmnopqrstuvwxyz", 2  , "acegikmoqsuwybdfhjlnprtvxz")
    ,("codegolf.stackexchange.com", 4  , "cg.ccgoooskhemdltea.efaxnc")
    ,("Pen Pineapple Apple Pen!!!", 7  , "PeAeeapnnpp! pl!Ple!ie n P")
    ,("1,1,2,3,5,8,13,21,34,55,89", 10 , "18,,,5115,3,2,8,2931,,53,4")
) | % {
    $s,$n,$expected = $_
    $result = &$f $s $n
    "$($result-eq$expected): $result"
}

Resultado:

True: acegikmoqsuwybdfhjlnprtvxz
True: cg.ccgoooskhemdltea.efaxnc
True: PeAeeapnnpp! pl!Ple!ie n P
True: 18,,,5115,3,2,8,2931,,53,4

SINCLAIR ZX81 / TIMEX TS-1000/1500 BASIC, 134 bytes BASIC tokenizados

 1 INPUT A$
 2 INPUT A
 3 LET C=-SGN PI
 4 FOR I=SGN PI TO A
 5 PRINT I;
 6 NEXT I
 7 PRINT
 8 FOR I=SGN PI TO LEN A$
 9 LET C=C+SGN PI
10 IF C=A THEN LET C=NOT PI
11 IF NOT C AND I>SGN PI THEN PRINT
12 PRINT A$(I);
13 NEXT I

O primeiro parâmetro A$é o valor da string que você deseja codificar e o segundo Aé o número de colunas que você deseja codificar. A variável Cé usada para adicionar uma nova linha após os Acaracteres.

As linhas 4 a 6, inclusive, imprimem os números das colunas na parte superior da área da tela.

A linha 7 adiciona uma nova linha ( "\r\n"equivalente).

As linhas 8 - 13 imprimirão cada caractere de A$ .

Este programa não requer uma expansão de RAM para funcionar.

K (OK) , 27 bytes

Solução:

{,/+(0N;y)#(y*-_-(#x)%y)$x}

Experimente online!

Explicação:

{,/+(0N;y)#(y*-_-(#x)%y)$x} / the solution
{                         } / lambda taking implicit x and y
                        $x  / pad x 
           (           )    / do this together
                     %y     / divide by y
                 (  )       / do this together
                  #x        / count (#) length of x
                -           / negate \
               _            / floor   | ceiling
              -             / negate /
            y*              / multiply by y
          #                 / reshape
    (0N;y)                  / null by y grid
   +                        / transpose
 ,/                         / flatten

05AB1E (herdado) , 3 bytes

ôζJ

A versão herdada do Python é usada em vez da reescrita do Elixir, porque a nova versão não converte implicitamente seqüências de caracteres em caracteres ao usar zip , o que a versão antiga fez.

Experimente online ou verifique todos os casos de teste .

Explicação:

ô      # Split the (implicit) input-String into chunks of size (implicit) input-integer
       #  i.e. "Hello, world!" and 3 → ['Hel','lo,',' wo','rld','!']
 ζ     # Zip, swapping rows and columns (with space filler by default)
       #  i.e. ['Hel','lo,',' wo','rld','!'] → ['Hl r!','eowl ','l,od ']
  J    # Join the list of strings together (and output implicitly)
       #  i.e. ['Hl r!','eowl ','l,od '] → 'Hl r!eowl l,od '