13
\$\begingroup\$

Imagine throwing a rock into a pond. You get to see perfect circles of ripples spreading out over the pond, bouncing off of each other. Of course, nothing can be as serene as that in coding, but, we can try!

Given a point on a 2D array (x, y) and the dimensions of a 2D array/pond (w, h), and a "frame" count, f, return a array of 2D arrays length f that shows a ripple animation starting at (x, y). An ON value (choose between int, bool, or any val for that matter that has two values) should spread out one point in a diamond shape, as the examples show.

Example 1

Input: (0, 0, 3, 3, 7)
Output = a[]
a[0] = 
1 0 0
0 0 0
0 0 0

a[1] = 
0 1 0
1 0 0
0 0 0

a[2] =
0 0 1
0 1 0
1 0 0

a[3] = 
0 0 0
0 0 1
0 1 0

a[4] = 
0 0 0
0 0 0
0 0 1

a[5]+ = 
0 0 0
0 0 0
0 0 0

Example 2

Input: (2, 2, 5, 5, 5)
Output: b
b[0] = 
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0

b[1] = 
0 0 0 0 0
0 0 1 0 0
0 1 0 1 0
0 0 1 0 0
0 0 0 0 0

b[2] =
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1
0 1 0 1 0
0 0 1 0 0

b[3] = 
0 1 0 1 0
1 0 0 0 1
0 0 0 0 0
1 0 0 0 1
0 1 0 1 0

b[4] = 
1 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 0 0 0 1

b[5]+ = 
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

Requirements

  • Output should be an array of an array of an array, or a format that well represents the desired output shown above (comments appreciated on this part)
  • Must be a method
  • Must not use libraries that do everything for you
  • values in the arrays of output must only use 2 unique values
    • this means you can't just return the plain manhattan distance, you must make it a ripple
  • Standard loopholes apply

Information

  • Parameters are (int x, int y, int w, int h, int f)
  • \$0 \le x < w \le 10\$
  • \$0 \le y < h \le 10\$
  • \$0 < f \le 10\$
  • w and h are equal
  • if your language does not support functions, just print to stdout

Test cases:

  • The two examples
  • (3, 2, 5, 5, 3)
  • (0, 0, 1, 1, 1)
  • (1, 2, 3, 3, 4)
  • (4, 4, 10, 10, 10)

Please try to make it testable online, would be appreciated
This is code golf, so shortest code for each language wins!

\$\endgroup\$
9
  • 7
    \$\begingroup\$ If you add bouncing waves off the sides and wave interference, this could be a very interesting question 👀 (not saying you should do those things) \$\endgroup\$
    – Seggan
    Apr 4 at 1:31
  • \$\begingroup\$ I was wondering if I should do that, except I'm not exactly sure how that even works! \$\endgroup\$
    – Chspsa
    Apr 4 at 2:29
  • 8
    \$\begingroup\$ Return an array of 2D arrays and must be a method assume language features. Why those restrictions? \$\endgroup\$
    – Luis Mendo
    Apr 4 at 9:25
  • \$\begingroup\$ If w and h are equal, why take both as input? Also, does the output have to have the Index 1 etc. lines? Finally, you should provide sample outputs for the test cases, rather than just giving a bunch of inputs \$\endgroup\$ Apr 4 at 11:35
  • 1
    \$\begingroup\$ @Chspsa easiest way to fix it is to remove "must be a method" (as we have standard rules for what submissions must be), and changing the first bullet point to something along the lines of "array of matrices, or the closest equivalent in your language" \$\endgroup\$ Apr 4 at 14:57

12 Answers 12

9
\$\begingroup\$

J, 30 27 26 bytes

1 :'i.@u=/1#.(|@-"1]#:i.)'

Try it online!

Using (2 2) 5 f (5 5) as the example:

  • ]#:i. Creates the w,h coordinate system (showing it boxed here for clarity):

    ┌───┬───┬───┬───┬───┐
    │0 0│0 1│0 2│0 3│0 4│
    ├───┼───┼───┼───┼───┤
    │1 0│1 1│1 2│1 3│1 4│
    ├───┼───┼───┼───┼───┤
    │2 0│2 1│2 2│2 3│2 4│
    ├───┼───┼───┼───┼───┤
    │3 0│3 1│3 2│3 3│3 4│
    ├───┼───┼───┼───┼───┤
    │4 0│4 1│4 2│4 3│4 4│
    └───┴───┴───┴───┴───┘
    
  • |@-"1 subtract from x,y and take absolute value:

    ┌───┬───┬───┬───┬───┐
    │2 2│2 1│2 0│2 1│2 2│
    ├───┼───┼───┼───┼───┤
    │1 2│1 1│1 0│1 1│1 2│
    ├───┼───┼───┼───┼───┤
    │0 2│0 1│0 0│0 1│0 2│
    ├───┼───┼───┼───┼───┤
    │1 2│1 1│1 0│1 1│1 2│
    ├───┼───┼───┼───┼───┤
    │2 2│2 1│2 0│2 1│2 2│
    └───┴───┴───┴───┴───┘
    
  • 1#. Sum each cell for the Manhattan distance:

    4 3 2 3 4
    3 2 1 2 3
    2 1 0 1 2
    3 2 1 2 3
    4 3 2 3 4
    
  • i.@u=/ Equality "table" (3d table) with 0, 1, 2, 3, 4:

    0 0 0 0 0
    0 0 0 0 0
    0 0 1 0 0
    0 0 0 0 0
    0 0 0 0 0
    
    0 0 0 0 0
    0 0 1 0 0
    0 1 0 1 0
    0 0 1 0 0
    0 0 0 0 0
    
    0 0 1 0 0
    0 1 0 1 0
    1 0 0 0 1
    0 1 0 1 0
    0 0 1 0 0
    
    0 1 0 1 0
    1 0 0 0 1
    0 0 0 0 0
    1 0 0 0 1
    0 1 0 1 0
    
    1 0 0 0 1
    0 0 0 0 0
    0 0 0 0 0
    0 0 0 0 0
    1 0 0 0 1
    
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Wow! That is really cool! Thank you for sharing this program. \$\endgroup\$
    – Chspsa
    Apr 4 at 2:28
  • \$\begingroup\$ Can your solution leave a flat 'pond' as in the OP's examples or does it always leave the last set of 1s? \$\endgroup\$
    – gotube
    Apr 4 at 20:03
  • \$\begingroup\$ It can leave a flat pond. Just adjust the iteration number (directly left of f in the examples) high enough. \$\endgroup\$
    – Jonah
    Apr 4 at 20:05
7
\$\begingroup\$

Julia 1.0, 55 52 bytes

-3 bytes thanks to @MarcMush

x and y are 1-indexed. Outputs an Array{BitArray{2},1}.

x*y*w*h*f=0:~-f.|>d->@.abs((1:w)-x)+abs((1:h)-y)'==d

Try it online!

It simply generates a 2D matrix consisting of the manhattan distances from the point (x,y).

\$\endgroup\$
3
  • \$\begingroup\$ this is really cool. thanks for posting this solution! \$\endgroup\$
    – Chspsa
    Apr 4 at 14:05
  • \$\begingroup\$ -3 bytes by overloading *: x*y*w*h*f=... Try it online! \$\endgroup\$
    – MarcMush
    Apr 7 at 8:19
  • \$\begingroup\$ @MarcMush Nice, I'll remember that one! \$\endgroup\$ Apr 9 at 3:04
5
\$\begingroup\$

Wolfram Language (Mathematica), 53 bytes

Table[Abs[#1-i]+Abs[#2-j]==k,{k,0,#5},{i,#3},{j,#4}]&

Try it online!

Defines a pure function that takes the inputs x, y, w, h, f (in that order). Constructs a h-by-wmatrix using Table, where each matrix element is either True or False depending on whether the Manhattan distance from (x, y) equals k, an iteration variable corresponding to the kth element in the output array. x and y are 1-indexed. In the TIO I have wrapped the output in Boole so that the output has 0 for Falseand 1 for True.

\$\endgroup\$
4
\$\begingroup\$

R, 62 bytes

\(x,y,d,f,`[`=outer)abs(1:d-x-1)[abs(1:d-y-1),"+"][1:f-1,"=="]

Attempt This Online!

Returns a 3-d logical array--+ is prepended to the function call to make the output more readable.

Computes the manhattan distances of each cell with the starting cell, then computes the equality with each frame number.

\$\endgroup\$
5
  • \$\begingroup\$ Great! I was 1 minute slower but 12 bytes worse! Well done! \$\endgroup\$ Apr 4 at 15:24
  • \$\begingroup\$ @DominicvanEssen I guess you'll have to find a nice Husk solution now! \$\endgroup\$
    – Giuseppe
    Apr 4 at 15:26
  • \$\begingroup\$ Does the Q insist on zero-based coordinates & indexing (I didn't find it)? If not, it seems wasteful (to me...) to use-up 6 bytes just to convert from native R 1-based numbering... \$\endgroup\$ Apr 4 at 15:32
  • \$\begingroup\$ @DominicvanEssen it does quite plainly state the bounds for the inputs, so I went with those. \$\endgroup\$
    – Giuseppe
    Apr 4 at 20:31
  • \$\begingroup\$ Hm, is there anything here that doesn't work within those bounds, though... (probably yes, but I don't immediately see it...)? \$\endgroup\$ Apr 4 at 21:04
3
\$\begingroup\$

PARI/GP, 63 bytes

A port of dingledooper's Julia answer. x and y are 1-indexed. Outputs a vector of matrices.

(x,y,w,h,f)->[matrix(w,h,i,j,abs(i-x)+abs(j-y)==d)|d<-[0..f-1]]

Attempt This Online!

\$\endgroup\$
3
\$\begingroup\$

Factor + math.matrices math.unicode pair-rocket, 80 bytes

[ <iota> [ '[ 2array _ => _ v- vabs Σ _ = ] <matrix-by-indices> ] 4 nwith map ]

Takes input as h w y x f and gives output as a sequence of matrices.

I'm using a modern build of Factor for this, so have a picture:

enter image description here

There are two reasons for that:

  • make-matrix-with-indices is now called <matrix-by-indices>.
  • Values can be fried directly into literals now, so I can say _ => _ instead of _ _ 2array.

See here for a version that runs on TIO at a cost of 7 bytes.

\$\endgroup\$
2
  • \$\begingroup\$ Can your solution leave a flat 'pond' as in the OP's examples or does it always leave the last set of 't's? \$\endgroup\$
    – gotube
    Apr 4 at 20:04
  • \$\begingroup\$ @gotube It works the same way as OP's examples. Try it online! \$\endgroup\$
    – chunes
    Apr 4 at 21:06
3
\$\begingroup\$

05AB1E, 12 (or 17) bytes

F²Lã€αO²ôNQ,

Three inputs in the order: \$f\$, \$d\$, \$[x,y]\$, where \$d\$ is both \$w\$ and \$h\$ since it's guaranteed that \$w==h\$ anyway, and \$[x,y]\$ are 1-based indices. Outputs each matrix on a separated line to STDOUT.

Try it online.

For a more strict I/O as described in the challenge description, it would be 17 bytes instead:

L<²L`âε³>αO}²нôδQ

Try it online.

Explanation:

F            # Loop `N` in the range [0, first (implicit) input `f`):
 ²L          #  Push a list in the range [1, second input `d`]
   ã         #  Create all coordinate-pairs by taking the cartesian product of
             #  itself
    €        #  Map over each coordinate-pair:
     α       #   Calculate the absolute difference with the (implicit) third
             #   input [x,y]
      O      #  Sum each inner pair to get the Manhattan distance
       ²ô    #  Split this list into parts of size `d` to turn it into a matrix
         NQ  #  Check for each value if it equals `N`
           , #  Pop and output this matrix with trailing newline
L            # Push a list in the range [1, first (implicit) input `f`]
 <           # Decrease it by 1 to range [0, f)
  ²          # Push the second input-pair [w,h]
   L         # Transform both to a list in the range [[1,w],[1,h]]
    `        # Pop and push both lists separated to the stack
     â       # Create pairs of both lists with the cartesian power
      ε      # Map over each pair:
       ³     #  Push the third input [x,y]
        >    #  Increase it from a 0-based to 1-based index
         α   #  Take the absolute difference with the current pair
          O  #  Sum to get the Manhattan distance
      }²н    # After the map: push the first value of the second input: w
         ô   # Split the list into parts of that size
          δ  # Apply on the two lists double-vectorized:
           Q #  Check which values in the matrix are equal to the value of the
             #  [0,f) list
             # (after which the list of matrices is output implicitly as result)
\$\endgroup\$
3
\$\begingroup\$

Ruby, 81 bytes

->x,y,w,h,f{(0...f).map{|c|(-y...h-y).map{|m|(-x...w-x).map{|n|m.abs+n.abs==c}}}}

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Java 10, 140 134 bytes

(x,y,w,h,f)->{var r=new int[f][h][w];for(;f-->0;)for(int d=h*w;d-->0;)r[f][d%h][d/h]=Math.abs(d%h-x)+Math.abs(d/h-y)==f?1:0;return r;}

Could technically be 132 bytes since w==h, but this also works for non-square matrices.

Try it online.

Explanation:

(x,y,w,h,f)->{           // Method with the 5 parameters & int[][][] return-type
  var r=new int[f][h][w];//  Result array of `f` amount of `h` by `w` sized
                         //  matrices, filled with 0s by default
  for(;f-->0;)           //  Loop `f` in the range (f,0]:
    for(int d=h*w;d-->0;)//   Inner loop over all cells of a matrix:
      r[f]               //    Modify the matrix at index `f`
          [d%h][d/h]=    //    at the current cell, to:
        Math.abs(d%h-x)  //     Calculate the absolute difference of the current
                         //     cell's x-coordinate and `x`
        +Math.abs(d/h-y) //     Add the same for `y`
        ==f?             //     If this Manhattan distance is equal to `f`:
            1            //      Fill the current cell with a 1
           :0;           //     Else: keep the 0
  return r;}             //  Return the result
\$\endgroup\$
2
  • \$\begingroup\$ man, java is my favorite language, it is super cool how you golfed this language! Thank you for posting this solution \$\endgroup\$
    – Chspsa
    Apr 4 at 14:07
  • \$\begingroup\$ java? close to competitive with python? its more likely than you think! \$\endgroup\$
    – des54321
    Apr 9 at 3:48
1
\$\begingroup\$

Python 3.8 (pre-release), 90 bytes

lambda a,b,c,d,e,R=range:[[[i==abs(k-a)+abs(j-b)for k in R(c)]for j in R(d)]for i in R(e)]

Try it online!

Returns a 2d list of booleans indicating whether or not the Manhattan distance from the original point is equal to the iteration number, for each iteration number from 0 to e (frame count).

\$\endgroup\$
1
\$\begingroup\$

Charcoal, 25 bytes

NθNηNζNεENEε⭆ζ⁼ι⁺↔⁻ηλ↔⁻θν

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

Nθ                          First input as a number
  Nη                        Second input as a number
    Nζ                      Third input as a number
      Nε                    Fourth input as a number
         ï¼®                  Fifth input as a number
        ï¼¥                   Map over implicit range
           ε                Fourth input
          ï¼¥                 Map over implicit range
             ζ              Third input
            ⭆               Map over implicit range and join
               ι            Current frame
              ⁼             Equal to
                   η        Second input
                 ↔⁻         Absolute difference with
                    λ       Current row
                ⁺           Plus
                       θ    First input
                     ↔⁻     Absolute difference with
                        ν   Current column
\$\endgroup\$
1
\$\begingroup\$

Jelly, 10 bytes

Uses Jonah's method of precalculating the Manhattan distance matrix and then filtering for equality with the step number.

;ạ⁵SƲþ/‘=Ɱ

A full-program that accepts [w, h] f [x, y] and prints a list of frames which are each lists of lists of integers 1 (ripple) and 0 (calm). The coordinates, w h x y are all 1-indexed (top-left = [1,1]).

Try it online! (Footer formats the result for ease on the eyes.)

How?

;ạ⁵SƲþ/‘=Ɱ - Main Link: [w, h]; f
      /    - reduce [w, h] by:
     þ     -   table between i in [1..w] and j in [1..h] of:
    Ʋ      -     last four links as a monad - f(i, j):
;          -       concatenate -> [i, j]
  ⁵        -       third program argument = [x, y]
 ạ         -       absolute difference (vectorises) -> [abs(i-x), abs(j-y)]
   S       -       sum -> Manhattan distance of [i, j] from [x, y]
       ‘   - increment (vectorises)
         â±® - map across (implicit range) [1..f] with:
        =  -   equals? (vectorises)
           - implicit print
\$\endgroup\$

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.