One of my favorite memes is the bouncing DVD logo. Yet silly but extremely satisfying, a DVD logo keeps bouncing on a screen and if you ever happened to watch this screensaver, you were most likely anxiously waiting for the logo to exactly hit the corner.

enter image description here

I know part of the fun is the waiting, but let's try to predict when the DVD logo will hit the corner of the screen.


Given the dimensions and initial coordinates of the logo and the size of the grid, calculate when the logo will hit any corner for the first time.


  • In this challenge, the logo will be represented by a rectangle and the screen by a grid. The grid will always be bigger than the logo.
  • The logo's starting movement will be southeast. The logo only moves diagonally. Horizontal and vertical speeds are the same and stays the same.
  • The unit of time for this challenge is represented as a movement of 1 grid square in a certain direction.
  • If the logo already starts in a corner, the expected answer is 0 (the logo is already touching a corner).
  • The initial coordinates of the logo represents the top-left corner of the logo.
  • The starting logo position will not extend outside the grid.
  • You can assume for this challenge that the logo will eventually hit a corner.
  • Input is flexible, read it however you see fit for you.
  • Standard loopholes are not allowed.


In the example below, the initial coordinates of the logo is i=(1,1), the size of the grid is g=(20,20), the dimensions of the dvd logo is d=(10,5).

It took 29 units of time to reach a corner.

enter image description here

Test Cases

i , g , d --> output

#Special cases: logo starting in the four corners
(10,15), (20,20), (10,5) --> 0
(10,0), (20,20), (10,5) --> 0
(0,0), (20,20), (10,5) --> 0
(0,15), (20,20), (10,5) --> 0
#Special cases: logo starting glued to all walls
(0,7), (30,20), (7,12) --> 161
(7,0), (30,20), (7,12) --> 16
(23,3), (30,20), (7,12) --> 69
(11,8), (30,20), (7,12) --> 104
# Other test cases
(1,1), (20,20), (10,5) --> 29
(11,8), (24,50), (7,12) --> 448
(11,8), (50,24), (7,12) --> 376
(5,8), (48,39), (31,3) --> 352

This is , so shortest answers in bytes wins!

  • 5
    \$\begingroup\$ Are we guaranteed that the logo will in fact hit the corner? \$\endgroup\$
    – xnor
    Sep 5 at 19:36
  • 1
    \$\begingroup\$ @xnor Yes, you can assume that for this problem. \$\endgroup\$ Sep 5 at 19:38
  • 8
    \$\begingroup\$ The first gif doesn't hit the corner :( \$\endgroup\$ Sep 6 at 16:54
  • 4
    \$\begingroup\$ Related :) \$\endgroup\$
    – DLosc
    Sep 6 at 20:01
  • 2
    \$\begingroup\$ To confirm @Samathingamajig: At frame 187 out of 223, the gif hits the bottom border, and at frame 188 it hits the left border. \$\endgroup\$
    – Nzall
    Sep 7 at 19:38

10 Answers 10


Wolfram Language (Mathematica), 27 bytes


Try it online!

This is the least \$t\ge0\$ such that \$i+t\equiv0\pmod{g-d}\$.


Python, 59 bytes

-1 thanks to @xnor

f=lambda i,I,g,G,d,D:i%(g-d)+I%(G-D)and-~f(i+1,I+1,g,G,d,D)

Attempt This Online!

Based on the observation that we can "unroll" the box and let the logo fly in a straight line.

  • 5
    \$\begingroup\$ Nice solution! Don't forget the f= and that you can do -~. \$\endgroup\$
    – xnor
    Sep 5 at 20:09

C (gcc), 55 54 bytes


Try it online!

Saved 1 thanks to @G B

f(A,B,x,y,a,b){ function tacking :

  • A B as position
  • x y as grid size
  • a b as logo size

for(x-=a,y-=b stretches grid to remove logo space.

A++%x|B++%y checks if both bounds are reached using positions % new grid sizes

  • \$\begingroup\$ -1 byte by using (y-b) inside the loop instead of y-=b at the beginning \$\endgroup\$
    – G B
    Sep 7 at 5:23
  • \$\begingroup\$ A B as grid size, and x y as position would be nicer naming. :) \$\endgroup\$
    – Kaz
    Sep 7 at 22:29

Jelly,  11  10 bytes

Followed att's description in their Mathematica answer.


A full program that accepts g, d, i and prints the result.

Try it online!


_µ0+⁵ọẠʋ1# - Main Link: grid-dimensions (g), DVD-dimensions (d)
_          - g subtract d (vectorises)
 µ         - start a new monadic chain - f(g-d)
  0        - set the left argument "Step" to 0 (right argument is g-d by default)
         # - count up and find...
        1  - ...the first truthy result of:
       ʋ   -   last four links as a dyad - f(Step, g-d):
    ⁵      -     program's third argument -> initial-state (i)
   +       -     add to Step (vectorises)
     ọ     -     multiplicity (vectorises) (number of times each Step+i value
                                            divides the respective g-d value)
      Ạ    -     all? (are both non-zero?)
           - implicit print

Vyxal, 12 bytes


Try it online! Test suite.

Similar to @att's answer.

λ        ;ṅ   # Find the first positive integer t>0 such that:
 ‹?+   ḊA     #  t-1+x for each x in i are both divisible by, respectively...
    ??-       #  g[0]-d[0] and g[1]-d[1].
           ‹  # Subtract one from this.

Ruby, 56 ... 50 bytes

->r,c,h,w,d,v{a=-r%h-=d;a+=h while(c+a)%(w-v)>0;a}

Try it online!

How it works:

First, unwrap the box, and reduce the coordinates. It will take a steps to reach the vertical boundary, and after that it will take h-d steps to reach the next. So we only need to check if we hit the horizontal boundary every h-d steps.


Java, 73 69 bytes

(i,I,g,G,d,D)->{int r=0;for(;(i-r)%(d-g)+(I-r--)%(D-G)>0;);return~r;}

Port of @att's Mathematical answer.

Try it online.


(i,I,g,G,d,D)->{      // Method with 6 integer parameters and integer return-type
  int r=0;            //  Create a result-integer `r`, starting at 0
  for(;(i-r)%(d-g)    //  Loop as long as (i-r) modulo (d-g)
       +(I-r--)%(D-G) //  and (I-r) modulo (D-G) added together
       >0;);          //  is not 0 yet
                      //  (and decrease `r` by 1 after this check with `r--`)
  return~r;}          //  After the loop, return -r-1 as result

PARI/GP, 51 bytes


Attempt This Online!

A port of @att's Mathematica answer.

PARI/GP, 50 bytes


Attempt This Online!

A port of @loopy walt's Python answer. This is a curried function that takes input as f(g1,g2,d1,d2)(i1,i2).


Charcoal, 34 bytes


Try it online! Link is to verbose version of code. Explanation:


Input the initial coordinates of the logo.


Input the size of the grid.


Subtract the dimensions of the logo from the size of the grid.


Start at 0 units of time.


Move the logo by the current time and wrap it back into the grid. Until the sides of the logo line up with the sides of the grid...


... increment the time.


Output the final time.


05AB1E, 10 bytes


Another port of @att's Mathematica answer, so make sure to upvote him as well!

Inputs in the order \$d,g,i\$.

Try it online or verify all test cases.


-        # Decrease the first two (implicit) inputs from one another: [g₁-d₁, g₂-d₂]
 U       # Pop and store this pair in variable `X`
∞        # Push an infinite positive list: [1,2,3,...]
 <       # Decrease each by 1 to make it a non-negative list: [0,1,2,...]
  .Δ     # Find the first integer `y` in this list which is truthy for:
    +    #  Add it to the third (implicit) input: [i₁+y, i₂+y]
     X   #  Push pair `X`
      Ö  #  Check if the pairs are divisible: [(i₁+y)%(g₁-d₁)==0, (i₂+y)%(g₂-d₂)==0]
       P #  Product to check if both are truthy: ((i₁+y)%(g₁-d₁)==0)*((i₂+y)%(g₂-d₂)==0)
         # (after which the found result is output implicitly)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.