Dancing arrays. Output them with some forward-backward moves

Question

The task is to create a program (or a function), which outputs array elements in the order, determined by two numbers F and B. F is number of elements to print, B is the rollback distance (from last printed element). Each element must be printed on separate line and blank line must be inserted after each rollback. Run till the end of array. If endless loop or backward progression requested, program should print nothing and exit. Same for empty arrays.

F and B cannot be negative numbers. Be positive while dancing!

For example, if given:

array is 2, 3, 5, 7, 11, 101, 131;
F is 4;
B is 1;

then output must be:

2
3
5
7

5
7
11
101

11
101
131

Init array, F and B as you like.

Shortest code wins. Imperative beauty will be enjoyed.

Test cases:

Empty array.
Any F.
Any B.

Produces no output (array is empty).

---

Array: [42]
F = 0;
B = 1;

Produces no output (zero elements to print).

---

Array: [42, 17, 84]
F = 2;
B = 1;

Produces no output (endless printing).

---

Array: [7, 16, 65]
F = 2;
B = 3;

Produces no output (will be moving backward to negative indices).

---

Array: [7, 16, 65]
F = 2;
B = 0;

Output:

7
16

16
65

---

Array: [7, 16, 65]
F = 3;
B = 2;

Output:

7
16
65

(no rollback, end of array is reached).

---

Array: [7, 16, 65]
F = 17;
B = 15;

Output:

7
16
65

(run till the end)

---

Array: [7, 16, 65]
F = 17;
B = 16;

Output:

7
16
65

Whole array can be printed in first iteration, run till the end is working, even if F and B form endless-loop condition.

Answer 1

Python 2, 135 128 126 bytes

Pretty naive solution:

a,f,b=input()
b+=1
l=len(a)
i=0
e=min(l,f)
while f>b:
    print'\n'.join(map(str,a)[i:e])+'\n';i=e-b
    if e==l:f=b
    e=min(l,e+f-b)

Try it online!

Input format is [array], F, B except you can also use (). (You can't use {} because that's unordered; thanks to Felipe Batista for pointing that out because I forgot).
Output format is as specified in the challenge, with a single trailing newline at the end of all output and no leading whitespace.

-7 bytes by changing if f>b: while 1: to while f>b
-2 bytes by changing break to f=b because that causes the while loop to exit.

Answer 2

JavaScript, 119 bytes

(a,b,c)=>{o="";for(s=++b;(s<(t=c.length)||s==b)&&s>=0&&b<a;)s-=b,o+=c.slice(s,s+=a<t?a:t).join`
`+`

`;return s>0?o:""}

Try it online!

Receives input in the format F, B, [Array]

Answer 3

Python 2, 116

Finally beat javascript!

Now in case of endless loop outputs full array only if it fits in one step, otherwise ouputs nothing. Output all array in every case of endless loop was harder.

Uncomment different test cases in footer in Try it online

a,F,B=input()
l=len(a)-F;m=F+~B or-1;s=l/m;s+=1+(s*m<l)
for i in range(s):print"\n".join(map(str,a)[m*i:F+i*m]+[''])

Explanation:

  a,F,B=input()
  l=len(a)-F            # length of input array minu F stored to compact code
  m=F+~B or-1           # get the difference beetween blocks of output
                        # if F-B-1 == 0, which means endless loop, makes m = -1, which will make s < 0 and for loop won't execute
  s=l/m                 # get number of blocks (does not count first block)
  s+=1+(s*m<l)          # +1 for first block (brackets are still needed)
                        # s*m<l-F equals +1 for numbers at the end of array, that are not enough to make full block
                        # s becomes 2 in case of F-B-1==0, but it doesn't matter
  for i in range(s):
                        # print elements from slices, joined by line separator
                        # additional empty element added at the end of each block to divide blocks with newline
    print"\n".join(map(str,a)[m*i:F+i*m]+[''])

Answer 4

05AB1E, 41 bytes

gD²³+‹iq}©0U[XD²<+Ÿv¹yè,}¶,³X+U®X³2*+-0‹#

Try it online!

That output format, and inability to limit inputs for F/B made this less fun, will explain soon.

Answer 5

Mathematica, 136 123 bytes

Here's my answer:

""<>r[#~(r=Riffle)~"\n"&/@Quiet@Check[Partition[#,#2,n=#2-#3-1,1,{}]~Take~-Floor[(L=#2-Length@#)/n-1],If[L<0,{},{#}]],"\n\n"]&

(where \ns are replaced by newlines). It's a function that takes a list of strings (e.g. {"1", "2", "3", ...}) and two integers.

Mathematica has a function that almost solves this challenge on its own, namely Partition[#, #2, #2-#3-1, 1, {}]. However, the output format isn't what we want, it returns errors if F and B would put the program into a loop, and it doesn't stop when it reaches the end of a list (so if the inputs are {"1", "2", "3"}, 3, 1, for instance, it returns {{"1", "2", "3"}, {"2", "3"}, {"3"}} instead of just {{"1", "2", "3"}}). We deal with those technicalities as follows:

• ...~Take~-Floor[(L=#2-Length@#)/n-1] gets rid of the extra bits after we hit the end of the list.
• Quiet@Check[...,If[L<0,{},{#}]] deals with the infinite loop cases by Checking if the earlier code gives errors (but it does it Quietly, so it doesn't actually print them), and instead returns an empty list or the entire list as appropriate.
• ""<>r[#~(r=Riffle)~"\n"&/@...,"\n\n"]& formats the output properly, by putting newlines between everything, including double newlines between the separate groups, and string-joins that all together.

Answer 6

Ruby, 78 76 72 bytes

->a,f,b{i=b-=f-1;puts a[i,f]+[""]while 0>b&&a[f+i-=b];b<i&&puts(a[i,f])}

Explanation

• Initialize the index so that the first step brings it back to zero.
• Print f elements from the array starting with the current index, then a newline
• Move the index f-b-1 elements forward, but only if (b-f+1) is negative
• If the increment is not negative, or we reached the end of the array, stop.
• If everything went Ok, the increment is negative, and the index is not (we took at least one step forward), in this case print the remaining elements.

Answer 7

dc, 123 bytes

[[[dx]dx]sOzlF!>O]sO?1+sBsFlFlB-1>O_1sq[lq1+:Rlq1+sqz0<k]dskx0sd[[10PlqlB+sq]sWld0<W]sz[ldlF%0=zlq;Rplq1-dsqld1+sd0!>g]dsgx

Much longer than it should have been because of strict output regulations. Takes input on one line in the format

n_1 n_2 ... n_k F B

where n_i represents the ith element of the k length array. I hope this is an okay input format.

Try it online!