/*
 * File: Rainbow.java
 * ------------------
 * This program displays a rainbow by adding consecutively
 * smaller circles to the canvas using an array. 
 */
 
import java.awt.Color;
 
import acm.graphics.GOval;
import acm.graphics.GRect;
import acm.program.*;
 
public class Rainbow extends GraphicsProgram {
 
 public static final int SUN_RADIUS = 80;
 public static final int BAND_WIDTH = 20;
 public static final int RAINBOW_OVERHANG = 380;
 public static final int RAINBOW_OFFSET = 150;
 
 public void run() {
 
// Creating a sky with a GRect method
 
 drawSky (Color.CYAN);
 
// Creating a sky with a GOval method
// drawCircle (220, 220, 510, Color.CYAN);
 
 Color[] colors = {Color.RED, Color.ORANGE, Color.YELLOW, Color.GREEN, Color.BLUE, Color.MAGENTA, Color.CYAN};
 
 for (int i=0; i<colors.length; i++){
 
 drawCircle (getWidth()/2, getHeight() + RAINBOW_OFFSET, ((getWidth()+RAINBOW_OVERHANG)/2)-(i*BAND_WIDTH), colors[i]);
 
 }
 
// Creating a cute, little sun in the corner using the GOval method
 
 drawCircle (0, 0, SUN_RADIUS, Color.YELLOW);
 
 }
 
 private void drawCircle(int x, int y, int r, Color acolor) { 
 
 GOval myCircle = new GOval(x-r, y-r, r*2, r*2);
 myCircle.setFilled(true);
 myCircle.setColor(acolor);
 add (myCircle); 
 
 }
 
 private void drawSky(Color skycolor) {
 
 GRect mySky = new GRect(0, 0, getWidth(), getHeight());
 mySky.setFilled(true);
 mySky.setColor(skycolor);
 add (mySky);
 }
 
}

/*
 * File: Pyramid.java
 * ------------------
 * This program is a stub for the Pyramid problem, which draws
 * a brick pyramid.
 */
 
import acm.graphics.*;
import acm.program.*;
 
public class Pyramid extends GraphicsProgram {
 
//create constants for the brick width, brick height, and the number of 
//bricks in the base of the pyramid
 
	public static final int BRICK_WIDTH = 30;
	public static final int BRICK_HEIGHT = 12;
	public static final int BRICKS_IN_BASE = 12;
 
	public void run() {
 
		for(int i=0;i<BRICKS_IN_BASE; i++) {
 
			drawRowOfBricks(
 
				(getWidth()-(BRICK_WIDTH*(BRICKS_IN_BASE-(i))))/2,
				(i*(-BRICK_HEIGHT))-BRICK_HEIGHT,
				BRICKS_IN_BASE-i
 
			);
 
		}
	}
 
	private void drawBrick(int x, int y, int brick_width, int brick_height) { 
 
		GRect myBrick = new GRect(x, y, brick_width, brick_height);
		add (myBrick); 
 
	}
 
	public void drawRowOfBricks(int x, int y, int numOfBricks) {
 
		for(int i=0;i<numOfBricks; i++)
 
			drawBrick(x+(i*BRICK_WIDTH), y+getHeight(), BRICK_WIDTH, BRICK_HEIGHT);
 
	}
 
}

import stanford.karel.*;
 
public class CheckerboardKarel extends SuperKarel {
 
 public void run() {
 while (leftIsClear()) {
 putBeepersInARow();
 goBackToStartOfRow();
 determineNextRow();
 }
 putBeepersInARow();
 }
 
 public void putBeepersInARow() {
 putBeeper();
 while (frontIsClear()) { 
 move();
 if (frontIsClear()) {
 move();
 putBeeper();
 }
 }
 }
 
 public void goBackToStartOfRow() {
 turnAround();
 while (frontIsClear()) {
 move();
 } 
 }
 
 public void determineNextRow() {
 if (beepersPresent()) {
 turnRight();
 move();
 turnRight();
 move();
 } else {
 turnRight();
 move();
 turnRight();
 }
 }
}

Doing something completely outside of my paradigm has been helping me think and behave in ways I wouldn’t normally think and behave. With each coding exercise, I’ve been learning a lot about myself.

    import stanford.karel.*;
 
    public class StoneMasonKarel extends SuperKarel {
    public void run() {
    //putting beepers into the broken columns in the world
 
    while (frontIsClear()) {
    topOfColumn();
    putBeeperInColumn();
    nextColumn();
    }
    topOfColumn();
    putBeeperInColumn();
    }
 
    public void topOfColumn() {
    //getting to the top of the Column
 
    turnLeft();
    goToWall();
    turnAround();
 
    }
    public void putBeeperInColumn() {
    //putting beepers into the empty parts of the column
 
    while (frontIsClear()) {
    if (noBeepersPresent()) {
    putBeeper();
    }
    move();
    }
    if (noBeepersPresent()) {
    putBeeper();
    }
    }
    public void goToWall() {
    while(frontIsClear()){
    move();
    }
    }
    public void nextColumn() {
    //going to the next column in the world
 
    turnLeft();
    move();
    move();
    move();
    move();
    }
 
    }

//Karel finds the midpoint in the world. It is not the center.

function main() {

markWalls();
putBeepersDown();
turnAround();
move();
putBeeper();
turnAround();
goToWall();
turnAround();
lastBeeperStanding();

}

//Karel moves to end walls, marking them with beepers

function markWalls() {

goToWall();
putBeeper();
turnAround();
goToWall();
putBeeper();
turnAround();
move();

}

function goToWall() {
while(frontIsClear()) {
move();
}
}

//Karel starts putting beepers down to find the midpoint of the world.

function putBeepersDown() {
while(noBeepersPresent()) {
move();
if (beepersPresent()) {
turnAround();
move();
putBeeper();
move();
}
}
}

function lastBeeperStanding() {
while (frontIsClear()) {
if (beepersPresent()) {
pickBeeper();
}
move();
}
pickBeeper();
}