Dado un entero k y un bloque de texto, o una matriz 2D que las matrices internas pueden tener longitudes desiguales (que se asemeja a un bloque de texto), gire cada carácter o elemento en la columna k arriba o hacia abajo a la siguiente posición eso existe.

Ejemplo

Gire la vigésima columna del siguiente texto (basado en 1):

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.

Salida:

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.

Rotando la k -ésima columna de la misma entrada donde 35 < k <42 produciría el texto de entrada sin cambios.

Reglas

• Puede usar texto sin formato, una matriz de líneas, una matriz 2D de caracteres o cualquier formato razonable para representar los datos. También puede usar tipos de datos que no sean caracteres.
• El número de valores posibles del tipo de datos de los elementos debe ser al menos 20 si la longitud de su código depende de ello, de lo contrario, al menos 2. Esto podría ser un subconjunto de los caracteres u otros valores admitidos en el tipo nativo.
• Los espacios y cualquier tipo de valores nulos son solo valores normales, si los permite en la entrada. También puede simplemente excluirlos en el tipo de elemento.
• Cambio de regla: se le permite rellenar las matrices más cortas con un valor predeterminado genérico (como espacios), si prefiere usar matrices de igual longitud para almacenar los datos.
• k podría estar basado en 0 o en 1. Se garantiza que está dentro de la línea más larga de la entrada (lo que implica que la entrada tiene al menos una línea no vacía).
• Puede elegir si gira hacia arriba o hacia abajo.
• Simplemente gire una posición o gire n posiciones donde n es un número entero positivo dado en la entrada.
• El código más corto gana.

APL (Dyalog Extended) , ^{SBCS de} 9 bytes

Programa completo Solicita stdin para el bloque de texto 2D, luego k (basado en 0 o en 1, dependiendo de la configuración actual de APL), luego n . Positivo n rotar hacia arriba, negativo n rotar hacia abajo.

El dominio consta de uno de los siguientes:

1. todos los caracteres Unicode, excepto los espacios , dejando 1114111 valores permitidos, que es más que el requerido 20.

2. todos los números, excepto 0 , dejando aproximadamente 2 ¹²⁹ valores permitidos, que es más que el requerido 20.

Como APL requiere que los bloques 2D sean rectangulares, la entrada debe rellenarse con espacios / ceros. Esto se puede hacer automáticamente ingresando ↑a la izquierda de una lista de cadenas / listas numéricas.

⎕⌽@≠@⎕⍢⍉⎕

Pruébalo en línea! (los espacios aparentes son en realidad espacios que no se rompen)

⎕ solicitud de bloqueo de texto

⍢⍉ mientras se transpone:

 @⎕ aplique lo siguiente en la fila de entrada:

  @≠ en elementos diferentes de su prototipo (espacio para caracteres, cero para números):

   ⎕⌽ gire los pasos de "entrada" a la izquierda

APL (Dyalog Unicode) , ^{SBCS de más de} 22 bytes

Esta versión permite el conjunto completo de caracteres mediante el uso de ceros como elemento de relleno identificable.

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

Pruébalo en línea!

Por supuesto, esto significa que no se permiten ceros en los argumentos numéricos. El programa correspondiente para todos los números tendría las tres ocurrencias de 0reemplazado por ' 'y, por lo tanto, usaría el espacio como relleno:

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

Si realmente queremos los rangos completos de (incluso una mezcla de) caracteres y números, podríamos usar nulo como relleno:

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

Y finalmente, si quisiéramos incluir valores nulos y objetos en el dominio de entrada, podríamos definir una clase de relleno y usar instancias de esto como rellenos:

~∘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)]

Pruébalo en línea!

Toma la entrada como una lista de líneas y una columna de índice 0, y devuelve una lista de cadenas.

La columna se gira hacia arriba 1.

_{-11 bytes, gracias a 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 para una corrección de errores.

0 indexado; gira hacia abajo como el ejemplo.
Entrada como una matriz de caracteres; modifica la matriz de caracteres en lugar de devolver una nueva para guardar bytes.

Pruébalo en línea.

Explicación:

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 cambiando a un ternario aritmético, -9 bytes cambiando el carácter in situ (TIL), -4 bytes ingresando el índice en stdin y las cadenas como argumentos, -5 bytes usando una cadena en lugar de una matriz para almacenar los personajes rotativos.

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

Old Old Old Old ¡ Pruébelo en línea!

Estas son las claves para que esta respuesta funcione:

• $array[0]o $string[0]siempre está vacío
• $array[n]o $string[n]está vacío si n es mayor que la longitud de la matriz / cadena
• array[i]=co string[i]=creemplazará el elemento / personaje.
• En $[$#s<i?0:++j], jse no se incrementa si $#s<i.

En la respuesta original de 94 bytes, me encontré con un problema interesante relacionado con el uso <<<para imprimir. Tuve que usar echopara evitarlo:

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

La razón de esto se puede ver aquí:

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

Aquí las cadenas se ejecutan en subcapas porque se proporcionan como stdin a otro programa. Si no hay un programa dado, se le da implícitamente a cat. Puedes ver esto con<<< $_ . <<< $ZSH_SUBSHELLes similar a echo $ZSH_SUBSHELL | cat. Como necesitamos aumentar j, no podemos estar en una subshell.

R , 62 bytes

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

Pruébalo en línea!

Toma la entrada como una matriz de caracteres rellena con espacio. Rota hacia arriba. Todo gracias a 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}

Pruébalo en línea!

Esta presentación es anterior a la asignación de líneas rellenadas.

Aliasing substraquí no funcionará porque estamos llamando substrysubstr<- en la primera línea.

E / S como una lista de líneas sin relleno; Rota hacia arriba.

C # (compilador interactivo de Visual C #) , 82 bytes

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

Pruébalo en línea!

¡Gracias a @ASCIIOnly por sugerir foreachqué condujo a un ahorro de 12 bytes!

-8 bytes gracias a @someone!
-1 byte gracias a @EmbodimentofIgnorance!

Ruby , 57 bytes

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

Pruébalo en línea!

Toma la entrada como una matriz de líneas a. Gira el texto hacia abajo en la posición basada en 0 k. Regresa modificando la entrada a.

05AB1E , 21 bytes

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

Definitivamente se puede jugar más golf ..

0 indexado; entrada y salida como una lista de cadenas.
Gira hacia abajo como en el ejemplo, pero <se puede reemplazar con >para girar hacia arriba

Pruébelo en línea (el pie de página se une a la lista con nuevas líneas, elimínelo para ver el resultado real de la lista).

Explicación:

ʒ  }             # 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

Solución:

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

Explicación:

No estoy seguro si me falta algo ... 0 índice, gira hacia arriba (cambiar el 1que -1por abajo girar)

{.[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

Basado en 0 con entrada y salida como una cadena de varias líneas. Rota por 1.

¡Debe haber un método más corto!

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

Intentalo

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

Jalea , 16 bytes

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

Un enlace diádico que acepta una lista de líneas (listas de caracteres que no contienen caracteres de nueva línea) a la izquierda y un número entero a la derecha que devuelve una lista de líneas.

Pruébalo en línea!(el pie de página se divide en líneas nuevas, llama al enlace y se une a las líneas nuevas nuevamente)

¿Cómo?

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 está indexado a 0, gira hacia abajo

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

TIO

Perl 6 , 38 33 bytes

Modifica la matriz en su lugar (las reglas no permiten)

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

Pruébalo en línea!

JavaScript (Node.js) , 52 bytes

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

Pruébalo en línea!

-7 bytes gracias a Shaggy!

¡Aún no he visto una respuesta de JavaScript! Puerto de mi respuesta C #.

Carbón , 34 28 21 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma una matriz de cadenas como entrada. 0 indexado. Editar: ahora que PeekDirectionse ha solucionado, puedo manipularlo directamente. Explicación:

θ

Imprime las cadenas de entrada.

Ｊη⁰

Salta a la parte superior de la columna para rotar.

≔ΦＫＤＬθ↓℅ιζ

Extraiga las celdas que se han impreso.

ＵＭζ§ζ⊖κ

Reemplace cada celda impresa con el valor de la celda anterior (cíclicamente). Convenientemente, los valores de las celdas se leen en el momento de la PeekDirectionllamada, por lo que el hecho de que la MapCommandllamada escriba nuevos valores en las celdas no importa.

Pip -rn , 32 bytes

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

0 indexado, gira hacia abajo. Pruébalo en línea!

Filtra para encontrar los índices de todas las filas que son lo suficientemente largas como para participar en la rotación. Luego recorre esas filas, intercambiando el carácter apropiado en cada fila con una variable temporal s. Visitar la primera fila nuevamente al final intercambia el valor ficticio nuevamente.

Jalea , 19 bytes

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

Pruébalo en línea!

1 indexado. Rota hacia abajo. Un enlace monádico que toma una lista rellena a la derecha de cadenas Jelly (una lista de listas de caracteres) como el primer argumento yk como el segundo. Los espacios están prohibidos en la entrada, excepto como relleno correcto, pero se permiten todos los demás caracteres.

Tal como se implementó en TIO, el pie de página divide una entrada de cadena única en una lista de cadenas y las rellena con la derecha, pero esto es por conveniencia; Según tengo entendido, el resultado de ese paso es entrada permitida para el enlace principal según las reglas.

GFortran , 199 bytes

_{-20 más o menos leyendo desde stdin en lugar de un archivo
-14 usando enteros implícitos para i, k, n
-4 mediante la eliminación de espacios y::}

Requiere que el usuario ingrese ky nen la primera línea, donde kestá la columna para rotar, y nes el número de filas de texto. Las entradas posteriores son las líneas de texto a rotar. ¡Fue un dolor de escribir! ¡Fortran es tan pedante!

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

• Programa original sin golf aquí, con comentarios y notas de compilación: rotcol.f
• Versión de 203 bytes: rextester.com
• Versión de 199 bytes (nueva): ¡ Pruébelo en línea!

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

Pruébelo en línea versión sin golf