Introdução:

Embora eu originalmente tivesse uma música holandesa na minha cabeça, onde as letras são: " Doe 'e stapje naar voren, en' e stapje terug " (traduzido para " Dê um pequeno passo à frente e um pequeno passo para trás "), quando Procurei as letras completas, percebi que elas só iam e voltavam e nunca para os lados.

Então, agora eu uso as letras do Sr. C The Slide Man, também conhecido como DJ Casper - Cha-Cha Slide, para esse desafio.

Se ignorarmos tudo o resto e apenas olharmos para as palavras "esquerda", "direita", "voltar" e "salto" (contei "salto" como avanço) incluindo as quantias mencionadas, a música completa terá a seguinte lista ( Estou usando as abreviações LRBH aqui):

LBHRLLBHRLBHHRRLLLRLBHHHHRRLLLBHHHHHRLRLRLHRLLBHHLRLBHH

Aqui, a letra da música completa em um trecho de código JavaScript oculto (para economizar espaço), onde os movimentos e as quantias são cercados por colchetes:

To the [left], take it [back] now y'all
One [hop] this time, [right] foot let's stomp
[Left] foot let's stomp, cha cha real smooth

Turn it out, to the [left]
Take it [back] now y'all
One [hop] this time, [right] foot let's stomp
[Left] foot let's stomp, cha cha now y'all

Now it's time to get funky
To the [right] now, to the [left]
Take it [back] now y'all
One [hop] this time, one [hop] this time
[Right] foot [two] stomps, [left] foot [two] stomps
Slide to the [left], slide to the [right]
Criscross, criscross
Cha cha real smooth

Let's go to work
To the [left], take it [back] now y'all
[Two] [hops] this time, [two] [hops] this time
[Right] foot [two] stomps, [left] foot [two] stomps
Hands on your knees, hands on your knees
Get funky with it, aahhhhhhhhhh yaaaa
Come on, cha cha now y'all

Turn it out, to the [left]
Take it [back] now y'all
[Five] [hops] this time
[Right] foot let's stomp, [left] foot let's stomp
[Right] foot again, [left] foot again
[Right] foot let's stomp, [left] foot let's stomp

Freeze, everybody clap yo hands
Come on y'all, check it out
How low can you go?
Can you go down low?
All the way to da floor?
How low can you go?
Can you bring it to the top?
Like it never never stop?
Can you bring it to the top?
One [hop], [right] foot now
[Left] foot now y'all
Cha cha real smooth

Turn it down, to the [left]
Take it [back] now y'all
One [hop] this time, one [hop] this time
Reverse, reverse
Slide to the [left], slide to the [right]
Reverse reverse, reverse reverse
Cha cha now y'all
Cha cha again
Cha cha now y'all
Cha cha again
Turn it down

To the [left], take it [back] now y'all
[Two] [hops] two hops, two hops two hops    EDIT: Made a mistake here, but bit to late to change it now..

Desafio:

Agora, para o desafio em si. Tomamos uma, duas ou três entradas † . Um deles é uma lista de números inteiros de índice (portanto, não negativos para indexados a 0 ou positivos para indexados a 1). (As outras entradas são opcionais e explicadas nas regras de desafio.)

Todo caso de teste começará em uma posição {x=0, y=0}.
Agora use a lista de movimentos das letras e remova todos os movimentos nos índices fornecidos da lista de entrada. Então 'caminhe' sobre os movimentos (até o maior índice do array de entrada) e produza a posição em que você terminará.

Os movimentos mudarão as coordenadas da seguinte maneira:
- R: x+1
- L: x-1
- H: y+1
- B:y-1

Regras do desafio:

• A lista de movimentos pode ser acessada da maneira que você desejar. †: pode ser uma entrada adicional; pode estar em um arquivo separado no disco do qual você lerá; pode estar em uma variável em nível de classe que você acessa. Ele vai ter que ser na forma de L, R, Be Hembora (pode ser uma string ou lista de caracteres / matriz), então você não pode salvar a lista de movimentos como 1s e -1s ou inteiros.
• A lista de movimentos fornecida acima é codificada e sempre será a mesma. (É também por isso que é bom colocá-lo como campo em nível de classe em vez de tomá-lo como uma entrada, se isso ajudar na contagem de bytes de sua resposta.)
• A lista de entrada pode ser indexada em 0 ou 1 (até você)
• Apenas 'andamos' os movimentos até e excluindo o maior índice da lista.
  • †: Você também pode aceitar este último item como entrada inteira separada, em vez do último item da matriz de entrada.
• A saída das coordenadas x e y em que terminamos pode estar em qualquer formato razoável (matriz inteira contendo dois itens, sequência delimitada, impressa em STDOUT em duas linhas separadas, etc.)
• Você pode assumir que a lista de entrada é classificada da mais baixa para a mais alta (ou mais alta para a mais baixa, se preferir. Nesse caso, o primeiro item é o tamanho inicial da lista de movimentos - se não for considerado como entrada separada). E também não conterá índices duplicados.
• Se o maior índice da lista de entrada for maior que a lista de movimentos acima (55 movimentos estão na lista de movimentos acima), seguiremos para o início da lista novamente (quantas vezes for necessário, dependendo do maior índice da entrada).
• Você está autorizado a produzir, em y,xvez de x,y, mas, por favor, especifique isso na sua resposta.

Exemplo:

Entrada: [0,4,8,10,13,14,27,34,42,43,44,50,53,56,59,60,64]

Aqui, os movimentos e índices (indexados com 0) são um sobre o outro:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
L, B, H, R, L, L, B, H, R, L, B, H, H, R, R, L, L, L, R, L, B, H, H, H, H, R, R, L, L, L, B, H, H, H, H, H, R, L, R, L, R, L, H, R, L, L, B, H, H, L, R, L, B, H, H, L, B, H, R, L, L, B, H, R, L

Removendo os índices da lista de entrada, teremos a seguinte lista de movimentos restante:

1, 2, 3, 5, 6, 7, 9,11,12,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31,32,33,35,36,37,38,39,40,41,45,46,47,48,49,51,52,54,55,57,58,61,62,63
B, H, R, L, B, H, L, H, H, L, L, L, R, L, B, H, H, H, H, R, R, L, L, B, H, H, H, H, R, L, R, L, R, L, L, B, H, H, L, L, B, H, L, H, R, B, H, R

Agora, se caminharmos da posição {0, 0}sobre os movimentos restantes, teremos as seguintes novas coordenadas após cada movimento:

{0,0};B,{0,-1};H,{0,0};R,{1,0};L,{0,0};B,{0,-1};H,{0,0};L,{-1,0};H,{-1,1};H,{-1,2};L,{-2,2};L,{-3,2};L,{-4,2};R,{-3,2};L,{-4,2};B,{-4,1};H,{-4,2};H,{-4,3};H,{-4,3};H,{-4,5};R,{-3,5};R,{-2,5};L,{-3,5};L,{-4,5};B,{-4,4};H,{-4,5};H,{-4,6};H,{-4,7};H,{-4,8};R,{-3,8};L,{-4,8};R,{-3,8};L,{-4,8};R,{-3,8};L,{-4,8};L,{-5,8};B,{-5,7};H,{-5,8};H,{-5,9};L,{-6,9};L,{-7,9};B,{-7,8};H,{-7,9};L,{-8,9};H,{-8,10};R,{-7,10};B,{-7,9};H,{-7,10};R,{-6,10}

Portanto, a saída final será: {-6, 10}

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

0-indexed input: [0,4,8,10,13,14,27,34,42,43,44,50,53,56,59,60,64]
1-indexed input: [1,5,9,11,14,15,28,35,43,44,45,51,54,57,60,61,65]
Output: {-6, 10}

0-indexed input: [55]    (Note: There are 55 moves in the unmodified list)
1-indexed input: [56]    (Note: There are 55 moves in the unmodified list)
Output: {-6, 11}

0-indexed input: [0,1,4,5,6,9,10,15,16,17,19,20,27,29,30,37,38,39,41,44,45,46,49,51,52]
1-indexed input: [1,2,5,6,7,10,11,16,17,18,20,21,28,30,31,38,39,40,42,45,46,47,50,52,53]
Output: {10, 16}

0-indexed input: [2,3,7,8,11,12,13,14,18,21,22,23,24,25,26,31,32,33,34,35,36,38,40,42,43,47,48,50,53]
1-indexed input: [3,4,8,9,12,13,14,15,19,22,23,24,25,26,27,32,33,34,35,36,37,39,41,43,44,48,49,51,54]
Output: {-18, -7}

0-indexed input: [0]
1-indexed input: [1]
Output: {0, 0}

0-indexed input: [4,6,7,11,12,13,15,17,20,28,31,36,40,51,59,66,73,74,80,89,92,112,113,114,116,120,122,125,129,134,136,140,145,156,161,162,165,169,171,175,176,178,187,191,200]
1-indexed input: [5,7,8,12,13,14,16,18,21,29,32,37,41,52,60,67,74,75,81,90,93,113,114,115,117,121,123,126,130,135,137,141,146,157,162,163,166,170,172,176,177,179,188,192,201]
Output: {-17, 37}

0-indexed input: [25,50,75,100,125,150,175,200,225,250]
1-indexed input: [26,51,76,101,126,151,176,201,226,251]
Output: {-28, 49}

05AB1E , 15 12 bytes

Economizou 3 bytes graças a Erik the Outgolfer

ÝsKèIêRS¢2ôÆ

Experimente online! ou como um conjunto de testes

Explicação

Ý                 # push range [0 ... input_int]
 sK               # remove all elements in input_list from this range
   è              # cyclically index into the moves-list with the remaining elements
    Iê            # push the unique chars of the move-list, sorted
      R           # reverse
       S¢         # count the occurrences of each char in "RLHB"
         2ô       # split into 2 parts
           Æ      # reduce each part by subtraction

Ruby , 98 ... 58 55 bytes

->a{([*0..a[-1]]-a).sum{|c|-1i**(m[c%55].ord%19)}.rect}

Experimente online!

Explicação:

O truque principal é usar números complexos para representar movimentos: 'B' é -i, 'H' é + i, 'L' é -1 e 'R' é +1. Se convertermos todos os movimentos em números complexos, obteremos o resultado certo com uma única soma.

Tentei de maneiras diferentes, mas encontrei o número mágico 19: não precisamos mexer na correspondência de regex porque:

B  is ASCII 66; 66%19=9  and i^9  = i
H  is ASCII 72; 72%19=15 and i^15 =-i
L  is ASCII 76; 72%19=0  and i^0  = 1
R  is ASCII 82; 82%19=6  and i^6  =-1

Então, junte tudo isso, some, inverta o sinal e pronto.

Obrigado Jakob por -3 bytes

JavaScript (ES6), 85 bytes

De acordo com as regras de desafio, esse código espera que a cadeia de escopo global m mantenha a lista de movimentos. (Salvando 3 bytes, conforme sugerido por @KevinCruijssen.)

Recebe a entrada como uma lista de índices baseados em 0, ordenados do menor para o maior.

a=>a.map(g=i=>j++<i&&g(i,p=m.search(m[~-j%55])*3%5,x+=--p%2,y-=--p%2),j=x=y=0)&&[x,y]

Experimente online!

Quão?

Cada caractere de movimento é convertido para sua posição na sequência de movimentos "LBHR...". Multiplicamos o resultado por 3 e aplicamos um módulo 5 , que fornece p . Temos então:

• dx = ((p-1) mod 2)
• dy = - ((p-2) mod 2)

Onde o sinal de um mod b é o de a .

 character | position | * 3 | mod 5 | dx | dy
-----------+----------+-----+-------+----+----
    'L'    |     0    |  0  |   0   | -1 |  0
    'B'    |     1    |  3  |   3   |  0 | -1
    'H'    |     2    |  6  |   1   |  0 | +1
    'R'    |     3    |  9  |   4   | +1 |  0

Gelatina , 14 bytes

Rḟị⁵ċⱮ⁵QṢṚ¤_2/

Experimente online!

Argumento 1 / Argumento esquerdo: Índice máximo baseado em 1.
Argumento 2 / Argumento correto: índices baseados em 1.
Argumento 3: lista de movimentos como uma sequência. A função ainda será reutilizável se o terceiro argumento da linha de comando for usado para esse fim.

Java 10, 129 119 112 107 100 86 bytes

a->m->{var r=new int[2];for(;m-->0;)r[s[m%55]/73]-=a.add(m)?s[m%55]*3%5-2:0;return r;}

Toma o máximo como entrada adicional; move-list é uma matriz de caracteres no nível de classe.

Inspirado por @Emigna resposta 05AB1E 's .
-7 bytes graças a @Jakob .
-14 bytes graças a @Geobits .

Experimente online.

Explicação:

a->m->{              // Method with Integer-Set & int parameters and int-array return
  var c=new int[2];  //  [x,y] result-array, starting at {0,0}
  for(;m-->0;)       //  Use the `m` input as index, and loop in the range (`m`, 0]
    r[s[m%55]/73]-=  //   Subtract from either x or y based on the character:
     a.add(m)?       //    If the input-set doesn't contain the current index `m`:
      s[m%55]*3%5-2  //     Modify the x or y coordinate based on the character
     :               //    Else:
      0;             //     Leave the x or y coordinate unchanged
  return r;}         //  Return count(R)-count(L) and count(H)-count(B) as result

s[m%55]/73mapeia para a coordenada x ou y, dependendo do caractere ( Experimente on-line ):

Letter    Unicode value    /73

B         66               0
H         72               0
L         76               1
R         82               1

s[m%55]*3%5-2mapeia para o correto +1ou -1depende do personagem ( Experimente online ):

Letter    Unicode value    *3     %5    -2

B         66               198    3     1
H         72               216    1     -1
L         76               228    3     1
R         82               246    1     -1

Python 3, 85 bytes

bé a lista de índices (a set) e lé o índice final. A lista de movimentação (uma lista de cadeias ou caracteres) aparece livre como s. Esta é uma porta da resposta Ruby da GB , e uma explicação da abordagem pode ser encontrada lá.

def f(b,l):r=sum(-1j**(ord(s[i%55])%19)for i in set(range(l))-b);print(r.real,r.imag)

Experimente Online

Ungolfed

def f(b, l):
    r = sum(
        -1j ** (ord(s[i % 55]) % 19)
        for i in set(range(l)) - b
    );
    print(r.real, r.imag)

MATL , 16 bytes

:wX-)Jw19\^s_&Zj

Experimente online!

Aceita 3 entradas, como a resposta Jelly, o maior índice, a lista de índices a serem ignorados e a matriz de 55 caracteres.

Limpo , 148 ... 130 bytes

import StdEnv
$i=foldr(\a(x,y)|any((==)a)i=(x,y)=case m.[a rem 55]of'H'=(x,y+1);'B'=(x,y-1);'L'=(x-1,y);_=(x+1,y))(0,0)[0..last i]

Experimente online!

Define a função $ :: [Int] -> (Int, Int), fazendo com que uma lista de índices (classificados do menor para o maior) seja removida das movimentações antes de foldrconcluir as operações aplicáveis (0,0).