Indexation de la diapositive Cha-Cha

12

Introduction:

Bien que j'avais à l'origine une chanson néerlandaise dans ma tête, où les paroles étaient: " Doe 'n stapje naar voren, en' n stapje terug " (qui se traduisait par " Faites un petit pas en avant et un petit pas en arrière "), quand J'ai cherché les paroles complètes, j'ai réalisé qu'elles ne faisaient que des allers-retours, et jamais de côté.

Donc, à la place, j'utilise maintenant les paroles de Mr C The Slide Man alias DJ Casper - Cha-Cha Slide pour ce défi.

Si nous ignorons tout le reste et ne regardons que les mots "gauche", "droite", "arrière" et "hop" (j'ai compté "hop" comme avant), y compris les montants mentionnés, la chanson complète aura la liste suivante ( J'utilise ici les abréviations LRBH):

LBHRLLBHRLBHHRRLLLRLBHHHHRRLLLBHHHHHRLRLRLHRLLBHHLRLBHH

Voici les paroles complètes de la chanson dans un extrait de code JavaScript caché (pour économiser de l'espace), où les mouvements et les montants sont entourés de crochets bloqués:

Afficher l'extrait de code

Défi:

Passons maintenant au défi lui-même. Nous prenons une, deux ou trois entrées † . L'un d'eux est une liste d'entiers d'index (donc non négatifs pour 0 indexés; ou positifs pour 1 indexés). (Les autres entrées sont facultatives et expliquées dans les règles du défi.)

Chaque scénario de test commencera à une position {x=0, y=0}.
Maintenant, utilisez la liste des paroles des mouvements et supprimez tous les mouvements aux indices donnés de la liste d'entrée. Ensuite, parcourez les mouvements (jusqu'au plus grand index du tableau d'entrée) et affichez la position dans laquelle vous vous retrouverez.

Les mouvements modifieront les coordonnées comme suit:
- R: x+1
- L: x-1
- H: y+1
- B:y-1

Règles du défi:

  • La liste des déplacements est accessible comme vous le souhaitez. †: peut être une entrée supplémentaire; peut être dans un fichier séparé sur le disque à partir duquel vous lirez; peut être dans une variable de niveau classe à laquelle vous accédez. Il devra être sous la forme de L, R, Bet Hbien (peut être une chaîne ou caractère liste / tableau), de sorte que vous ne pouvez pas enregistrer les mouvements liste que 1s et -1s ou entiers.
  • La liste des mouvements donnée ci-dessus est codée en dur et sera toujours la même. (C'est aussi pourquoi il est bon de le mettre comme champ au niveau de la classe au lieu de le prendre comme entrée si cela aide le décompte d'octets de votre réponse.)
  • La liste des entrées peut être à la fois indexée 0 ou indexée 1 (à vous de choisir)
  • Nous ne «marchons» que les mouvements jusqu'à et en excluant le plus grand index de la liste.
    • †: Vous êtes également autorisé à prendre ce dernier élément comme entrée entière séparée, au lieu du dernier élément du tableau d'entrée.
  • La sortie des coordonnées x et y où nous nous trouvons peut être dans n'importe quel format raisonnable (tableau d'entiers contenant deux éléments, chaîne délimitée, imprimée sur STDOUT sur deux lignes séparées, etc.)
  • Vous pouvez supposer que la liste d'entrée est triée du plus bas au plus élevé (ou du plus haut au plus bas si c'est ce que vous préférez, auquel cas le premier élément est la taille initiale de la liste des déplacements - s'il n'est pas pris comme entrée séparée). Et il ne contiendra pas non plus d'index dupliqués.
  • Si le plus grand index de la liste d'entrée est plus grand que la liste des mouvements ci-dessus (55 mouvements sont dans la liste des mouvements ci-dessus), nous revenons au début de la liste (autant de fois que nécessaire en fonction du plus grand index de l'entrée).
  • Vous êtes autorisé à produire à la y,xplace de x,y, mais veuillez le spécifier dans votre réponse si vous le faites.

Exemple:

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

Voici les mouvements et les indices (indexés 0) les uns au-dessus des autres:

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

En supprimant les indices de la liste d'entrée, nous aurons la liste de mouvements suivante:

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

Maintenant, si nous marchons de la position {0, 0}sur les mouvements restants, nous aurons les nouvelles coordonnées suivantes après chaque mouvement:

{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}

La sortie finale sera donc: {-6, 10}

Règles générales:

  • C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
    Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
  • Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
  • Les failles par défaut sont interdites.
  • Si possible, veuillez ajouter un lien avec un test pour votre code.
  • De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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}
code-golf number subsequence Kevin Cruijssen
la source
Pouvons-nous sortir les coordonnées dans l'ordre inverse?
Shaggy
3
@Shaggy Umm, bien sûr, pourquoi pas. Tant que vous le précisez clairement dans votre réponse.
Kevin Cruijssen
@Arnauld Oui, les mouvements sont ceux affichés et ne changeront jamais. Je vais peut-être clarifier cela plus clairement s'il n'était pas encore clair. (C'est aussi pourquoi vous pouvez l'avoir comme champ de niveau de classe codé en dur si cela pourrait profiter à votre nombre d'octets.)
Kevin Cruijssen
La sortie peut-elle être une paire de flotteurs?
Jakob
1
Très tard pour relever le défi, mais deux de vos cas de test semblent avoir une entrée erronée pour le cas indexé 1: 82 supplémentaires dans le sixième, et 29 au lieu de 39 dans le troisième cas de test (le tri indique que vous auriez pu le vouloir pour être réellement 28/29, mais la sortie attendue indiquée est d'utiliser 38/39 là-bas).
sundar

Réponses:

4

05AB1E , 15 12 octets

Sauvegardé 3 octets grâce à Erik l'Outgolfer

ÝsKèIêRS¢2ôÆ

Essayez-le en ligne! ou comme suite de tests

Explication

Ý                 # 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
Emigna
la source
1
Bonne réponse! Je ne savais même pas Æ. Une façon intelligente de simplement compter tous les mouvements et Æde calculer la différence pour les paires RLet BH.
Kevin Cruijssen
Æexiste depuis toujours, n'est-ce pas? Je suppose que oui, vu que je ne le savais pas. On dirait que les commandes que je pense être "nouvelles" existent depuis le début, mais je n'ai jamais su les utiliser lol. Oh, +1
Urne Magic Octopus
@MagicOctopusUrn: Il a en effet existé pour toujours;)
Emigna
7

Ruby , 98 ... 58 55 octets

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

Essayez-le en ligne!

Explication:

L'astuce principale consiste à utiliser des nombres complexes pour représenter les mouvements: «B» est -i, «H» est + i, «L» est -1 et «R» est +1. Si nous convertissons tous les mouvements en nombres complexes, alors avec une seule somme nous obtenons le bon résultat.

J'ai essayé différentes façons, mais j'ai trouvé le numéro magique 19: nous n'avons pas besoin de jouer avec la correspondance regex parce que:

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

Alors, mettez tout cela ensemble, somme, inversez le signe, et nous avons terminé.

Merci Jakob pour -3 octets

GB
la source
Utilisation intelligente des nombres complexes! Puisque la chaîne de déplacement est fixe, vous pouvez la remplacer (m*c+m)[c]par m[c%55].
Jakob
4

JavaScript (ES6), 85 octets

Conformément aux règles de défi, ce code s'attend à ce que la chaîne de portée globale m contienne la liste des mouvements. (Enregistrement de 3 octets, comme suggéré par @KevinCruijssen.)

Prend en entrée une liste d'indices basés sur 0, classés du plus bas au plus élevé.

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]

Essayez-le en ligne!

Comment?

Chaque caractère de déplacement est converti à sa position dans la chaîne de déplacement "LBHR...". On multiplie le résultat par 3 et on applique un modulo 5 , ce qui donne p . On a alors:

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

Où le signe d' un mod b est celui d' un 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
Arnauld
la source
3

Gelée , 14 octets

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

Essayez-le en ligne!

Argument 1 / Argument de gauche: index basé sur 1 maximum.
Argument 2 / Argument de droite: indices basés sur 1.
Argument 3: Moves-list sous forme de chaîne. La fonction est toujours réutilisable si le troisième argument de ligne de commande est utilisé à cet effet.

Erik le Outgolfer
la source
3

Java 10, 129 119 112 112 107 100 86 octets

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;}

Prend le maximum comme entrée supplémentaire; moves-list est un tableau de caractères au niveau de la classe.

Inspiré par @Emigna réponse 05AB1E de .
-7 octets grâce à @Jakob .
-14 octets grâce à @Geobits .

Essayez-le en ligne.

Explication:

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]/73correspond à la coordonnée x ou y selon le personnage ( essayez-le en ligne ):

Letter    Unicode value    /73

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

s[m%55]*3%5-2correspond au bon +1ou en -1fonction du personnage ( essayez-le en ligne ):

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
Kevin Cruijssen
la source
1
Si vous prenez la liste d'index comme un ensemble modifiable, vous pouvez l'utiliser a.add(m)comme ifcondition.
Jakob
Et int c[]peut l'être int[]c.
Jakob
1
@Jakob Ah, int c[]était d'une version précédente où j'utilisais toujours un index iau lieu de l'utiliser m. Et intelligent d'utiliser un ensemble au addlieu de !contains, merci!
Kevin Cruijssen
1
Vous pouvez éviter la soustraction d'octet-hogging à la fin en utilisant c[2]pour l'axe (avec s[m%55]/73) et en le parcourant avec quelque chose comme 3*s[m%55]%5-2(j'aimerais pouvoir voir un moyen de raccourcir cela, mais ...). Avec un ternaire, c'est a->m->{var c=new int[2];for(;m-->0;)c[s[m%55]/73]-=a.add(m)?3*s[m%55]%5-2:0;return c[1]+","+c[0];}pour 98.
Geobits
@Geobits Merci! Et -12 octets de plus en renvoyant simplement le int[]au lieu d'une chaîne. :)
Kevin Cruijssen
2

Python 3, 85 octets

best la liste d'index (a set) et lest l'index de fin. La liste des déplacements (une liste de chaînes ou de caractères) apparaît comme libre s. Il s'agit d'un portage de la réponse Ruby de GB , et une explication de l'approche peut être trouvée ici.

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

Essayez-le en ligne

Non golfé

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

MATL , 16 octets

:wX-)Jw19\^s_&Zj

Essayez-le en ligne!

Prend 3 entrées comme la réponse Jelly, le plus grand index, la liste des index à ignorer et le tableau de 55 caractères.

Sundar - Rétablir Monica
la source
1

Nettoyer , 148 ... 130 octets

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]

Essayez-le en ligne!

Définit la fonction $ :: [Int] -> (Int, Int), en prenant une liste (triée du plus petit au plus grand) des indices à supprimer des mouvements avant de foldrterminer les opérations applicables (0,0).

Οurous
la source