Dada una cadena para codificar, y varias columnas (la clave), codifique la cadena de la siguiente manera:

^{Usaré el ejemplo Hello, world!y la clave3}

Primero, escriba el número de columnas:

1 2 3

Luego, escriba el texto comenzando desde la esquina superior izquierda, un carácter por columna, y cuando se quede sin columnas, pase a la siguiente línea.

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

Ahora, para obtener su texto codificado, lea el texto comenzando desde la esquina superior izquierda, pero esta vez, primero lea una columna, luego la siguiente, y así sucesivamente. Si no hay un personaje en la ranura, ponga un espacio.

Hl r!eowl l,od 

^{Tenga en cuenta que aquí hay un espacio final.}

Este es tu texto codificado.

Otro caso de prueba es Programming Puzzles and Code Golf SEcon clave 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

El texto codificado es PagzaooErm lndl omPedef gius rnz CGS.

Más casos de prueba

"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 "

Recuerde, este es el código de golf , por lo que gana el código con la menor cantidad de bytes.

MATL , 4 bytes

e!1e

Pruébalo en línea!

Esto es lo más sencillo posible. ees una función integrada que da forma a una matriz en n filas. Entonces leemos en input1 como una cadena, y formamos una matriz con input2 filas:

Hl r!
eowl 
l,od 

Luego, lo transponemos para obtener esto:

Hel
lo,
 wo
rld
!  

Después de eso, solo llamamos 1epara remodelarlo en una sola fila y mostrarlo como una cadena.

Como puede ver en este programa de ejemplo , la función "remodelar" agrega convenientemente tantos ceros como sea necesario para que la matriz sea un rectángulo perfecto. Cuando se muestra como una cadena, MATL trata los '0 como espacios, por lo que automáticamente llena el número necesario de espacios para que no se trabaje más.

Jalea , 3 bytes

sz⁶

TryItOnline!

¿Cómo?

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=~/./}

Véalo en eval.in: https://eval.in/668412

Sin golf

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

Pyth - 5 bytes

s.tcF

Pruébelo en línea aquí .

Python 2, 46 bytes

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

La idea es tomar la cadena de entrada, copiarla nveces con el primer carácter eliminado, y luego tomar todos nlos caracteres.

Veamos, por ejemplo s="abcdef", n=3, donde, la longitud es un múltiplo de n:

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

El primer ciclo a través de la cadena toma todos nlos caracteres del primero. Luego, cada ciclo subsiguiente desplaza un índice a la derecha porque se omite el primer carácter. Para garantizar que la longitud sea un múltiplo de n, la cadena inicial se rellena con espacios.

Japt, 15 bytes

U+SpV f'.pV)y q

¡Pruébelo en línea!

Japt tiene "todas las subsecciones de longitud N" incorporadas, pero ni "todas las subsecciones que no se superponen" ni "todos los caracteres Nth". De repente, hay un agujero enorme en mi vida ...

Explicación

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]

Pruébalo en Ideone .

JavaScript (ES6), 84 bytes

Es una solución 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="")

Pruébalo en R-Fiddle

Esto resultó ser un poco dolor de cabeza porque R recicla automáticamente el vector de entrada cuando las filas o columnas especificadas en la creación de la matriz no son múltiplos de la longitud de la entrada. Por lo tanto, tenemos que rellenar el vector con -nchar(x)%%nespacios antes de pasarlo a la función matriz.

El último paso es simplemente transponer la matriz e imprimirla.

Perl, 61 bytes

54 bytes de códigos y -F -pibanderas.

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

Toma la cadena de entrada sin nueva línea final, y la clave debe colocarse después de la -ibandera:

$ 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

¡Gracias a las millas por ahorrar tres bytes!

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

Función sin nombre que toma dos argumentos, una matriz de caracteres y un número entero; Devuelve una serie de caracteres. La mayor parte del trabajo pesado se realiza mediante la Threadfunción, que (en este contexto) intercambia filas y columnas. Partitionnecesita ser invocado con un par de argumentos inútiles para que coincida con el 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}

Puntaje terrible, consejos apreciados.

Perl, 87 bytes

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

Acepta dos argumentos como parámetros y uso:

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

Pyth, 40 bytes

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

Pruébalo aquí

Probablemente el código Pyth más feo de la historia, pero este es mi primer intento en 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)

Si alguien tiene consejos para mejorar mi golf, ¡por favor deje un comentario!

En realidad , 12 bytes

Las sugerencias de golf son bienvenidas, especialmente si puede encontrar una forma más golfista de rellenar espacios. Pruébalo en línea!

;' *(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.

Otra versión de 12 bytes.

En esta versión, el orden de las entradas se invierte, pero esto se puede cambiar si eso no está permitido. Sugerencias de golf bienvenidas. Pruébalo en línea!

│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

Pruébalo aquí!

C #, 161 bytes

Lo siento mucho.

(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 , (no competidor) 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()}

Acolche la entrada por el techo del tamaño dividido en ntrozos.

Obtenga la cadena acolchada como una lista de caracteres.

Clasificar en n trozos y transponer.

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

Resultados en:

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 prueba:

$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"
}

Salida:

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

El primer parámetro A$es el valor de cadena que desea cifrar, y el segundo Aes el número de columnas a las que desea cifrar. La variable Cse usa para agregar una nueva línea después de los Acaracteres.

Las líneas 4 a 6 inclusive imprimen los números de columna en la parte superior del área de la pantalla.

La línea 7 agrega una nueva línea ( "\r\n"equivalente).

Las líneas 8 a 13 imprimirán cada carácter de A$.

Este programa no requiere una expansión de RAM para funcionar.

K (oK) , 27 bytes

Solución:

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

Pruébalo en línea!

Explicación:

{,/+(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 (heredado) , 3 bytes

ôζJ

La versión heredada de Python se usa en lugar de la reescritura de Elixir, porque la nueva versión no convierte implícitamente las cadenas en caracteres cuando se usa zip, lo que hizo la versión anterior.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ô      # 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 '