Dado um número k e um bloco de texto ou uma matriz 2D que as matrizes internas possam ter comprimentos desiguais (que se assemelham a um bloco de texto), gire cada caractere ou elemento da k- ésima coluna para cima ou para baixo até a próxima posição isso existe.

Exemplo

Gire a 20ª coluna do seguinte texto (com base em 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.

Saída:

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.

Girar a k- ésima coluna da mesma entrada em que 35 < k <42 produziria o texto de entrada inalterado.

Regras

• Você pode usar texto bruto, uma matriz de linhas, uma matriz 2D de caracteres ou qualquer formato razoável para representar os dados. Você também pode usar outros tipos de dados que não caracteres.
• O número de valores possíveis do tipo de dados dos elementos deve ser pelo menos 20 se o tamanho do código depender dele, caso contrário, pelo menos 2. Esse pode ser um subconjunto dos caracteres ou outros valores suportados no tipo nativo.
• Espaços e qualquer tipo de valor nulo são apenas valores normais, se você os permitir na entrada. Você também pode simplesmente excluí-los no tipo de elemento.
• Alteração de regra: você tem permissão para preencher as matrizes mais curtas com um valor padrão genérico (como espaços), se preferir usar matrizes com comprimentos iguais para armazenar os dados.
• k pode ser baseado em 0 ou baseado em 1. É garantido que ele esteja dentro da linha mais longa da entrada (o que implica que a entrada tenha pelo menos uma linha não vazia).
• Você pode escolher se gira para cima ou para baixo.
• Apenas gire uma posição ou gire n posições onde n é um número inteiro positivo dado na entrada.
• O menor código vence.

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

Programa completo. Solicita ao stdin o bloco de texto 2D e, em seguida, k (com base em 0 ou em 1, dependendo da configuração atual da APL) e, em seguida, n . N positivo gira para cima, n negativo gira para baixo.

O domínio consiste em um dos seguintes:

1. todos os caracteres Unicode, exceto espaços , deixando 1114111 com valores permitidos, mais do que o necessário 20.

2. todos os números, exceto 0 , deixando aproximadamente 2 ¹²⁹ valores permitidos, que é mais do que o necessário 20.

Como o APL exige que os blocos 2D sejam retangulares, a entrada deve ser preenchida com espaços / zeros. Isso pode ser feito automaticamente, digitando ↑à esquerda de uma lista de strings / listas numéricas.

⎕⌽@≠@⎕⍢⍉⎕

Experimente online! (os espaços aparentes são na verdade espaços sem quebra)

⎕ prompt para bloco de texto

⍢⍉ enquanto transposto:

 @⎕ aplique o seguinte na linha de entrada:

  @≠ em elementos diferentes de seu protótipo (espaço para caracteres, zero para números):

   ⎕⌽ gire as etapas de "entrada" para a esquerda

APL (Dyalog Unicode) , mais de 22 bytes ^SBCS

Esta versão permite o conjunto completo de caracteres usando zeros como elemento de preenchimento identificável.

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

Experimente online!

Obviamente, isso significa que zeros não são permitidos em argumentos numéricos. O programa correspondente para todos os números teria as três ocorrências de 0substituídas por ' 'e, portanto, utilizaria o espaço como preenchimento:

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

Se realmente desejamos os intervalos completos de (mesmo uma mistura de) caracteres e números, poderíamos usar null como preenchimento:

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

E, finalmente, se quisermos incluir nulos e objetos no domínio de entrada, poderemos definir uma classe de preenchimento e usar instâncias disso como preenchimentos:

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

Experimente online!

Recebe entrada como uma lista de linhas e coluna de índice 0 e retorna uma lista de cadeias.

A coluna é girada para cima 1.

_{-11 bytes, graças 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 uma correção de bug ..

Indexado a 0; gira para baixo como no exemplo.
Entrada como uma matriz de caracteres; modifica a matriz de caracteres em vez de retornar uma nova para salvar bytes.

Experimente online.

Explicação:

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 alterando para um ternário aritmético, -9 bytes alterando o caractere no local (TIL), -4 bytes inserindo o índice em stdin e as strings como argumentos, -5 bytes usando uma string em vez de uma matriz para armazenar os caracteres rotativos.

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

Velho Velho Velho Velho Experimente online!

Aqui estão as chaves para fazer essa resposta funcionar:

• $array[0]ou $string[0]está sempre vazio
• $array[n]ou $string[n]está vazio se n for maior que o comprimento da matriz / sequência
• array[i]=cou string[i]=csubstituirá o elemento / caractere.
• In $[$#s<i?0:++j], nãoj é incrementado se .$#s<i

Na resposta original de 94 bytes, houve um problema interessante que me deparei com o uso <<<para imprimir. Eu tive que usar echopara contornar isso:

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

A razão para isso pode ser vista aqui:

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

As strings here são executadas em subshells porque são fornecidas como stdin para outro programa. Se não houver um programa, ele é implicitamente atribuído cat. Você pode ver isso com <<< $_. <<< $ZSH_SUBSHELLé semelhante a echo $ZSH_SUBSHELL | cat. Como precisamos incrementar j, não podemos estar em um subshell.

R , 62 bytes

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

Experimente online!

Recebe a entrada como uma matriz de caracteres preenchida com espaço. Gira para cima. Tudo graças 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}

Experimente online!

Este envio antecede a permissão de linhas acolchoadas.

O aliasing substraqui não funcionará porque estamos ligando substre substr<-na primeira linha.

E / S como uma lista de linhas não preenchidas; gira para cima.

C # (compilador interativo do 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;}

Experimente online!

Agradecemos a @ASCIIOnly por sugerir o foreachque resultou em uma economia de 12 bytes!

-8 bytes graças a alguém!
-1 byte graças a @EmbodimentofIgnorance!

Ruby , 57 bytes

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

Experimente online!

Recebe a entrada como uma matriz de linhas a. Gira o texto para baixo na posição baseada em 0 k. Retorna modificando a entrada a.

05AB1E , 21 bytes

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

Definitivamente pode ser jogado um pouco mais ..

Indexado a 0; entrada e saída como uma lista de strings.
Ele gira para baixo como no exemplo, mas <pode ser substituído por >para girar para cima.

Experimente on-line (o rodapé se junta à lista por novas linhas, remova-o para ver a saída real da lista).

Explicação:

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

Solução:

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

Explicação:

Não tenho certeza se estou faltando alguma coisa ... 0 índice, gira para cima (altere 1para -1para girar para baixo)

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

Baseado em 0 com entrada e saída como uma sequência de linhas múltiplas. Gira para cima 1.

Tem que haver um método mais curto!

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

Tente

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

Gelatina , 16 bytes

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

Um link diádico que aceita uma lista de linhas (listas de caracteres que não contêm caracteres de nova linha) à esquerda e um número inteiro à direita que retorna uma lista de linhas.

Experimente online! (o rodapé divide-se em novas linhas, chama o link e junta-se por novas linhas novamente)

Quão?

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 é indexado em 0, gire para baixo

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

TIO

Perl 6 , 38 33 bytes

Modifica a matriz no local (as regras não proíbem)

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

Experimente online!

JavaScript (Node.js) , 52 bytes

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

Experimente online!

-7 bytes graças a Shaggy!

Ainda não encontrou uma resposta em JavaScript! Porta da minha resposta c #.

Carvão , 34 28 21 bytes

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

Experimente online! Link é a versão detalhada do código. Toma uma matriz de seqüências de caracteres como entrada. Indexado a 0. Edit: Agora que PeekDirectionfoi corrigido, eu posso manipulá-lo diretamente. Explicação:

θ

Imprima as seqüências de entrada.

Ｊη⁰

Salte para o topo da coluna a ser girada.

≔ΦＫＤＬθ↓℅ιζ

Extraia as células que foram impressas.

ＵＭζ§ζ⊖κ

Substitua cada célula impressa pelo valor da célula anterior (ciclicamente). Convenientemente, os valores das células são lidos no momento da PeekDirectionchamada, portanto, o fato de a MapCommandchamada gravar novos valores nas células não importa.

Pip -rn , 32 bytes

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

Indexado em 0, gira para baixo. Experimente online!

Filtra para encontrar os índices de todas as linhas que são longas o suficiente para participar da rotação. Em seguida, circula essas linhas, trocando o caractere apropriado em cada linha por uma variável temp s. Visitar a primeira linha novamente no final troca novamente o valor fictício.

Geléia , 19 bytes

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

Experimente online!

1 indexado. Gira para baixo. Um link monádico que leva uma lista preenchida à direita de seqüências de caracteres Jelly (uma lista de listas de caracteres) como o primeiro argumento ek como o segundo. Os espaços são proibidos na entrada, exceto como preenchimento à direita, mas todos os outros caracteres são permitidos.

Conforme implementado no TIO, o rodapé divide uma entrada de string única em uma lista de strings e a coloca com o botão direito, mas isso é por conveniência; Pelo que entendi, o resultado dessa etapa é permitido para a entrada do link principal de acordo com as regras.

GFortran , 199 bytes

_{-20 ou mais lendo stdin em vez de um arquivo
-14 usando números inteiros implícitos para i, k, n
-4 removendo espaços e::}

Requer que o usuário insira ke nna primeira linha, onde kestá a coluna a girar e né o número de linhas de texto. As entradas subsequentes são as linhas de texto a serem giradas. Foi uma pena escrever! Fortran é tão 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 e não destruído aqui, com comentários e notas de compilação: rotcol.f
• Versão de 203 bytes: rextester.com
• Versão de 199 bytes (nova): Experimente 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

Experimente a versão online não destruída