Overflow-Proof Buffer
Perl, 37 bytes
35 bytes of code + 2 bytes for -lp
flags.
splice@F,1+<>%(@F||1),0,$_}{$_="@F"
Try it online!
The implementation is quite straight forward, splice
inserts in array @F
at index 1+<>%(@F||1)
(note that @F||1
handles the case of the array being empty).
Just a few words about the (seemingly) unmatched braces }{
(because I had a comment about it, and I think it's quite weird for people who don't know Perl), and it's a quite common trick in Perl golfings:
-p
flag surrounds the code with (roughly) while(<>){ CODE } continue { print }
, (the continue
is executed after each iteration). So with those unmatched }{
, I change my code to while(<>) { CODE}{ } continue { print }
. So it creates an empty block right after my code (but that's not a problem), and the continue
is executed only once, after the while
(ie. when the all the input has been read).
ES6 (Javascript), 58,57,53, 50 bytes
Golfed
a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b
Takes an array of index-value pairs, as input.
EDITS
- Use
&&
to return value, -1 byte - Removed
|0
(as splice apparently can handle NaN just well), -2 bytes - Made
b=[]
a second "argument" to map(), -2 bytes (Thx @ETHproductions !) - Replaced b.length with map() index (i), -3 bytes (Thx @Patrick Roberts !)
Test
F=a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b
F([[11, 9], [13, 14]])
[ 11, 13 ]
F([[2, 29], [19, 30], [18, 17], [13, 3], [0, 21], [19, 19], [11, 13], [12, 31], [3, 25]])
[ 2, 13, 3, 11, 0, 12, 19, 18, 19 ]
Haskell, 70 69 bytes
b!(x,i)|b==[]=[x]|j<-1+i`mod`length b=take j b++x:drop j b
foldl(!)[]
Try it online! Usage: foldl(!)[] [(1,5),(2,4),(3,7)]
. Saved one byte thanks to @nimi!
Explanation:
b!(x,i) -- b!(x,i) inserts x into list b at position i+1
| b==[] = [x] -- if b is empty return the list with element x
| j <- 1 + i `mod` length b -- otherwise compute the overflow-save insertion index j
= take j b ++ x : drop j b -- and return the first j elements of b + x + the rest of b
foldl(!)[] -- given a list [(1,2),(3,5),...], insert each element with function ! into the initially empty buffer
Solution without computing the modulus: (90 bytes)
f h t(x,-1)=h++x:t
f h[]p=f[]h p
f h(c:t)(x,i)=f(h++[c])t(x,i-1)
g((x,_):r)=foldl(f[])[x]r
Try it online!