Dato un intero k e un blocco di testo o un array 2d che le matrici interne possono avere lunghezze disuguali (che assomigliano a un blocco di testo), ruota ogni carattere o elemento nella colonna k -up su o giù nella posizione successiva quello esiste.

Esempio

Ruota la 20a colonna del seguente testo (basato su 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.

Produzione:

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.

Ruotando la colonna k -esima dello stesso input in cui 35 < k <42 renderebbe invariato il testo di input.

Regole

• È possibile utilizzare testo non elaborato, una matrice di righe, una matrice di caratteri 2D o qualsiasi formato ragionevole per rappresentare i dati. È inoltre possibile utilizzare tipi di dati diversi dai caratteri.
• Il numero di possibili valori del tipo di dati degli elementi deve essere almeno 20 se la lunghezza del codice dipende da esso, altrimenti almeno 2. Questo potrebbe essere un sottoinsieme dei caratteri o altri valori supportati nel tipo nativo.
• Gli spazi e qualsiasi tipo di valori null sono solo valori normali, se li consenti nell'input. Puoi anche semplicemente escluderli nel tipo di elemento.
• Modifica della regola: è possibile riempire le matrici più brevi con un valore predefinito generico (come gli spazi), se si preferisce utilizzare matrici di uguale lunghezza per memorizzare i dati.
• k potrebbe essere basato su 0 o su 1. È garantito che si trovi all'interno della riga più lunga nell'input (il che implica che l'input ha almeno una riga non vuota).
• Puoi scegliere se ruotare su o giù.
• O basta ruotare una posizione o ruotare n posizioni dove n è un numero intero positivo indicato nell'input.
• Il codice più corto vince.

APL (Dyalog Extended) , ^{SBCS da} 9 byte

Programma completo. Richiede stdin per il blocco di testo 2D, quindi k (basato su 0 o basato su 1, a seconda dell'impostazione corrente di APL), quindi n . Positivo n ruota verso l'alto, negativo n ruota verso il basso.

Il dominio è costituito da uno dei seguenti:

1. tutti i caratteri Unicode, tranne gli spazi , lasciano 1114111 valori consentiti, che è superiore ai 20 richiesti.

2. tutti i numeri, tranne 0 , lasciando circa 2 ¹²⁹ valori consentiti, che è superiore ai 20 richiesti.

Poiché APL richiede che i blocchi 2D siano rettangolari, l'input deve essere riempito con spazi / zeri. Questo può essere fatto automaticamente inserendo ↑a sinistra un elenco di stringhe / elenchi numerici.

⎕⌽@≠@⎕⍢⍉⎕

Provalo online! (gli spazi apparenti sono in realtà spazi non spezzanti)

⎕ richiesta di blocco di testo

⍢⍉ mentre trasposto:

 @⎕ applicare quanto segue sulla riga di input:

  @≠ in elementi diversi dal loro prototipo (spazio per i caratteri, zero per i numeri):

   ⎕⌽ ruota i passaggi di "input" a sinistra

APL (Dyalog Unicode) , ^{SBCS da} 22+ byte

Questa versione consente il set completo di caratteri utilizzando zeri come elemento di riempimento identificabile.

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

Provalo online!

Questo ovviamente significa che gli zeri non sono ammessi negli argomenti numerici. Il programma corrispondente per tutti i numeri avrebbe le tre occorrenze di 0sostituito da ' 'e quindi utilizzare lo spazio come riempimento:

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

Se vogliamo veramente tutti gli intervalli di (anche una miscela di) sia caratteri che numeri, potremmo usare null come riempimento:

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

E infine, se volessimo includere valori null e oggetti nel dominio di input, potremmo definire una classe di riempimento e usare istanze di questo come riempimenti:

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

Python 2 , 111 110 109 109 99 98 96 94 byte

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

Provalo online!

Prende l'input come un elenco di righe e una colonna di indice 0 e restituisce un elenco di stringhe.

La colonna è ruotata verso l'alto 1.

_{-11 byte, grazie a Jo King}

Java 8, 107 106 135 107 byte

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 byte per una correzione di bug.

0-indicizzati; ruota verso il basso come nell'esempio.
Input come matrice di caratteri; modifica la matrice di caratteri anziché restituirne una nuova per salvare i byte.

Provalo online.

Spiegazione:

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 byte

-7 byte cambiando in un ternario aritmetico, -9 byte modificando il carattere sul posto (TIL), -4 byte inserendo l'indice su stdin e le stringhe come argomenti, -5 byte usando una stringa anziché una matrice per memorizzare i caratteri rotanti.

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 Provalo online!

Ecco le chiavi per far funzionare questa risposta:

• $array[0]o $string[0]è sempre vuoto
• $array[n]o $string[n]è vuoto se n è maggiore della lunghezza della matrice / stringa
• array[i]=co string[i]=csostituirà l'elemento / carattere.
• In $[$#s<i?0:++j], nonj viene incrementato se .$#s<i

Nella risposta originale a 94 byte, c'era un problema interessante che ho riscontrato durante l'utilizzo <<<della stampa. Ho dovuto usare echoper aggirarlo:

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

Il motivo di ciò può essere visto qui:

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

Le stringhe qui vengono eseguite in subshells perché vengono assegnate come stdin a un altro programma. Se non viene fornito alcun programma, viene implicitamente assegnato cat. Puoi vederlo con <<< $_. <<< $ZSH_SUBSHELLè simile a echo $ZSH_SUBSHELL | cat. Dato che dobbiamo incrementare j, non possiamo essere in una subshell.

R , 62 byte

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

Provalo online!

Accetta input come una matrice di caratteri riempita di spazio. Ruota verso l'alto. Tutto grazie a Kirill L. !

R , 74 byte

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

Provalo online!

Questa presentazione precede il margine di linee imbottite.

Alias substrqui non funzionerà perché stiamo chiamando substre substr<-nella prima riga.

I / O come elenco di linee non imbottite; ruota verso l'alto.

C # (compilatore interattivo Visual C #) , 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;}

Provalo online!

Ringraziamo @ASCIIOnly per aver suggerito foreachche ha portato a un risparmio di 12 byte!

-8 byte grazie a @someone!
-1 byte grazie a @EmbodimentofIgnorance!

Rubino , 57 byte

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

Provalo online!

Accetta input come una matrice di linee a. Ruota il testo verso il basso in posizione 0 k. Ritorna modificando l'ingresso a.

05AB1E , 21 byte

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

Si può sicuramente giocare a golf ancora un po '..

0-indicizzati; input e output entrambi come un elenco di stringhe.
Ruota verso il basso come nell'esempio, ma <può essere sostituito con >per ruotare invece verso l'alto.

Provalo online (il piè di pagina si unisce all'elenco per newline, rimuovilo per vedere l'output effettivo dell'elenco).

Spiegazione:

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

Soluzione:

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

Spiegazione:

Non sono sicuro che mi manchi qualcosa ... 0 indice, ruota verso l'alto (cambia in 1per -1per ruotare verso il basso)

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

Basato su 0 con input e output come stringa multilinea. Ruota verso l'alto di 1.

Deve esserci un metodo più breve!

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

Provalo

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 byte

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

Un collegamento diadico che accetta un elenco di righe (elenchi di caratteri che non contengono caratteri di nuova riga) a sinistra e un numero intero a destra che restituisce un elenco di righe.

Provalo online! (il piè di pagina si divide su newline, chiama il collegamento e si unisce di nuovo a newline)

Come?

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 byte

k è indicizzato 0, ruotare verso il basso

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

TIO

Perl 6 , 38 33 byte

Modifica l'array in atto (le regole non sono vietate)

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

Provalo online!

JavaScript (Node.js) , 52 byte

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

Provalo online!

-7 byte grazie a Shaggy!

Non ho ancora visto una risposta JavaScript! Porta della mia risposta C #.

Carbone , 34 28 21 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta una matrice di stringhe come input. 0-indicizzati. Modifica: ora che PeekDirectionè stato risolto, posso manipolarlo direttamente. Spiegazione:

θ

Stampa le stringhe di input.

Ｊη⁰

Salta all'inizio della colonna da ruotare.

≔ΦＫＤＬθ↓℅ιζ

Estrarre le celle che sono state stampate.

ＵＭζ§ζ⊖κ

Sostituisci ogni cella stampata con il valore della cella precedente (ciclicamente). Convenientemente i valori delle celle vengono letti al momento della PeekDirectionchiamata, quindi il fatto che la MapCommandchiamata scriva nuovi valori nelle celle non ha importanza.

Pip -rn , 32 byte

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

0 indicizzato, ruota verso il basso. Provalo online!

Filtri per trovare gli indici di tutte le righe sufficientemente lunghi per partecipare alla rotazione. Quindi scorre su quelle righe, scambiando il carattere appropriato su ogni riga con una variabile temp s. Visitando di nuovo la prima riga alla fine si scambia nuovamente il valore fittizio.

Gelatina , 19 byte

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

Provalo online!

1-indicizzati. Ruota verso il basso. Un collegamento monadico che accetta un elenco di stringhe di Jelly (un elenco di elenchi di caratteri) riempito a destra come primo argomento e k come secondo. Gli spazi sono vietati nell'input, tranne come riempimento corretto, ma sono ammessi tutti gli altri caratteri.

Come implementato su TIO, il piè di pagina divide un singolo input di stringa in un elenco di stringhe e lo sposta a destra, ma questo è per comodità; a quanto ho capito, al risultato di questo passaggio è consentito l'input per il collegamento principale secondo le regole.

GFortran , 199 byte

_{-20 o giù di lì leggendo dallo stdin anziché da un file
-14 usando numeri interi impliciti per i, k, n
-4 rimuovendo spazi e::}

Richiede all'utente di inserire ke nsulla prima riga, dove si ktrova la colonna da ruotare, ed nè il numero di righe di testo. Gli input successivi sono le righe di testo da ruotare. È stato un dolore da scrivere! Fortran è così 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

• Programma originale e non golfato qui, con commenti e note di compilazione: rotcol.f
• Versione a 203 byte: rextester.com
• Versione a 199 byte (nuova): provala online!

T-SQL, 195 byte

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

Provalo online versione non golfata