Bei einer Ganzzahl k und entweder einem Textblock oder einem 2d-Array, dessen innere Arrays möglicherweise ungleich lang sind (ähnlich einem Textblock), drehen Sie jedes Zeichen oder Element in der k- ten Spalte nach oben oder unten zur nächsten Position das existiert.

Beispiel

Drehen Sie die 20. Spalte des folgenden Textes (1-basiert):

A line with more than k characters.
A longer line with more than k character.
A short line.
Rotate here: ------v--
This is long enough.

This is not enough.
Wrapping around to the first line.

Ausgabe:

A line with more thtn k characters.
A longer line with aore than k character.
A short line.
Rotate here: ------m--
This is long enoughv

This is not enough.
Wrapping around to .he first line.

Wenn Sie die k- te Spalte derselben Eingabe drehen, wobei 35 < k <42 ist, wird der Eingabetext unverändert angezeigt.

Regeln

• Sie können Rohtext, ein Array von Zeilen, ein 2D-Array von Zeichen oder ein beliebiges vernünftiges Format zur Darstellung der Daten verwenden. Sie können auch andere Datentypen als Zeichen verwenden.
• Die Anzahl der möglichen Werte des Datentyps der Elemente muss mindestens 20 betragen, wenn Ihre Codelänge davon abhängt, andernfalls mindestens 2. Dies kann eine Teilmenge der Zeichen oder andere Werte sein, die vom systemeigenen Typ unterstützt werden.
• Leerzeichen und alle Arten von Nullwerten sind nur normale Werte, wenn Sie sie in der Eingabe zulassen. Sie können sie auch einfach im Elementtyp ausschließen.
• Regeländerung: Sie können die kürzeren Arrays mit einem allgemeinen Standardwert (z. B. Leerzeichen) auffüllen, wenn Sie Arrays mit gleicher Länge zum Speichern der Daten bevorzugen.
• k könnte 0-basiert oder 1-basiert sein. Es befindet sich garantiert in der längsten Zeile der Eingabe (dies bedeutet, dass die Eingabe mindestens eine nicht leere Zeile enthält).
• Sie können wählen, ob es sich nach oben oder unten dreht.
• Drehen Sie entweder nur um eine Position oder um n Positionen, wobei n eine positive Ganzzahl ist, die in der Eingabe angegeben ist.
• Kürzester Code gewinnt.

APL (Dyalog Extended) , 9 Byte ^SBCS

Volles Programm. Fordert stdin zur Eingabe eines 2D-Textblocks auf, dann k (0-basiert oder 1-basiert, abhängig von der aktuellen Einstellung von APL), dann n . Positive n drehen sich nach oben, negative n drehen sich nach unten.

Die Domain besteht aus einem der folgenden Elemente:

1. Alle Unicode-Zeichen außer Leerzeichen , wobei 1114111 zulässige Werte übrig bleiben, dh mehr als die erforderlichen 20.

2. Alle Zahlen außer 0 lassen ungefähr 2 ¹²⁹ zulässige Werte übrig , was mehr als die erforderlichen 20 sind.

Da für APL rechteckige 2D-Blöcke erforderlich sind, muss die Eingabe mit Leerzeichen / Nullen aufgefüllt werden. Dies kann automatisch erfolgen, indem ↑links von einer Liste von Zeichenfolgen / numerischen Listen eingegeben wird.

⎕⌽@≠@⎕⍢⍉⎕

Probieren Sie es online! (die scheinbaren Räume sind eigentlich nicht unterbrechende Räume)

⎕ Eingabeaufforderung für Textblock

⍢⍉ während transponiert:

 @⎕ Wende in der Eingabezeile Folgendes an:

  @≠ bei Elementen, die sich von ihrem Prototyp unterscheiden (Leerzeichen für Zeichen, Null für Zahlen):

   ⎕⌽ "input" -Schritte nach links drehen

APL (Dyalog Unicode) , über 22 Byte ^SBCS

Diese Version ermöglicht den vollständigen Zeichensatz unter Verwendung von Nullen als identifizierbares Füllelement.

0~¨⍨↓⍉⎕⌽@(0≠⊢)@⎕⍉↑0,¨⎕

Probieren Sie es online!

Dies bedeutet natürlich, dass in numerischen Argumenten keine Nullen zulässig sind. Das entsprechende Programm für alle Zahlen würde die drei Vorkommen von 0durch ersetzen ' 'und daher Leerzeichen als Füllung verwenden:

' '~¨⍨↓⍉⎕⌽@(' '≠⊢)@⎕⍉↑' ',¨⎕

Wenn wir wirklich alle Bereiche (auch nur eine Mischung aus) von Zeichen und Zahlen wollen, könnten wir null als Füllung verwenden:

n~¨⍨↓⍉⎕⌽@(n≠⊢)@⎕⍉↑⎕,¨⍨n←⎕NULL

Und schließlich könnten wir, wenn wir Nullen und Objekte in die Eingabedomäne aufnehmen möchten, eine Füllklasse definieren und Instanzen davon als Füllungen verwenden:

~∘I¨⍨↓⍉⎕⌽@(~⊢∊I←⎕INSTANCES⊢∘C)@⎕⍉↑⎕,¨⍨⎕NEW⎕FIX':Class C' ':EndClass'

Python 2 , 111 110 109 99 98 96 94 Bytes

lambda a,n:[l[:n]+(l[n:]and[L[n]for L in a[i:]+a if L[n:]][1]+l[n+1:])for i,l in enumerate(a)]

Probieren Sie es online!

Nimmt Eingaben als Liste von Zeilen und 0-Index-Spalten und gibt eine Liste von Zeichenfolgen zurück.

Säule ist nach oben gedreht 1.

_{-11 Bytes, danke an Jo King}

Java 8, 107 106 135 107 Bytes

k->m->{int s=m.length,i=-1;for(char p=0,t;i<s;t=m[i%s][k],m[i%s][k]=p<1?t:p,p=t)for(;m[++i%s].length<=k;);}

+29 Bytes für einen Bugfix.

0-indiziert; dreht sich nach unten wie im Beispiel.
Eingabe als Zeichenmatrix; Ändert die Zeichenmatrix, anstatt eine neue zurückzugeben, um Bytes zu sparen.

Probieren Sie es online aus.

Erläuterung:

k->m->{                 // Method with integer and char-matrix parameters and no return-type
  int s=m.length,       //  Amount of lines in the matrix `s`
      i=-1;             //  Index-integer `i`, starting at -1
  for(char p=0,         //  Previous-character, starting at 0
           t;           //  Temp-char, uninitialized
      i<s               //  Loop as long as `i` is smaller than `s`:
      ;                 //    After every iteration:
       t=m[i%s][k],     //     Set the temp to the `k`th character of the `i`'th line
       m[i%s][k]=       //     Replace the `k`'th character of the `i`'th line with:
         p<1?           //      If `p` is still 0:
          t             //       Set it to the temp we just set
         :              //      Else:
          p,            //       Set it to the previous-character instead
       p=t)             //     And then replace `p` with the temp for the next iteration
    for(;m[++i          //   Increase `i` by 1 before every iteration with `++i`,
             %s].length //   And continue this loop until the length of the `i`'th line
           <=k;);}      //   is smaller than or equal to the input `k`

Zsh , 94 87 78 74 69 Bytes

-7 Bytes durch Ändern eines arithmetischen Ternärs, -9 Bytes durch Ändern des vorhandenen Zeichens (TIL), -4 Bytes durch Eingeben des Index für stdin und der Zeichenfolgen als Argumente, -5 Bytes durch Verwenden einer Zeichenfolge anstelle eines Arrays um die rotierenden Zeichen zu speichern.

read i
for s;c+=$s[i]
c=$c[-1]$c
for s;s[i]=$c[$[$#s<i?0:++j]]&&<<<$s

Alt Alt Alt Alt Probieren Sie es online!

Hier sind die Schlüssel dafür, dass diese Antwort funktioniert:

• $array[0]oder $string[0]ist immer leer
• $array[n]oder $string[n]ist leer, wenn n größer als die Länge des Arrays / Strings ist
• array[i]=coder string[i]=cersetzt das Element / Zeichen.
• In $[$#s<i?0:++j], jwird nicht erhöht , wenn $#s<i.

In der ursprünglichen 94-Byte-Antwort gab es ein interessantes Problem mit der Verwendung <<<zum Drucken. Ich musste verwenden echo, um es zu umgehen:

for s;echo $s[0,i-1]$c[$[$#s<i?0:++j]]${s:$i}

Der Grund dafür ist hier zu sehen:

echo $ZSH_SUBSHELL   # prints 0
<<< $ZSH_SUBSHELL    # prints 1

Hier werden Strings in Subshells ausgeführt, da sie einem anderen Programm als stdin übergeben werden. Wenn kein Programm angegeben ist, wird es implizit an gegeben cat. Sie können dies mit sehen <<< $_. <<< $ZSH_SUBSHELList ähnlich wie echo $ZSH_SUBSHELL | cat. Da wir inkrementieren müssen j, können wir uns nicht in einer Unterschale befinden.

R , 62 Bytes

function(L,n){L[A,n]<-rep(L[A<-L[,n]!=' ',n],2)[1+1:sum(A)];L}

Probieren Sie es online!

Nimmt die Eingabe als mit Leerzeichen aufgefüllte Zeichenmatrix auf. Dreht sich nach oben. Vielen Dank an Kirill L. !

R , 74 Bytes

function(L,n){substr(L[A],n,n)=rep(substr(L[A<-nchar(L)>=n],n,n),2)[-1]
L}

Probieren Sie es online!

Diese Übermittlung geht der Berücksichtigung von gepolsterten Zeilen voraus.

Aliasing substrfunktioniert hier nicht, weil wir anrufen substrund substr<-in der ersten Zeile.

E / A als Liste nicht aufgefüllter Zeilen; dreht sich nach oben.

C # (Visual C # Interactive Compiler) , 82 Byte

k=>a=>{var c='0';a.Where(b=>b.Count>k&&((b[k],c)=(c,b[k])).c>0).ToList()[0][k]=c;}

Probieren Sie es online!

Wir danken @ASCIIOnly für den Vorschlag, foreachder zu einer Einsparung von 12 Byte geführt hat!

-8 Bytes dank @someone!
-1 Byte dank @EmbodimentofIgnorance!

Ruby , 57 Bytes

->a,k{b=a.map{|i|i[k]}-[p];c=-2;a.map{|i|i[k]&&=b[c+=1]}}

Probieren Sie es online!

Nimmt die Eingabe als Array von Zeilen a. Dreht den Text auf 0-Basis nach unten k. Kehrt durch Ändern der Eingabe zurück a.

05AB1E , 21 Bytes

ʒg‹}U¹εXyk©diX®<èIèIǝ

Kann auf jeden Fall noch mehr golfen werden ..

0-indiziert; Eingabe und Ausgabe als Liste von Zeichenfolgen.
Es dreht sich wie im Beispiel nach unten, <kann jedoch durch Rotieren >nach oben ersetzt werden.

Probieren Sie es online aus (Fußzeile tritt der Liste durch Zeilenumbrüche bei, entfernen Sie sie, um die tatsächliche Listenausgabe zu sehen).

Erläuterung:

ʒ  }             # Filter the (implicit) input-list by:
 g               #  Where length of the current string
  ‹              #  is larger than the (implicit) input-integer
    U            # Pop and store this filtered list in variable `X`
¹ε               # Map over the first input-list again:
  Xyk            #  Get the index of the current string in variable `X`
     ©           #  Store it in the register (without popping)
      di         #  If the index is not -1, so the current string is present in variable `X`
        X®<è     #   Get the (index-1)'th string in variable `X`
            Iè   #   Get the character at the index of the input-integer
              Iǝ #   And insert it at the index of the input-integer in the current string

K4 , 41 Bytes

Lösung:

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]}

Erläuterung:

Ich bin mir nicht sicher, ob mir etwas fehlt ... 0-Index, dreht sich nach oben (ändern Sie den Wert auf, um nach unten 1zu -1drehen)

{.[x;i;:;.q.rotate[1;x . i:(&y<#:'x;y)]]} / the solution
{                                       } / lambda taking implicit x and y
 .[x; ;:;                              ]  / index apply assignment back into x
         .q.rotate[1;                 ]   / left rotate 1 character
                           (       ; )    / two item list
                                    y     / index to rotate
                               #:'x       / count (#:) each (') input
                             y<           / index less than ?
                            &             / indexes where true
                         i:               / assign to variable w
                     x .                  / index into x
     i                                    / indexes we saved as i earlier

Japt v2.0a0, 18 Bytes

0-basiert mit Eingabe und Ausgabe als mehrzeilige Zeichenfolge. Dreht sich um 1 nach oben.

Es muss eine kürzere Methode geben!

yÈr\S_Y¦V?Z:°TgXrS

Versuch es

yÈr\S_Y¦V?Z:°TgXrS     :Implicit input of string U & integer V
y                      :Transpose
 È                     :Pass each line X at 0-based index Y through the following function & transpose back
  r                    :  Replace
   \S                  :  RegEx /\S/g
     _                 :  Pass each match Z through the following function
      Y¦V              :    Test Y for inequality with V
         ?Z:           :    If true, return Z, else
            °T         :    Increment T (initially 0)
              g        :    Index into
               XrS     :    X with spaces removed

Gelee , 16 Bytes

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦"

Ein dyadischer Link, der links eine Liste von Zeilen (Listen von Zeichen, die keine Zeilenumbrüche enthalten) und rechts eine Ganzzahl akzeptiert, die eine Liste von Zeilen zurückgibt.

Probieren Sie es online! (Die Fußzeile teilt sich in Zeilenumbrüche, ruft den Link auf und verbindet sich wieder durch Zeilenumbrüche)

Wie?

z⁷⁹ịỴFṙ-ṁƲY⁸ṛ⁹¦" - Link: lines L; index I        e.g. example in question; 20
z⁷               - transpose L with filler '\n'       ['AAART\nTW', '   oh\nhr', ...]
  ⁹ị             - Ith item                           'am\nv.\n\nt'
    Ỵ            - split at newlines                  ['am', 'v.', '', 't']
         Ʋ       - last four links as a monad - i.e. f(X):
     F           -   flatten                          'amv.t'
       -         -   -1
      ṙ          -   rotate left by                   'tamv.'
        ṁ        -   mould like X                     ['ta', 'mv', '', '.']
          Y      - join with newlines                 'ta\nmv\n\n.'
                 -   -- call this C
           ⁸     - chain's left argument, L
               " - zip with - i.e. [f(L1,C1), f(L2,C2), ...]:
              ¦  -   sparse application...
             ⁹   -   ...to indices: chain's right argument, I
            ṛ    -   ...of: right argument, Cn

Perl 5 ( -p), 75 Bytes

k ist 0-indiziert, nach unten drehen

s/.*//;$r="^.{$&}";s/
//;/$r(.)/;$c=$1;s/$r\K.(?=(?s:.)*?$r(.)|)/$1||$c/gme

TIO

Perl 6 , 38 33 Bytes

Ändert das Array an Ort und Stelle (Regeln nicht verboten)

{@^a.grep(*>$^b+1)[*;$b].=rotate}

Probieren Sie es online!

JavaScript (Node.js) , 52 Byte

k=>a=>a.filter(b=>b[k]&&([b[k],a]=[a,b[k]]))[0][k]=a

Probieren Sie es online!

-7 Bytes dank Shaggy!

Ich habe noch keine JavaScript-Antwort erhalten! Port meiner C # Antwort.

Kohle , 34 28 21 Bytes

θＪη⁰≔ΦＫＤＬθ↓℅ιζＵＭζ§ζ⊖κ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt ein Array von Strings als Eingabe. 0-indiziert. Edit: Nun, PeekDirectiondas wurde behoben, ich kann es direkt manipulieren. Erläuterung:

θ

Drucken Sie die Eingabezeichenfolgen.

Ｊη⁰

Zum Anfang der zu drehenden Spalte springen.

≔ΦＫＤＬθ↓℅ιζ

Extrahieren Sie die Zellen, die gedruckt wurden.

ＵＭζ§ζ⊖κ

Ersetzen Sie jede gedruckte Zelle durch den Wert der vorherigen Zelle (zyklisch). Praktischerweise werden die Zellenwerte zum Zeitpunkt des PeekDirectionAufrufs gelesen , so dass die Tatsache, dass der MapCommandAufruf neue Werte in die Zellen schreibt, keine Rolle spielt.

Pip -rn , 32 Bytes

POgY#(g@_)>aFI,#gFiyAE@ySsg@i@ag

0-indiziert, dreht sich nach unten. Probieren Sie es online!

Filtert nach den Indizes aller Zeilen, die lang genug sind, um an der Rotation teilzunehmen. Durchlaufen Sie dann diese Zeilen und tauschen Sie das entsprechende Zeichen in jeder Zeile mit einer temporären Variablen aus s. Wenn Sie am Ende die erste Zeile erneut aufrufen, wird der Dummy-Wert wieder ausgeblendet.

Jelly , 19 Bytes

ZnÄ×$ịḟ¹ṙ-;ɗɗʋ€⁹¦⁶Z

Probieren Sie es online!

1-indiziert. Dreht sich nach unten. Ein monadischer Link, der eine mit einem Rechtspolster versehene Liste von Jelly-Zeichenfolgen (eine Liste von Zeichenlisten) als erstes Argument und k als zweites verwendet. Leerzeichen sind in der Eingabe verboten, außer als rechter Abstand, aber alle anderen Zeichen sind zulässig.

Wie in TIO implementiert, teilt die Fußzeile eine einzelne Zeichenfolge in eine Liste von Zeichenfolgen auf und fügt sie mit der rechten Maustaste ein. Soweit ich weiß, ist das Ergebnis dieses Schritts gemäß den Regeln als Eingabe für den Hauptlink zulässig.

GFortran , 199 Bytes

_{-20 oder so durch Lesen von stdin anstelle einer Datei
-14 unter Verwendung impliziter Ganzzahlen füri, k, n
-4 durch Entfernen von Leerzeichen und::}

Erfordert die Eingabe von kund durch den Benutzern in der ersten Zeile, wobei kdie zu drehende Spalte und ndie Anzahl der Textzeilen ist. Nachfolgende Eingaben sind die zu drehenden Textzeilen. Das war ein Schmerz zu schreiben! Fortran ist so pedantisch!

character(99),allocatable::A(:);character(1)r,s
read(*,*)k,n;allocate(A(n))
do i=1,n;read(*,'(A)')A(i);r=A(i)(k:k)
if(r.ne.''.or.r.ne.' ')then;A(i)(k:k)=s;s=r;endif;enddo
A(1)(k:k)=s;print'(A)',A;end

• Original, ungolfed Programm hier, mit Kommentaren und Zusammenstellungsnotizen: rotcol.f
• 203-Byte-Version: rextester.com
• 199-Byte-Version (neu): Probieren Sie es online!

T-SQL, 195 Bytes

WITH C as(SELECT rank()over(order by i)r,sum(1)over()c,*FROM @t
WHERE len(x)>=@)SELECT
isnull(stuff(c.x,@,1,substring(e.x,@,1)),t.x)FROM @t t
LEFT JOIN c ON t.i=c.i
LEFT JOIN c e ON e.r%c.c+1=c.r

Probieren Sie es online ungolfed version