Étant donné un entier k et soit un bloc de texte, soit un tableau 2d dont les tableaux internes peuvent avoir des longueurs inégales (qui ressemble à un bloc de texte), faites pivoter chaque caractère ou élément de la k- ème colonne vers le haut ou vers le bas jusqu'à la position suivante qui existe.

Exemple

Faites pivoter la 20e colonne du texte suivant (basé sur 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.

Sortie:

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.

La rotation de la k la colonne de la même entrée d'où 35 < k <42 donnerait le texte d'entrée sans changement.

Règles

• Vous pouvez utiliser du texte brut, un tableau de lignes, un tableau 2D de caractères ou tout autre format raisonnable pour représenter les données. Vous pouvez également utiliser des types de données autres que des caractères.
• Le nombre de valeurs possibles du type de données des éléments doit être d'au moins 20 si la longueur de votre code en dépend, sinon au moins 2. Il peut s'agir d'un sous-ensemble de caractères ou d'autres valeurs prises en charge dans le type natif.
• Les espaces et tout type de valeurs nulles ne sont que des valeurs normales, si vous les autorisez en entrée. Vous pouvez également simplement les exclure dans le type d'élément.
• Changement de règle: vous êtes autorisé à remplir les tableaux plus courts avec une valeur par défaut générique (comme les espaces), si vous préférez utiliser des tableaux de longueurs égales pour stocker les données.
• k pourrait être basé sur 0 ou basé sur 1. Il est garanti d'être à l'intérieur de la ligne la plus longue de l'entrée (ce qui implique que l'entrée a au moins une ligne non vide).
• Vous pouvez choisir s'il tourne vers le haut ou vers le bas.
• Soit il suffit de faire pivoter une position, soit de faire pivoter n positions où n est un entier positif donné en entrée.
• Le code le plus court gagne.

APL (Dyalog Extended) , 9 octets ^SBCS

Programme complet. Demande stdin pour un bloc de texte 2D, puis k (basé sur 0 ou 1, selon le paramètre actuel d'APL), puis n . Positif n tourne vers le haut, négatif n tourne vers le bas.

Le domaine se compose de l'un des éléments suivants:

1. tous les caractères Unicode, à l' exception des espaces , laissant 1114111 valeurs autorisées, ce qui est supérieur aux 20 requis.

2. tous les nombres, sauf 0 , laissant environ 2 ¹²⁹ valeurs autorisées, ce qui est supérieur aux 20 requis.

Comme APL requiert que les blocs 2D soient rectangulaires, l'entrée doit être complétée par des espaces / zéros. Cela peut être fait automatiquement en entrant ↑à gauche d'une liste de chaînes / listes numériques.

⎕⌽@≠@⎕⍢⍉⎕

Essayez-le en ligne! (les espaces apparents sont en fait des espaces insécables)

⎕ invite pour le bloc de texte

⍢⍉ pendant la transposition:

 @⎕ appliquez ce qui suit sur la ligne d'entrée:

  @≠ à des éléments différents de leur prototype (espace pour les caractères, zéro pour les nombres):

   ⎕⌽ faire pivoter les étapes "d'entrée" vers la gauche

APL (Dyalog Unicode) , 22+ octets ^SBCS

Cette version permet le jeu de caractères complet en utilisant des zéros comme élément de remplissage identifiable.

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

Essayez-le en ligne!

Cela signifie bien sûr que les zéros ne sont pas autorisés dans les arguments numériques. Le programme correspondant pour tous les nombres aurait les trois occurrences de 0remplacé par ' 'et utiliserait donc l'espace comme remplissage:

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

Si nous voulons vraiment les plages complètes (même un mélange de) à la fois des caractères et des nombres, nous pourrions utiliser null comme remplissage:

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

Et enfin, si nous voulions inclure des valeurs nulles et des objets dans le domaine d'entrée, nous pourrions définir une classe de remplissage et utiliser ses instances comme remplissages:

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

Python 2 , 111 110 109 99 98 96 94 octets

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

Essayez-le en ligne!

Prend l'entrée sous la forme d'une liste de lignes et d'une colonne d'index 0 et renvoie une liste de chaînes.

La colonne est tournée vers le haut 1.

_{-11 octets, merci à Jo King}

Java 8, 107 106 135 135 107 octets

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 octets pour une correction de bogue ..

Indexé 0; tourne vers le bas comme dans l'exemple.
Saisie sous forme de matrice de caractères; modifie la matrice de caractères au lieu d'en renvoyer une nouvelle pour économiser des octets.

Essayez-le en ligne.

Explication:

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 octets

-7 octets en passant à un ternaire arithmétique, -9 octets en changeant le caractère en place (TIL), -4 octets en entrant l'index sur stdin et les chaînes comme arguments, -5 octets en utilisant une chaîne au lieu d'un tableau pour stocker les caractères en rotation.

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 Essayez-le en ligne!

Voici les clés pour faire fonctionner cette réponse:

• $array[0]ou $string[0]est toujours vide
• $array[n]ou $string[n]est vide si n est supérieur à la longueur du tableau / de la chaîne
• array[i]=cou string[i]=cremplacera l'élément / le caractère.
• Dans $[$#s<i?0:++j], jn'est pas incrémenté si $#s<i.

Dans la réponse originale de 94 octets, il y avait un problème intéressant concernant l'utilisation <<<de l'impression. Je devais utiliser echopour le contourner:

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

La raison de ceci peut être vue ici:

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

Les chaînes ici sont exécutées en sous-coquilles car elles sont données en tant que stdin à un autre programme. Si aucun programme n'est donné, il est implicitement donné à cat. Vous pouvez le voir avec <<< $_. <<< $ZSH_SUBSHELLest similaire à echo $ZSH_SUBSHELL | cat. Puisque nous devons incrémenter j, nous ne pouvons pas être dans un sous-shell.

R , 62 octets

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

Essayez-le en ligne!

Prend l'entrée comme une matrice de caractères à espace rembourré. Pivote vers le haut. Merci à Kirill L. !

R , 74 octets

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

Essayez-le en ligne!

Cette présentation est antérieure à l'allocation de lignes matelassées.

L'aliasing substrici ne fonctionnera pas car nous appelons substret substr<-sur la première ligne.

E / S sous forme de liste de lignes non remplies; tourne vers le haut.

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

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

Essayez-le en ligne!

Nous remercions @ASCIIOnly d'avoir suggéré ce foreachqui a conduit à une économie de 12 octets!

-8 octets grâce à @someone!
-1 octet grâce à @EmbodimentofIgnorance!

Rubis , 57 octets

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

Essayez-le en ligne!

Prend l'entrée comme un tableau de lignes a. Fait pivoter le texte vers le bas à la position 0 k. Renvoie en modifiant l'entrée a.

05AB1E , 21 octets

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

Peut certainement être joué au golf un peu plus ..

Indexé 0; entrée et sortie sous forme de liste de chaînes.
Il tourne vers le bas comme dans l'exemple, mais <peut être remplacé par >pour tourner vers le haut à la place.

Essayez-le en ligne (le pied de page rejoint la liste par des sauts de ligne, supprimez-le pour voir la sortie réelle de la liste).

Explication:

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

Solution:

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

Explication:

Je ne sais pas si je manque quelque chose ... 0 index, tourne vers le haut (changez le 1pour -1pour faire pivoter vers le bas)

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

Basé sur 0 avec entrée et sortie sous forme de chaîne multi-lignes. Tourne vers le haut de 1.

Il doit y avoir une méthode plus courte!

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

Essayez-le

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

Gelée , 16 octets

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

Un lien dyadique acceptant une liste de lignes (listes de caractères ne contenant aucun caractère de nouvelle ligne) à gauche et un entier à droite qui renvoie une liste de lignes.

Essayez-le en ligne! (le pied de page se divise sur les nouvelles lignes, appelle le lien et rejoint à nouveau par les nouvelles lignes)

Comment?

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 octets

k est indexé 0, faites pivoter vers le bas

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

TIO

Perl 6 , 38 33 octets

Modifie le tableau en place (les règles ne l'interdisent pas)

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

Essayez-le en ligne!

JavaScript (Node.js) , 52 octets

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

Essayez-le en ligne!

-7 octets grâce à Shaggy!

Vous n'avez pas encore vu de réponse JavaScript! Port de ma réponse C #.

Fusain , 34 28 21 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend un tableau de chaînes en entrée. 0 indexé. Edit: Maintenant que cela PeekDirectiona été corrigé, je peux le manipuler directement. Explication:

θ

Imprimez les chaînes d'entrée.

Ｊη⁰

Sautez en haut de la colonne à faire pivoter.

≔ΦＫＤＬθ↓℅ιζ

Extrayez les cellules qui ont été imprimées.

ＵＭζ§ζ⊖κ

Remplacez chaque cellule imprimée par la valeur de la cellule précédente (cycliquement). De manière pratique, les valeurs des cellules sont lues au moment de l' PeekDirectionappel, donc le fait que l' MapCommandappel écrit de nouvelles valeurs dans les cellules n'a pas d'importance.

Pip -rn , 32 octets

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

0 indexé, tourne vers le bas. Essayez-le en ligne!

Filtre pour trouver les indices de toutes les lignes suffisamment longs pour participer à la rotation. Boucle ensuite sur ces lignes, en échangeant le caractère approprié sur chaque ligne avec une variable temporaire s. Visiter à nouveau la première ligne à la fin remplace à nouveau la valeur fictive.

Gelée , 19 octets

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

Essayez-le en ligne!

1 indexé. Pivote vers le bas. Un lien monadique qui prend une première liste de chaînes Jelly (une liste de listes de caractères) comme premier argument et k comme deuxième. Les espaces sont interdits dans l'entrée sauf comme remplissage à droite, mais tous les autres caractères sont autorisés.

Comme implémenté sur TIO, le pied de page divise une entrée de chaîne unique en une liste de chaînes et la place à droite, mais c'est pour plus de commodité; si je comprends bien, le résultat de cette étape est autorisé à entrer pour le lien principal selon les règles.

GFortran , 199 octets

_{-20 environ en lisant depuis stdin plutôt qu'un fichier
-14 en utilisant des entiers implicites pour i, k, n
-4 en supprimant les espaces et::}

Nécessite que l'utilisateur entre ket nsur la première ligne, où se ktrouve la colonne à faire pivoter et nle nombre de lignes de texte. Les entrées suivantes sont les lignes de texte à faire pivoter. C'était pénible à écrire! Fortran est tellement pédant!

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

• Programme original et non golfé ici, avec commentaires et notes de compilation: rotcol.f
• Version 203 octets: rextester.com
• Version 199 octets (nouveau): Essayez-le en ligne!

T-SQL, 195 octets

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

Essayez-le en ligne version non golfée