Codieren Sie die Zeichenfolge mit einer zu codierenden Zeichenfolge und einer Anzahl von Spalten (dem Schlüssel) wie folgt:

^{Ich werde das Beispiel Hello, world!und den Schlüssel verwenden3}

Schreiben Sie zunächst die Anzahl der Spalten auf:

1 2 3

Schreiben Sie als Nächstes den Text beginnend oben links mit einem Zeichen pro Spalte. Wenn Ihnen die Spalten ausgehen, fahren Sie mit der nächsten Zeile fort.

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

Um Ihren codierten Text zu erhalten, lesen Sie den Text ab der oberen linken Ecke. Lesen Sie diesmal jedoch zuerst eine Spalte und dann die nächste und so weiter. Wenn sich kein Zeichen im Steckplatz befindet, setzen Sie ein Leerzeichen.

Hl r!eowl l,od 

^{Beachten Sie, dass hier ein nachgestelltes Leerzeichen vorhanden ist.}

Dies ist Ihr verschlüsselter Text.

Ein weiterer Testfall ist Programming Puzzles and Code Golf SEmit Schlüssel 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

Der verschlüsselte Text ist PagzaooErm lndl omPedef gius rnz CGS.

Weitere Testfälle

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

Denken Sie daran, dies ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

MATL , 4 Bytes

e!1e

Probieren Sie es online aus!

Dies ist so einfach wie möglich. eist ein eingebautes Element, das eine Matrix in n Zeilen umformt . Also lesen wir input1 als String ein und formen eine Matrix mit input2- Zeilen:

Hl r!
eowl 
l,od 

Dann transponieren wir es, um Folgendes zu erhalten:

Hel
lo,
 wo
rld
!  

Danach rufen wir einfach 1eauf, um es in eine einzelne Zeile umzuformen und als Zeichenfolge anzuzeigen.

Wie Sie in diesem Beispielprogramm sehen können , fügt die Funktion "Umformen" bequem so viele Nullen hinzu, wie erforderlich sind, damit die Matrix ein perfektes Rechteck ist. Bei der Anzeige als Zeichenfolge behandelt MATL Nullen als Leerzeichen, sodass automatisch die erforderliche Anzahl von Leerzeichen für keine zusätzliche Arbeit ausgefüllt wird.

Gelee , 3 Bytes

sz⁶

TryItOnline!

Wie?

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

Siehe es auf eval.in: https://eval.in/668412

Ungolfed

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

Pyth - 5 Bytes

s.tcF

Probieren Sie es hier online aus .

Python 2, 46 Bytes

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

Die Idee ist, die Eingabezeichenfolge zu nehmen, sie nmit dem ersten Zeichen aus dem entfernten zu kopieren und dann jedes ndritte Zeichen zu nehmen.

Schauen wir uns zum Beispiel an s="abcdef", n=3, wo die Länge ein Vielfaches von ist n:

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

Der erste Zyklus durch die Zeichenfolge nimmt jedes nth-Zeichen vom ersten. Dann verschiebt jeder nachfolgende Zyklus einen Index nach rechts, da das erste Zeichen übersprungen wird. Um sicherzustellen, dass die Länge ein Vielfaches von ist n, wird die anfängliche Zeichenfolge mit Leerzeichen aufgefüllt.

Japt, 15 Bytes

U+SpV f'.pV)y q

Testen Sie es online!

In Japt ist "alle Unterabschnitte der Länge N" integriert, aber weder "alle nicht überlappenden Unterabschnitte" noch "jedes N-te Zeichen". Plötzlich gibt es ein klaffendes Loch in meinem Leben ...

Erläuterung

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]

Testen Sie es auf Ideone .

JavaScript (ES6), 84 Byte

Es ist eine rekursive Lösung.

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

Probieren Sie es auf R-Geige

Dies stellte sich als Kopfschmerz heraus, da R den Eingabevektor automatisch wiederverwendet, wenn die in der Matrixerstellung angegebenen Zeilen oder Spalten nicht ein Vielfaches der Länge der Eingabe sind. Daher müssen wir den Vektor mit -nchar(x)%%nLeerzeichen auffüllen, bevor wir ihn an die Matrixfunktion übergeben.

Der letzte Schritt besteht darin, die Matrix zu transponieren und zu drucken.

Perl, 61 Bytes

54 Bytes an Codes und -F -piFlags.

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

Nimmt die Eingabezeichenfolge ohne letzten Zeilenumbruch und der Schlüssel sollte nach dem -iFlag platziert werden :

$ 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

Vielen Dank an Meilen für die Einsparung von drei Bytes!

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

Unbenannte Funktion mit zwei Argumenten, einem Array von Zeichen und einer Ganzzahl; Gibt ein Array von Zeichen zurück. Der größte Teil des schweren Hebens wird von der ThreadFunktion ausgeführt, die (in diesem Zusammenhang) Zeilen und Spalten austauscht. Partitionmuss mit ein paar nutzlosen Argumenten aufgerufen werden, damit es mit dem fünften Argument aufgefüllt wird " ".

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}

Schreckliche Punktzahl, Tipps geschätzt.

Perl, 87 Bytes

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

Akzeptiert zwei Argumente als Parameter und Verwendung:

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

Testen Sie es hier

Wahrscheinlich der hässlichste Pyth-Code aller Zeiten, aber dies ist mein erster Versuch mit 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)

Wenn jemand Tipps zur Verbesserung meines Golfspiels hat, hinterlasse bitte einen Kommentar!

Eigentlich 12 Bytes

Golfvorschläge sind willkommen, insbesondere wenn Sie eine Golfart finden, um Räume aufzufüllen. Probieren Sie es online aus!

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

Eine weitere 12-Byte-Version

In dieser Version ist die Reihenfolge der Eingaben umgekehrt, dies kann jedoch geändert werden, wenn dies nicht zulässig ist. Golfvorschläge willkommen. Probieren Sie es online aus!

│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

Probieren Sie es hier aus!

C #, 161 Bytes

Es tut mir so leid.

(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 , (nicht konkurrierend) 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()}

Füllen Sie die Eingabe durch die Decke der Größe, die in nStücke unterteilt ist.

Holen Sie sich die aufgefüllte Zeichenfolge als Liste von Zeichen.

In n Stücke zusammenfassen und transponieren.

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

Ergebnisse in:

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

Testskript:

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

Ausgabe:

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 tokenisierte BASIC-Bytes

 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

Der erste Parameter A$ist der Zeichenfolgenwert, den Sie verschlüsseln möchten, und der zweite Aist die Anzahl der Spalten, in die Sie verschlüsseln möchten. Die Variable Cwird verwendet, um nach AZeichen eine neue Zeile einzufügen.

In den Zeilen 4 bis einschließlich 6 werden die Spaltennummern oben im Bildschirmbereich ausgedruckt.

Zeile 7 fügt eine neue Zeile hinzu ( "\r\n"äquivalent).

Die Zeilen 8 bis 13 drucken dann jedes Zeichen von aus A$.

Für dieses Programm ist keine RAM-Erweiterung erforderlich.

K (oK) , 27 Bytes

Lösung:

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

Probieren Sie es online aus!

Erläuterung:

{,/+(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 (Legacy) , 3 Bytes

ôζJ

Die Python-Legacy-Version wird anstelle des Elixir-Umschreibens verwendet, da die neue Version bei der Verwendung nicht implizit Zeichenfolgen in Zeichen konvertiert zip, wie dies bei der alten Version der Fall war .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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