From 618a1122226920fe693fa65cfeae22444d68776d Mon Sep 17 00:00:00 2001
From: Morry Kolman <morristskolman@gmail.com>
Date: Sat, 3 Feb 2024 00:52:33 -0500
Subject: [PATCH] added 033

---
 033/instructions.md  |   3 +
 033/paperSolve.html  | 217 +++++++++++++++++++++++++++++++++++++++++++
 050A/instructions.md |   3 +
 050A/paperSolve.html | 198 +++++++++++++++++++++++++++++++++++++++
 33/instructions.md   |   3 +
 33/paperSolve.html   | 198 +++++++++++++++++++++++++++++++++++++++
 50A/paperSolve.html  |  10 +-
 7 files changed, 629 insertions(+), 3 deletions(-)
 create mode 100644 033/instructions.md
 create mode 100644 033/paperSolve.html
 create mode 100644 050A/instructions.md
 create mode 100644 050A/paperSolve.html
 create mode 100644 33/instructions.md
 create mode 100644 33/paperSolve.html
diff --git a/033/instructions.md b/033/instructions.md
new file mode 100644
index 0000000..3630fa1
--- /dev/null
+++ b/033/instructions.md
@@ -0,0 +1,3 @@
+# Wall Drawing #50A (1970)
+
+A wall divided into four parts by lines drawn corner to corner. Each section with three different colors made of parallel lines superimposed. Color pencil.
\ No newline at end of file
diff --git a/033/paperSolve.html b/033/paperSolve.html
new file mode 100644
index 0000000..c7dbe8d
--- /dev/null
+++ b/033/paperSolve.html
@@ -0,0 +1,217 @@
+<html>
+  <head>
+    <meta>
+
+      <title>Solving Sol</title>
+      <!-- Load latest acron version first -->
+      <script type="text/javascript" src="https://unpkg.com/acorn"></script>
+      <!-- Then load Paper.js -->
+      <script type="text/javascript" src="https://unpkg.com/paper"></script>
+      <!-- <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/paper.js/0.9.18/paper-full.min.js" ></script> -->
+      <style type="text/css">
+
+        html, body {
+          width: 100%;
+          height: 100%;
+          overflow: hidden;
+          padding: 0;
+          margin: 0;
+          display: flex;
+          justify-content: center;
+          align-items: center;
+          background-color: floralwhite;
+        }
+
+        canvas[resize] {
+            width: 100%;
+            height: 100%;
+        }
+
+      </style>
+    </meta>
+  </head>
+  <body>
+    <script canvas='solving-sol' type='text/paperscript'>
+
+      /*
+
+        PASTE SOL INSTRUCTIONS HERE i.e...
+
+        Solving Sol #33
+
+        A one-inch (2.5cm) grid covering a square. 
+        Within each of the one-inch (2.5cm) squares: 
+        1: Vertical black lines; 
+        2: Horizontal yellow lines; 
+        3: Diagonal right red lines; 
+        or 4: Diagonal left blue lines. 
+        As many lines as desired, but at least one line in each square.
+
+        Reference: https://umfa.utah.edu/sites/default/files/2019-01/Students%20Needed_UMFA%20Sol%20LeWitt%20Wall%20Drawing.pdf
+
+      */
+
+      function onResize() {
+        // Handle resizes
+        // Paper.js will call this handler automatically on resize.
+
+        //this plus the removeChildren() at the start of init is very hacky but works
+        init()
+      }
+
+
+      function init() {
+        //this is a very
+        project.activeLayer.removeChildren()
+                
+        // A one-inch (2.5cm) grid covering a square. 
+        // Within each of the one-inch (2.5cm) squares: 
+        // 1: Vertical black lines; 
+        // 2: Horizontal yellow lines; 
+        // 3: Diagonal right red lines; 
+        // or 4: Diagonal left blue lines. 
+        // As many lines as desired, but at least one line in each square.
+        
+        let inchInPx = 96
+        
+        function getRandomInt(max) {
+          return Math.floor(Math.random() * max) + 1;
+        }
+        
+        function drawMovingLine(startingXY, endingXY, color, time) {
+            console.log("in moving line", startingXY, endingXY)
+            var path = new Path.Line({
+                from: [startingXY[0], startingXY[1]],
+                to: [startingXY[0], startingXY[1]],
+                strokeColor: color,
+                strokeWidth : 4
+            });
+            
+            console.log(path.segments[1])
+            
+            path.tween({
+                'segments[1].point': {x: endingXY[0], y: endingXY[1] },
+            }, time);
+        }
+        
+        function drawDiagonalLeftBlueLine (square, time) {
+            console.log("this is square .segments", square.segments, [square.segments[0].point.x, square.segments[0].point.y], [square.segments[3].point.x, square.segments[3].point.y])
+            let coords = [[square.segments[1].point.x, square.segments[1].point.y], [square.segments[3].point.x, square.segments[3].point.y]]
+            if (getRandomInt(2)<2) drawMovingLine(coords[0], coords[1], "blue", time)
+            else drawMovingLine(coords[1], coords[0], "blue", time)
+        }
+        
+        function drawDiagonalRightRedLine (square, time) {
+            console.log("in draw diag right")
+            let coords = [[square.segments[0].point.x, square.segments[0].point.y], [square.segments[2].point.x, square.segments[2].point.y]]
+            if (getRandomInt(2)<2) drawMovingLine(coords[0], coords[1], "red", time)
+            else drawMovingLine(coords[1], coords[0], "red", time)
+        }
+        
+        function drawVerticalBlackLine (square, time) {
+            let horizontalX = (square.segments[1].point.x + square.segments[2].point.x)/2
+            let coords = [[
+                horizontalX, 
+                square.segments[1].point.y], 
+                [horizontalX, 
+                square.segments[3].point.y]]
+            if (getRandomInt(2)<2) drawMovingLine(coords[0], coords[1], "#black", time)
+            else drawMovingLine(coords[1], coords[0], "black", time)
+        }
+        
+        function drawHorizontalYellowLine (square, time) {
+            let verticalY = (square.segments[0].point.y + square.segments[1].point.y) / 2
+            let coords = [[
+                    square.segments[0].point.x, 
+                    verticalY], 
+                    [square.segments[3].point.x, 
+                    verticalY]]
+            console.log("vertY", verticalY)
+            // this could be a ternary but more readable this way
+            if (getRandomInt(2)<2) drawMovingLine(coords[0], coords[1], "#FDDA0D", time)    
+            else drawMovingLine(coords[1], coords[0], "#FDDA0D", time)
+        
+            
+        }
+        
+        function drawSquare(upperLeftXY, lowerRightXY, color, time) {
+            var rectangle = new Rectangle(new Point(...upperLeftXY), new Point(...lowerRightXY));
+            var path = new Path.Rectangle(rectangle);
+            path.strokeColor = color;
+            path.strokeWidth = 2
+            
+            return path
+            // return {time, square : path}
+        }
+        
+        function drawLines(square) {
+                // console.log("this is time", this.time)
+                let time = 1000
+                let lineMade = false
+                while (!lineMade) {
+                    console.log("in while", getRandomInt(4))
+                    console.log("HELLOOOOOOOOOOOOO")
+                    if (getRandomInt(4) === 1) {
+                        drawVerticalBlackLine(square, time)
+                        lineMade = true
+                    }
+                    if (getRandomInt(4) === 2) {
+                        drawHorizontalYellowLine(square, time)
+                        lineMade = true
+                    }
+                    if (getRandomInt(4) === 3) {
+                        drawDiagonalRightRedLine(square, time)
+                        lineMade = true
+                    }
+                    if (getRandomInt(4) === 4) {
+                        drawDiagonalLeftBlueLine(square, time)
+                        lineMade = true
+                    }
+                }
+            }
+        
+
+
+        let smallerDimension = Math.min(view.size.width, view.size.height)
+        let numHorizontalFit = Math.floor(view.size.width / inchInPx)
+        let numVerticalFit = Math.floor(view.size.height / inchInPx)
+        console.log(numVerticalFit, numHorizontalFit)
+        let horizontalPadding = 0
+        let verticalPadding = 0
+        if (numVerticalFit < numHorizontalFit) {
+          console.log("less vert space")
+          horizontalPadding = (view.size.width - (numVerticalFit * inchInPx)) / 2
+          verticalPadding = (view.size.height % inchInPx) / 2
+        } else {
+          
+          console.log("less horiz space")
+          horizontalPadding = (view.size.width % inchInPx) / 2
+          verticalPadding = (view.size.height  - (numHorizontalFit * inchInPx)) / 2
+        }
+        //i is x, j is y
+        //row loop
+        console.log("width", view.size.width, "height", view.size.height)
+        
+        let delay = 0;
+        for (let j = 0; j + inchInPx < smallerDimension; j += inchInPx) {
+          for (let i = 0; i + inchInPx < smallerDimension; i+= inchInPx) {
+                setTimeout(function() {
+                  let newSquare = drawSquare([i + horizontalPadding,j + verticalPadding], [i + inchInPx + horizontalPadding, j+inchInPx + verticalPadding], "black");
+                  drawLines(newSquare);
+              }, delay);
+              delay += 123;
+            }
+        }
+      }
+
+      // This will fire when Paper.js is ready
+      init();
+
+    </script>
+
+    <canvas id='solving-sol' resize>
+      <!-- Paperscript will draw the graphics here -->
+    </canvas>
+
+  </body>
+</html>
diff --git a/050A/instructions.md b/050A/instructions.md
new file mode 100644
index 0000000..3630fa1
--- /dev/null
+++ b/050A/instructions.md
@@ -0,0 +1,3 @@
+# Wall Drawing #50A (1970)
+
+A wall divided into four parts by lines drawn corner to corner. Each section with three different colors made of parallel lines superimposed. Color pencil.
\ No newline at end of file
diff --git a/050A/paperSolve.html b/050A/paperSolve.html
new file mode 100644
index 0000000..ba089f3
--- /dev/null
+++ b/050A/paperSolve.html
@@ -0,0 +1,198 @@
+<html>
+  <head>
+    <meta>
+
+      <title>Solving Sol</title>
+      <!-- Load latest acron version first -->
+      <script type="text/javascript" src="https://unpkg.com/acorn"></script>
+      <!-- Then load Paper.js -->
+      <script type="text/javascript" src="https://unpkg.com/paper"></script>
+      <!-- <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/paper.js/0.9.18/paper-full.min.js" ></script> -->
+      <style type="text/css">
+
+        html, body {
+          width: 100%;
+          height: 100%;
+          overflow: hidden;
+          padding: 0;
+          margin: 0;
+        }
+
+        canvas[resize] {
+            width: 100%;
+            height: 100%;
+        }
+
+      </style>
+    </meta>
+  </head>
+  <body>
+    <script canvas='solving-sol' type='text/paperscript'>
+
+      /*
+
+        PASTE SOL INSTRUCTIONS HERE i.e...
+
+        Solving Sol #50A
+
+        A wall divided into four parts by lines drawn corner to corner. 
+        Each section with three different colors made of parallel lines superimposed. 
+        Color pencil.
+
+        Reference: https://www.themodern.org/sites/default/files/being_there_art_assignment_4_final.pdf
+
+      */
+
+      function onResize() {
+        // Handle resizes
+        // Paper.js will call this handler automatically on resize.
+
+        //this plus the removeChildren() at the start of init is very hacky but works
+        init()
+      }
+
+
+      function init() {
+        //this is a very
+        project.activeLayer.removeChildren()
+        console.log(view)
+        
+        let lineSpacing = 20
+        let strokeWidth = 2
+
+        function getColor(){ 
+          return "hsl(" + 360 * Math.random() + ',' +
+                    (25 + 70 * Math.random()) + '%,' + 
+                    (85 + 10 * Math.random()) + '%)'
+        }
+        let line1 = new Path();
+        line1.strokeColor = 'black'
+        line1.add(new Point(0,0));
+        line1.add(new Point(view.size.width, view.size.height))
+
+
+        let line2= new Path();
+        line2.strokeColor = 'black'
+        line2.add(new Point(0, view.size.height));
+        line2.add(new Point(view.size.width, 0))
+
+
+        var leftTri = new Path();
+        leftTri.strokeColor = 'black';
+        leftTri.add(new Point(0, 0)); 
+        leftTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        leftTri.add(new Point(0, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        leftTri.fillColor = "blue"
+        leftTri.closed = true
+    
+    
+        var upperTri = new Path();
+        upperTri.strokeColor = 'black';
+        upperTri.add(new Point(0, 0)); 
+        upperTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        upperTri.add(new Point(view.size.width, 0));
+        // path.add(new Point(view.size.width, 0));
+        upperTri.fillColor = "white"
+        upperTri.closed = true
+    
+        var rightTri = new Path();
+        rightTri.strokeColor = 'black';
+        rightTri.add(new Point(view.size.width, 0)); 
+        rightTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        rightTri.add(new Point(view.size.width, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        rightTri.fillColor = "black"
+        rightTri.closed = true
+    
+        var bottomTri = new Path();
+        bottomTri.strokeColor = 'yellow';
+        bottomTri.add(new Point(0, view.size.height)); 
+        bottomTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        bottomTri.add(new Point(view.size.width, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        bottomTri.fillColor = "yellow"
+        bottomTri.closed = true
+    
+        function makeHorizontalLines (spacing, color) {
+            let returnArr = []
+            for (let i = 0; i <= view.size.height; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, i));
+                newLine.add(new Point(view.size.width, i));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeVerticalLines (spacing, color) {
+            let returnArr = []
+            for (let i = 0; i <= view.size.width; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(i, 0));
+                newLine.add(new Point(i, view.size.height));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeUpwardDiagonals (spacing, color) {
+            let ratioOfWidthToHeight = view.size.width / view.size.height
+            let returnArr = []
+            for (let i = 0; i <= view.size.height*2; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, i));
+                newLine.add(new Point(i * ratioOfWidthToHeight, 0));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeDownwardDiagonals (spacing, color) {
+            console.log("in downward")
+            let ratioOfWidthToHeight = view.size.width / view.size.height
+            let returnArr = []
+            for (let i = 0; i <= view.size.height*2; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = 'green';
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, view.size.height-i));
+                newLine.add(new Point(i * ratioOfWidthToHeight, view.size.height));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        //takes a triangle path object, which direction it lies on, and an array of colors
+        function fillTriangleWithColors (triangle, verticalOrHorizontal, colors) {
+            if (!colors) {
+                colors = new Array(3).fill().map(getColor)
+            }
+            let cardinalArr = verticalOrHorizontal === "vertical" ? makeVerticalLines(lineSpacing, colors[0]) : makeHorizontalLines(lineSpacing, colors[0])
+            var newGroup = new Group(triangle, ...cardinalArr, ...makeUpwardDiagonals(lineSpacing, colors[1]), ...makeDownwardDiagonals(lineSpacing, colors[2]))
+            newGroup.clipped = true
+        }
+    
+        fillTriangleWithColors(upperTri, "horizontal", ["red", "blue", "green"])
+        fillTriangleWithColors(bottomTri, "horizontal", ["purple", "orange", "teal"])
+        fillTriangleWithColors(leftTri, "vertical", ["coral", "brown", "sawdust"])
+        fillTriangleWithColors(rightTri, "vertical", ["fuschia", "pink", "yellow"])
+      }
+
+      // This will fire when Paper.js is ready
+      init();
+
+    </script>
+
+    <canvas id='solving-sol' resize>
+      <!-- Paperscript will draw the graphics here -->
+    </canvas>
+
+  </body>
+</html>
diff --git a/33/instructions.md b/33/instructions.md
new file mode 100644
index 0000000..3630fa1
--- /dev/null
+++ b/33/instructions.md
@@ -0,0 +1,3 @@
+# Wall Drawing #50A (1970)
+
+A wall divided into four parts by lines drawn corner to corner. Each section with three different colors made of parallel lines superimposed. Color pencil.
\ No newline at end of file
diff --git a/33/paperSolve.html b/33/paperSolve.html
new file mode 100644
index 0000000..ba089f3
--- /dev/null
+++ b/33/paperSolve.html
@@ -0,0 +1,198 @@
+<html>
+  <head>
+    <meta>
+
+      <title>Solving Sol</title>
+      <!-- Load latest acron version first -->
+      <script type="text/javascript" src="https://unpkg.com/acorn"></script>
+      <!-- Then load Paper.js -->
+      <script type="text/javascript" src="https://unpkg.com/paper"></script>
+      <!-- <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/paper.js/0.9.18/paper-full.min.js" ></script> -->
+      <style type="text/css">
+
+        html, body {
+          width: 100%;
+          height: 100%;
+          overflow: hidden;
+          padding: 0;
+          margin: 0;
+        }
+
+        canvas[resize] {
+            width: 100%;
+            height: 100%;
+        }
+
+      </style>
+    </meta>
+  </head>
+  <body>
+    <script canvas='solving-sol' type='text/paperscript'>
+
+      /*
+
+        PASTE SOL INSTRUCTIONS HERE i.e...
+
+        Solving Sol #50A
+
+        A wall divided into four parts by lines drawn corner to corner. 
+        Each section with three different colors made of parallel lines superimposed. 
+        Color pencil.
+
+        Reference: https://www.themodern.org/sites/default/files/being_there_art_assignment_4_final.pdf
+
+      */
+
+      function onResize() {
+        // Handle resizes
+        // Paper.js will call this handler automatically on resize.
+
+        //this plus the removeChildren() at the start of init is very hacky but works
+        init()
+      }
+
+
+      function init() {
+        //this is a very
+        project.activeLayer.removeChildren()
+        console.log(view)
+        
+        let lineSpacing = 20
+        let strokeWidth = 2
+
+        function getColor(){ 
+          return "hsl(" + 360 * Math.random() + ',' +
+                    (25 + 70 * Math.random()) + '%,' + 
+                    (85 + 10 * Math.random()) + '%)'
+        }
+        let line1 = new Path();
+        line1.strokeColor = 'black'
+        line1.add(new Point(0,0));
+        line1.add(new Point(view.size.width, view.size.height))
+
+
+        let line2= new Path();
+        line2.strokeColor = 'black'
+        line2.add(new Point(0, view.size.height));
+        line2.add(new Point(view.size.width, 0))
+
+
+        var leftTri = new Path();
+        leftTri.strokeColor = 'black';
+        leftTri.add(new Point(0, 0)); 
+        leftTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        leftTri.add(new Point(0, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        leftTri.fillColor = "blue"
+        leftTri.closed = true
+    
+    
+        var upperTri = new Path();
+        upperTri.strokeColor = 'black';
+        upperTri.add(new Point(0, 0)); 
+        upperTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        upperTri.add(new Point(view.size.width, 0));
+        // path.add(new Point(view.size.width, 0));
+        upperTri.fillColor = "white"
+        upperTri.closed = true
+    
+        var rightTri = new Path();
+        rightTri.strokeColor = 'black';
+        rightTri.add(new Point(view.size.width, 0)); 
+        rightTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        rightTri.add(new Point(view.size.width, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        rightTri.fillColor = "black"
+        rightTri.closed = true
+    
+        var bottomTri = new Path();
+        bottomTri.strokeColor = 'yellow';
+        bottomTri.add(new Point(0, view.size.height)); 
+        bottomTri.add(new Point(view.size.width/2, view.size.height/2)); 
+        bottomTri.add(new Point(view.size.width, view.size.height));
+        // path.add(new Point(view.size.width, 0));
+        bottomTri.fillColor = "yellow"
+        bottomTri.closed = true
+    
+        function makeHorizontalLines (spacing, color) {
+            let returnArr = []
+            for (let i = 0; i <= view.size.height; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, i));
+                newLine.add(new Point(view.size.width, i));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeVerticalLines (spacing, color) {
+            let returnArr = []
+            for (let i = 0; i <= view.size.width; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(i, 0));
+                newLine.add(new Point(i, view.size.height));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeUpwardDiagonals (spacing, color) {
+            let ratioOfWidthToHeight = view.size.width / view.size.height
+            let returnArr = []
+            for (let i = 0; i <= view.size.height*2; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = color;
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, i));
+                newLine.add(new Point(i * ratioOfWidthToHeight, 0));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        function makeDownwardDiagonals (spacing, color) {
+            console.log("in downward")
+            let ratioOfWidthToHeight = view.size.width / view.size.height
+            let returnArr = []
+            for (let i = 0; i <= view.size.height*2; i+= lineSpacing) {
+                let newLine = new Path() 
+                newLine.strokeColor = 'green';
+                newLine.strokeWidth = strokeWidth;
+                newLine.add(new Point(0, view.size.height-i));
+                newLine.add(new Point(i * ratioOfWidthToHeight, view.size.height));
+                returnArr.push(newLine)
+            }
+            return returnArr
+        }
+    
+        //takes a triangle path object, which direction it lies on, and an array of colors
+        function fillTriangleWithColors (triangle, verticalOrHorizontal, colors) {
+            if (!colors) {
+                colors = new Array(3).fill().map(getColor)
+            }
+            let cardinalArr = verticalOrHorizontal === "vertical" ? makeVerticalLines(lineSpacing, colors[0]) : makeHorizontalLines(lineSpacing, colors[0])
+            var newGroup = new Group(triangle, ...cardinalArr, ...makeUpwardDiagonals(lineSpacing, colors[1]), ...makeDownwardDiagonals(lineSpacing, colors[2]))
+            newGroup.clipped = true
+        }
+    
+        fillTriangleWithColors(upperTri, "horizontal", ["red", "blue", "green"])
+        fillTriangleWithColors(bottomTri, "horizontal", ["purple", "orange", "teal"])
+        fillTriangleWithColors(leftTri, "vertical", ["coral", "brown", "sawdust"])
+        fillTriangleWithColors(rightTri, "vertical", ["fuschia", "pink", "yellow"])
+      }
+
+      // This will fire when Paper.js is ready
+      init();
+
+    </script>
+
+    <canvas id='solving-sol' resize>
+      <!-- Paperscript will draw the graphics here -->
+    </canvas>
+
+  </body>
+</html>
diff --git a/50A/paperSolve.html b/50A/paperSolve.html
index 132e481..ba089f3 100644
--- a/50A/paperSolve.html
+++ b/50A/paperSolve.html
@@ -33,9 +33,13 @@
 
         PASTE SOL INSTRUCTIONS HERE i.e...
 
-        Solving Sol #16
-        Bands of lines 12 inches (30 cm) wide, in three directions
-        (vertical, horizontal, diagonal right) intersecting.
+        Solving Sol #50A
+
+        A wall divided into four parts by lines drawn corner to corner. 
+        Each section with three different colors made of parallel lines superimposed. 
+        Color pencil.
+
+        Reference: https://www.themodern.org/sites/default/files/being_there_art_assignment_4_final.pdf
 
       */
 
