Scorrimento di indicizzazione Cha-Cha

12

Introduzione:

Sebbene in origine avessi una canzone olandese nella mia testa, dove i testi sono: " Doe 'n stapje naar voren, en' n stapje terug " (che tradotto in " Fai un piccolo passo avanti e un piccolo passo indietro "), quando Ho cercato il testo completo, mi sono reso conto che andavano avanti e indietro e mai lateralmente.

Quindi, invece, ora uso il testo di Mr C The Slide Man, alias DJ Casper - Cha-Cha Slide per questa sfida.

Se ignoriamo tutto il resto e osserviamo solo le parole "left", "right", "back" e "hop" (ho contato "hop" come forward) inclusi gli importi citati, l'intero brano avrà il seguente elenco ( Sto usando le abbreviazioni LRBH qui):

LBHRLLBHRLBHHRRLLLRLBHHHHRRLLLBHHHHHRLRLRLHRLLBHHLRLBHH

Qui il testo completo della canzone in un frammento di codice JavaScript nascosta (per risparmiare spazio), dove le mosse e gli importi sono racchiusi tra parentesi bloccate:

Mostra snippet di codice

Sfida:

Ora sulla sfida stessa. Prendiamo uno, due o tre ingressi † . Uno di questi è un elenco di numeri interi di indice (quindi non negativi per 0 indicizzati o positivi per 1 indicizzati). (Gli altri input sono opzionali e spiegati nelle regole della sfida.)

Ogni caso di test inizierà in una posizione {x=0, y=0}.
Ora usa la lista di testi delle mosse e rimuovi tutte le mosse dagli indici indicati nella lista di input. Quindi 'cammina' sulle mosse (fino all'indice più grande dell'array di input) e visualizza la posizione in cui finirai.

Le mosse cambieranno le coordinate come segue:
- R: x+1
- L: x-1
- H: y+1
- B:y-1

Regole della sfida:

  • È possibile accedere all'elenco delle mosse nel modo desiderato. †: può essere un input aggiuntivo; può essere in un file separato sul disco da cui leggerai; può trovarsi in una variabile a livello di classe a cui accedi. Essa dovrà essere in forma di L, R, Be Hanche se (può essere una stringa o un carattere-list / array), in modo da non può salvare il mosse-lista come 1s e -1s o interi.
  • L'elenco delle mosse sopra riportato è codificato e sarà sempre lo stesso. (Questo è anche il motivo per cui va bene inserirlo come campo a livello di classe invece di prenderlo come input se questo aiuta il conteggio dei byte della tua risposta.)
  • L'elenco di input può essere indicizzato 0 o indicizzato 1 (fino a te)
  • "Camminiamo" solo verso l'alto ed escludendo l'indice più grande dell'elenco.
    • †: Puoi anche prendere questo ultimo elemento come input intero separato, invece dell'ultimo elemento dell'array di input.
  • L'output delle coordinate xey a cui finiamo può essere in qualsiasi formato ragionevole (array intero contenente due elementi, stringa delimitata, stampato su STDOUT su due linee separate, ecc.)
  • Puoi presumere che l'elenco di input sia ordinato dal più basso al più alto (o dal più alto al più basso se è quello che preferisci, nel qual caso il primo elemento è la dimensione iniziale dell'elenco mosse - se non preso come input separato). E inoltre non conterrà alcun indice duplicato.
  • Se l'indice più grande dell'elenco di input è più grande dell'elenco delle mosse sopra (55 mosse si trovano nell'elenco delle mosse sopra), ci spostiamo di nuovo all'inizio dell'elenco (tutte le volte necessarie a seconda dell'indice più grande dell'input).
  • Puoi eseguire l'output y,xinvece di x,y, ma per favore specifica questo nella tua risposta se lo fai.

Esempio:

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

Ecco le mosse e gli indici (0-indicizzati) uno sopra l'altro:

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

Rimuovendo gli indici della lista di input, rimarremo le seguenti liste di mosse:

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

Ora se camminiamo dalla posizione {0, 0}sopra le mosse rimanenti, avremo le seguenti nuove coordinate dopo ogni mossa:

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

Quindi l'output finale sarà: {-6, 10}

Regole generali:

  • Questo è code-golf , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Le scappatoie predefinite sono vietate.
  • Se possibile, aggiungi un link con un test per il tuo codice.
  • Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi 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
fonte
Possiamo emettere le coordinate in ordine inverso?
— Shaggy,
3
@Shaggy Umm, certo, perché no. Finché lo specifichi chiaramente nella tua risposta.
— Kevin Cruijssen,
@Arnauld Sì, le mosse sono quelle visualizzate e non cambieranno mai. Forse lo chiarirò più chiaramente se non fosse ancora chiaro. (Questo è anche il motivo per cui puoi averlo come campo a livello di codice hardcoded se gioverebbe al conteggio dei byte.)
— Kevin Cruijssen,
L'output può essere una coppia di float?
— Jakob,
1
Molto tardi alla sfida, ma due dei tuoi casi di test sembrano avere input errati per il caso con 1 indice: un extra 82 nel sesto e 29 invece di 39 nel terzo testcase (l'ordinamento indica che potresti aver inteso che essere effettivamente 28/29, ma l'output atteso mostrato proviene dall'uso di 38/39 lì).
— Sundar - Ripristina Monica il

Risposte:

4

05AB1E , 15 12 byte

Salvato 3 byte grazie a Erik the Outgolfer

ÝsKèIêRS¢2ôÆ

Provalo online! o come una suite di test

Spiegazione

Ý                 # 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
fonte
1
Bella risposta! Non lo sapevo nemmeno Æ. Modo intelligente per contare solo tutte le mosse e utilizzare Æper calcolare la differenza per le coppie RLe BH.
— Kevin Cruijssen,
Æè esistito per sempre, no? Suppongo di si, visto che non lo sapevo. Sembra che i comandi che penso siano "nuovi" siano esistiti sin dall'inizio, ma non ho mai saputo come usarli lol. Oh, +1
— Magic Octopus Urn
@MagicOctopusUrn: esiste davvero da sempre;)
— Emigna,
7

Rubino , 98 ... 58 55 byte

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

Provalo online!

Spiegazione:

Il trucco principale sta usando numeri complessi per rappresentare le mosse: 'B' è -i, 'H' è + i, 'L' è -1 e 'R' è +1. Se convertiamo tutte le mosse in numeri complessi, con una sola somma otteniamo il risultato giusto.

Ho provato diversi modi, ma poi ho trovato il numero magico 19: non abbiamo bisogno di giocherellare con la corrispondenza regex perché:

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

Quindi, metti tutto insieme, somma, inverti il ​​segno e il gioco è fatto.

Grazie Jakob per -3 byte

— GB
fonte
Uso intelligente di numeri complessi! Poiché la stringa di spostamento è fissa, è possibile sostituirla (m*c+m)[c]con m[c%55].
— Jakob,
4

JavaScript (ES6), 85 byte

Secondo le regole della sfida, questo codice prevede che la stringa di ambito globale m contenga l'elenco delle mosse. (Salvataggio di 3 byte, come suggerito da @KevinCruijssen.)

Prende l'input come un elenco di indici basati su 0, ordinati dal più basso al più alto.

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]

Provalo online!

Come?

Ogni carattere di spostamento viene convertito nella sua posizione nella stringa di spostamento "LBHR...". Moltiplichiamo il risultato per 3 e applichiamo un modulo 5 , che dà p . Abbiamo quindi:

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

Dove il segno di una mod b è quello di 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
fonte
3

Gelatina , 14 byte

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

Provalo online!

Argomento 1 / Argomento sinistro: indice massimo basato su 1.
Argomento 2 / Argomento destro: indici basati su 1.
Argomento 3: Move-list come stringa. La funzione è ancora riutilizzabile se il terzo argomento della riga di comando viene utilizzato per questo scopo.

— Erik l'Outgolfer
fonte
3

Java 10, 129 119 112 107 100 86 byte

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

Prende il massimo come input aggiuntivo; move-list è un array di caratteri a livello di classe.

Ispirato da @Emigna risposta 05AB1E s' .
-7 byte grazie a @Jakob .
-14 byte grazie a @Geobits .

Provalo online.

Spiegazione:

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]/73si associa alla coordinata x o y in base al carattere ( provalo online ):

Letter    Unicode value    /73

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

s[m%55]*3%5-2è mappato sul personaggio corretto +1o in -1base al personaggio ( Provalo 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
— Kevin Cruijssen
fonte
1
Se si prende l'elenco degli indici come set mutabile, è possibile utilizzare a.add(m)come ifcondizione.
— Jakob,
E int c[]può essere int[]c.
— Jakob,
1
@Jakob Ah, int c[]proveniva da una versione precedente in cui utilizzavo ancora un indice iinvece di utilizzare m. E intelligente di usare un set addinvece di !contains, grazie!
— Kevin Cruijssen,
1
Puoi evitare la sottrazione di byte hogging alla fine usando c[2]for axis (with s[m%55]/73) e percorrendolo con qualcosa del tipo 3*s[m%55]%5-2(vorrei poter vedere un modo per accorciarlo, ma ...). Insieme a un ternario, è 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];}per 98.
— Geobits,
@Geobits Grazie! E -12 byte in più semplicemente restituendo int[]invece di una stringa. :)
— Kevin Cruijssen,
2

Python 3, 85 byte

bè l'elenco dell'indice (a set) ed lè l'indice finale. L'elenco mosse (una stringa o un elenco di caratteri) appare libero come s. Questa è una porta della risposta di Ruby di GB , e una spiegazione dell'approccio può essere trovata 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)

Provalo 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)
— Jakob
fonte
1

Pulito , 148 ... 130 byte

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]

Provalo online!

Definisce la funzione $ :: [Int] -> (Int, Int), prendendo un elenco di indici (dal più piccolo al più grande) da rimuovere dalle mosse prima di foldreseguire le operazioni applicabili (0,0).

— Οurous
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.