Contract Proposals

[vladtepesch]

I have some proposals for two series of contracts

I post them as different follow ups.

I just want to get feedback if there is some interest in this. Or suggestions or comments.
If there is interest I my try to add it and make a PR. But I am not an JS expert so there would be definitely some work left to do for someone.

[vladtepesch]

Artificial Life

  Artificial Life I - 1D Nanite Computation Simulation

  A 1-dimensional nanite configuration have to be simulated a certain number of cycles.

  All nanites share the same simple program - the Wolfram-Code.
  A nanite can activate or deactivate itself for each cycle and
  is only connected to its n neighbors on each side.
  The activation in next cycle depends on the nantites own and neighbors
  activation in the current cycle.

  For a neighborhood of size n, this means there are 2^(2n+1) possible configurations.
  To each of this possible configurations a new state is assigned.

  Assuming n=1 these are all possible configurations are (in decending order):
     111 110 101 100 011 010 001 000
  and  new states may be:
      1   1   0   1   0   0   0   1
  The concatinated new states form a binary number 11010001_b = 209_dec
  This number is called the Wolfram-Code and is sufficient to describe the
  nanites bahaviour program.

  Nanites configuration is considered to be a ring.
  So nanites at the border of the configuration are connected to the nanites at the other end.

  The Contract:

  You get an input array  with the following elements:
   - a number n denoting the neighborhood size [1, 5]
   - a Wolfram-Code w for this size in the rage [0, 2^(2n+1)-1]
   - a cycle count c to caluculate [10, 1000]
   - an array N with the nanites starting configuration as 0 and 1 and length [50, 1000]
  Output should be a simple 1 dimensional array containing the nanites configuration at cycles g.

  Example:  n   w  c   N
    Input: [1, 110, 2, [0, 1, 0, 0, 0, 0, 1, 1, 1]]
        n = 1
        w = 110_dec = 01101110_bin
            111 110 101 100 011 010 001 000
             0   1   1   0   1   1   1   0
          i/c0  0 1 0 0 0 0 1 1 1
            c1: 1 1 0 0 0 1 1 0 1
    Output: c2: 0 1 0 0 1 1 1 1 1

  Additional References:
    - https://en.wikipedia.org/wiki/Elementary_cellular_automaton
    - https://en.wikipedia.org/wiki/Rule_110
    - https://en.wikipedia.org/wiki/Wolfram_code

  Artifical Life II - 2D Nanite Computation Simulation

  A 2-dimensional nanite configuration have to be simulated a certain number of cycles.

  All nanites share the same simple program - a rule string.
  Each nanite can activate or deactivate itself for each cycles and
  is only connected to its 8 sourounding neighbors.
  The activation in next cycles depends on the nantites neighbors
  activation in the current cycles.

  The rule string has the format [0-8]+/[0-8]+
  where the first number list denotes if a currently active nanite stays active,
  and the second if an inactive gets active.

  Example rule string: 23/3
    - An active nanite stays active if it has 2 or 3 active neighbors.
    - An inactive nanite gets active if it has exactly 3 active neighbors.

  Nanites configuration is considered to be a Torus.
  So nanites at the border of the configuration are connected to the nanites at the other opposite end.
  (left <-> right, top <-> bottom)


  The Contract:

  You get an input array  with the following elements:
   - a rule string r
   - a cycles count c to caluculate [10, 1000]
   - a two dimensional array N with the nanites starting configuration as 0 and 1 and
     dimensions [25, 200]
  Output should be a 2 dimensional array containing the nanites configuration at cycles c.

  Example:     r     c     N
     Input: ["23/3", 2, [
                 [0, 1, 0, 0, 0],
                 [0, 0, 1, 0, 0],
                 [1, 1, 1, 0, 0],
                 [0, 0, 0, 0, 0],
                 [0, 0, 0, 0, 0],
                ]]
            c1: [[0, 0, 0, 0, 0],
                 [1, 0, 1, 0, 0],
                 [0, 1, 1, 0, 0],
                 [0, 1, 0, 0, 0],
                 [0, 0, 0, 0, 0]]

    Output: c2: [[0, 0, 0, 0, 0],
                 [0, 0, 1, 0, 0],
                 [1, 0, 1, 0, 0],
                 [0, 1, 1, 0, 0],
                 [0, 0, 0, 0, 0]]

  Additional References:
  - https://en.wikipedia.org/wiki/Cellular_automaton
  - https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life

  Artifical Life III - 2D Nanite Warfare Simulation

  A 2-dimensional nanite war have to be simulated.

  The simulated world is toroidal (wrapps around at borders left<->right, top<->bottom)
  cell grid space that is populated 
   - 0   - empty space
   - 1   - indistructable wall
   - 2-5 - different nanite strains (0-4)


  For each (non-wall-) cell the new inhabitant is calculated from the cell itself and 
  the neighboring cells. Each inhabitant fights each other and the one with
  the most wins takes over the cell. If there is a draw the cell becomes blank.

  The winner of a fight is determined as follows:
  0 beats 1 and 3
  1 beats 2 and 4
  2 beats 3 and 0
  3 beats 4 and 1
  4 beats 0 and 2
  2 nanites of the same strain does not battle each other is always 
  counted as a win for the strain.
  
  The goal is to simulate the war to a stagnation state (or at most 100 cycles) 
  and return an array with the poupulation count of each cell type.

a fastly hacked together version of these can be viewed here:
https://gistpreview.github.io/?844d5435de8da75c59f7ea49377a3941
(ingore the gol2 - it just was an experimental variation of game of life with areas of different rules - did not turned out that well)

A cool thing that I could imagine to be a quite nice gimmic would be to add a new location in some city "artificial life exhibition" (or something) that scans home for scripts with some special exported function (init(seed):state, step(state):newstate) that then just let the user select one script and displays/plays it.

[vladtepesch]

Image Processing

  Image Processing I - Binarization

  You get a microscopy image from nanite research facility.
  These images are quite noisy.

  Before they can be processed further you have to clean up the 
  image data and mask out the relevant parts.

  Contract

  You get an input image represented by an 2d array with values between 0-255.
  Task is to convert it to a bitmask (a 2d array only containing 0 and 1) that 
  mask the background with 0.
  
  The nanites are always two pixel and always have distance of at 
  least 1 pixel between each others or borders. 
  Nanites are always at least 1.4 times brighter than any of surrounding pixels.

  Example: 
  Input: [[ 86, 100,  91,  98,  98,  88],
          [101, 168,  99,  94, 106,  98],
          [ 92, 189, 109, 198, 182, 109],
          [ 98, 109, 104, 118, 102, 103],
          [100, 109, 215, 210, 113, 129],
          [114, 117, 125, 120, 131, 131]]

  Output: [
            [ 0, 0, 0, 0, 0, 0 ],
            [ 0, 1, 0, 0, 0, 0 ],
            [ 0, 1, 0, 1, 1, 0 ],
            [ 0, 0, 0, 0, 0, 0 ],
            [ 0, 0, 1, 1, 0, 0 ],
            [ 0, 0, 0, 0, 0, 0 ]
          ]

  Image Processing II - Masking

  You get a microscopy image from nanite research facility.
  These images are quite noisy.

  Before they can be processed further you have to clean up the 
  image data and suppress noisy background.

  Contract

  You get an input image represented by an 2d array with values between 0-255.
  Task is to convert it to mask the background with 0 so that only the relevant 
  parts survive.
  
  The nanites are always two pixel and always have distance of at 
  least 1 pixel between each others or borders. 
  Nanites are always at least 1.4 times brighter than any of surrounding pixels.

  Example: 
  Input: [[ 90, 112, 119, 126, 135, 126],
          [ 81,  92, 105, 242, 230, 122],
          [ 76, 214, 110, 114, 125, 138],
          [ 75, 186,  89, 118, 115, 139],
          [ 81,  79,  97, 179, 201, 112],
          [ 78,  93, 102, 111, 115, 107]]

  Output: [[  0,   0,   0,   0,   0,   0],
           [  0,   0,   0, 242, 230,   0],
           [  0, 214,   0,   0,   0,   0],
           [  0, 186,   0,   0,   0,   0],
           [  0,   0,   0, 179, 201,   0],
           [  0,   0,   0,   0,   0,   0]]

  Image Processing III - Connected Components

  You get a preprocessed microscopy image from nanite research facility.
  These background is already masked out and only contains nanites, 
  which should be isolated.

  Contract

  You get an input image represented by an 2d array with values between 0-255.
  Your task is to create a list of cooridnates of each nanites brightest pixel
  and its size.
  
  Note that this are different strain of nanites those sizes may vary.
  The nanites always have distances of at 
  least 1 pixel between each others or borders. 

  Example: 
  Input:  [[  0,   0,   0,   0,   0,   0],
           [  0,   0,   0, 242, 230,   0],
           [  0, 214,   0,   0,   0,   0],
           [  0, 186,   0,   0, 194,   0],
           [  0, 135,   0, 179, 201,   0],
           [  0,   0,   0,   0,   0,   0]]

  Ouput: [[[4, 1], 2], 
          [[1, 2], 3],
          [[4, 4], 3]]
           

[d0sboots]

These seem like good potential CCT problems!

One thing to keep in mind is that CCTs are randomized, so although we often think of problems in groups, with them building on each other, every CCT has to stand on it's own. So, I might suggest picking the single "most interesting" (which is not necessarily the most complicated) problem from those groups, and going with that. (Yes, I know our existing CCTs don't hold to that practice fully.)