Piet é uma linguagem de programação interessante por várias razões. Hoje vamos nos concentrar em um motivo: o comando roll . O comando roll foi originalmente do PostScript e é uma maneira poderosa de manipular a pilha.

O comando roll exibe os dois principais elementos da pilha e os utiliza como parâmetros. Vamos chamar o primeiro valor popped turnse o segundo depth. Uma volta para a profundidade n pega o elemento mais alto da pilha, torna-o o enésimo elemento na pilha e move cada um dos elementos acima dela para cima um. Se turns for negativo, isso é feito na direção oposta. Ou seja, o enésimo elemento é movido para o topo e os outros elementos são movidos para baixo. Isso é repetido abs(turns)vezes.

Desafio

Escreva um programa ou função que pegue uma pilha e retorne essa pilha depois de executar um rolo.

Regras

• A entrada e a saída podem estar em uma lista, matriz, sequência com um delimitador, transmitidos em um elemento por vez ou em qualquer outro formato razoável. A saída deve estar no mesmo formato que a entrada.
• depth nunca será negativo e nunca será maior que o comprimento da pilha.
• A pilha de entrada sempre conterá pelo menos dois elementos.
• Isso é código-golfe, então a resposta mais curta em cada idioma vence. Como tal, não aceitarei uma resposta.
• As brechas padrão são proibidas.

Casos de teste

in:  out:
2    
4    
1    3
2    4
3    1
4    2
5    5
6    6

in:  out:
-2   
3
1    2
2    3
3    1

in:  out:
-42
0
1    1
2    2
3    3
4    4
5    5

Haskell , 64 62 bytes

Edit: -2 bytes: @xnor viu algo que eu pensava errado.

rpega e retorna uma lista de Ints.

r(t:d:l)|d<1=l|(x,y)<-d%l,(z,w)<-mod t d%x=w++z++y
(%)=splitAt

Experimente online!

splitAt n ldivide uma lista lno índice n, modcalcula o restante da divisão, ++concatena as listas.

JavaScript (ES6), 49 47 bytes

(t,d,...a)=>a.splice(t=(t%d+d)%d,d-t).concat(a)

Editar: salvou 2 bytes graças ao @Shaggy, tomando os elementos da pilha como parâmetros separados. Explicação:

• Quando o turno é múltiplo da profundidade, nada acontece. O primeiro passo é, portanto, calcular a profundidade do módulo de curva. Como o JavaScript sabe apenas como calcular o restante, tenho que fazer isso em duas etapas.
• Uma volta 1move o elemento superior para o depthelemento. Uma volta 2move os dois elementos principais, etc. No entanto, você também pode conseguir isso movendo os elementos entre a volta e a profundidade para a frente. spliceremove esses elementos e os concatanexa aos elementos restantes. (Eu poderia ter usado uma compreensão de matriz, pois tem o mesmo comprimento.)
• Ao contrário slice, o segundo parâmetro para spliceé o número de elementos a serem removidos.

CJam, 31 bytes

)\):N@\,0a|={NW*1$1$>)\+@@<\+}*

Entrada e saída são matrizes na pilha, com o último elemento representando a parte superior da pilha.

Rastreio de pilha:

                   e# Stack:                [6 5 4 3 2 1 4 2]
)                  e# Take out first value: [6 5 4 3 2 1 4] 2
\                  e# Swap:                 2 [6 5 4 3 2 1 4]
)                  e# Take out first value: 2 [6 5 4 3 2 1] 4
:N                 e# Store in N:           2 [6 5 4 3 2 1] 4; N=4
@                  e# Rotate:               [6 5 4 3 2 1] 4 2
\                  e# Swap:                 [6 5 4 3 2 1] 2 4
,                  e# Range:                [6 5 4 3 2 1] 2 [0 1 2 3]
0                  e# Push 0:               [6 5 4 3 2 1] 2 [0 1 2 3] 0
a                  e# Wrap in array:        [6 5 4 3 2 1] 2 [0 1 2 3] [0]
|                  e# Logical or:           [6 5 4 3 2 1] 2 [0 1 2 3]
                   e# (This will replace an empty array with [0] to handle a special case of n=0)
=                  e# Get array value:      [6 5 4 3 2 1] 2
{NW*1$1$>)\+@@<\+} e# Push block:           [6 5 4 3 2 1] 2 {NW*1$1$>)\+@@<\+}
*                  e# Preform n times:      [6 5 4 3 2 1]
  N                e# Push N:               [6 5 4 3 2 1] 4
  W*               e# Negate:               [6 5 4 3 2 1] -4
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1]
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1] -4
  >                e# Slice a[-4:]          [6 5 4 3 2 1] -4 [4 3 2 1]
  )                e# Take first value:     [6 5 4 3 2 1] -4 [4 3 2] 1
  \                e# Swap:                 [6 5 4 3 2 1] -4 1 [4 3 2]
  +                e# Append:               [6 5 4 3 2 1] -4 [1 4 3 2]
  @@               e# Rotate twice:         [1 4 3 2] [6 5 4 3 2 1] -4
  <                e# Slice a[:-4]:         [1 4 3 2] [6 5]
  \                e# Swap:                 [6 5] [1 4 3 2]
  +                e# Append:               [6 5 1 4 3 2]
e# Preform the block again:                 [6 5 2 1 4 3]

Mathematica, 58 50 bytes

Edit: Obrigado a Martin Ender por salvar 8 bytes.

Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&@@#&

Explicação:

Função pura que espera uma lista em que o início da lista represente o topo da pilha. Passamos os elementos da lista para a função pura Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&. xé definido como a sequência de elementos começando com o terceiro argumento., em seguida, rotacionamos o primeiro #2(segundo argumento) dos elementos xpara os #tempos à esquerda (primeiro argumento) e, em seguida, Joinos elementos restantes dex .

Economizaria 3 bytes se apenas passássemos os elementos da pilha como argumentos para a função diretamente, em vez de estarmos em uma lista inicialmente, mas os formatos de entrada e saída não coincidiriam.

Solução original:

#/.{t_,d_,x___}:>{x}~Take~d~RotateLeft~t~Join~Drop[{x},d]&

Há algo realmente satisfatório nessa cadeia de funções infix. Substitui uma lista pelo primeiro elemento t, segundo elemento de elementos restantes xpelo resultado de girar os primeiros delementos {x}para os ttempos esquerdos e unir os elementos restantes de {x}.

Ruby, 40 bytes

x=->s{n,d,*s=s;s[0,d]=s[0,d].rotate n;s}

Experimente online!

Pega a entrada como uma lista, retorna uma lista. O fato de rotateexistir um built-in que pode lidar com rotações positivas e negativas torna isso trivial.

Python, 141 98 87 74 bytes

11 bytes salvos graças ao @Cole

def f(s):*s,d,t=s;n=len(s)-d;return s*0**d or s[:n]+s[-t%d-d:]+s[n:-t%d-d]

Recebe entrada como uma lista, onde o último elemento é o topo da pilha.

Usa o truque 0ⁿ para filtrar a profundidade zero e o operador de módulo de ajuste de sinal do python para determinar a parte da lista a ser cortada.

JavaScript ES6, 109 92 bytes

x=>{for(i=x.shift(),i=i>0?i:-i,j=x.shift();i-->0&&j>0;)x=x.splice(j,1).concat(x);return x}

Experimente online!

Recebe entrada na forma de uma matriz de números inteiros.
Também tem a contagem para a seta: P

Explicação:

O código usa a função shift para extrair os dois primeiros elementos da lista.

Ele então obtém o valor absoluto do primeiro elemento, que é o número de voltas.

Como o Javascript é zero indexado, o índice de profundidade precisa ser diminuído em 1.

Se o índice de profundidade for 0 ou 1, nada deve mudar, mas, devido à diminuição, o índice de 0 causaria alterações. Portanto, saia do loop se o índice de profundidade não for <= 0.

A função de emenda (a, b) retorna a sub-matriz de comprimento b com o índice inicial a da matriz e deixa a matriz original sem esses elementos.

Quando concatenada com o restante da matriz original, essa é uma rotação única da matriz no índice de profundidade.

Executando essa operação n vezes, em que n é o número de voltas, a matriz resultante é o resultado do operador de rolagem.

Python 2 , 48 bytes

lambda r:r[2:r[1]+2][r[0]:]+r[2:r[0]]+r[r[1]+2:]

Experimente online!

TI-Basic, 141 150 bytes (não competitivo)

Prompt L1
L1(1→T
L1(2→D
seq(L1(C),C,3,dim(L1→L1
If TD>0
Then
For(A,1,T
L1(1→B
For(C,2,D
L1(C→L1(C–1
End
B→L1(D
End
End
If TD<0
Then
For(A,1,-T
L1(D→B
For(C,D,2,-1
L1(C–1→L1(C
End
B→L1(1
End
End
L1

Editar: caso fixo em que a profundidade é zero (+9 bytes)

O TI-Basic não suporta listas de tamanho 0, portanto, essa abordagem não funcionará para uma entrada de dois tamanhos.

Explicação:

Prompt L1                # 4 bytes, input list
L1(1→T                   # 7 bytes, turns
L1(2→D                   # 7 bytes, depth
seq(L1(C),C,3,dim(L1→L1   # 18 bytes, remove turns and depth from list
If TD>0                  # 6 bytes, if turns is positive and depth is nonzero (can't be negative)
Then                     # 2 bytes
For(A,1,T                # 7 bytes, do this 'turns' times
L1(1→B                    # 7 bytes, backup the first item
For(C,2,D                # 7 bytes, shuffle the rest along
L1(C→L1(C–1               # 12 bytes
End                      # 2 bytes
B→L1(D                   # 7 bytes, restore the backup to where it should be
End                      # 2 bytes
End                      # 2 bytes
If TD<0                  # 6 bytes, if T is negative and D is nonzero
Then                     # 2 bytes
For(A,1,-T               # 8 bytes, do this -'turns' times
L1(D→B                   # 7 bytes, backup the Dth item
For(C,D,2,-1             # 10 bytes, shuffle the items the other way
L1(C–1→L1(C              # 12 bytes
End                      # 2 bytes
B→L1(1                   # 7 bytes, restore backup to where it belongs
End                      # 2 bytes
End                      # 2 bytes
L1                       # 2 bytes, implicitly return

Lote, 163 bytes

@set s=
@set r=
@set/ad=%2,t=(%1%%d+d)%%d
:l
@shift
@set/af=t-=1,f^^=d-=1
@if %f% lss 0 (set r=%r% %2)else set s=%s% %2
@if not "%3"=="" goto l
@echo%r%%s%

Recebe a entrada como parâmetros da linha de comando e gera uma lista separada por espaços. Os parâmetros entre te dsão extraídos na rvariável para que possam ser anexados à svariável, que recebe todos os outros parâmetros.