is there a way to make this code shorter? - processing

Question

i wrote this program and, being new to this sort of thing, I can only write very sloppy programs, is there a way to make this code more efficient/shorter, i know most of it is redundant but, even after taking out all of the nonessential code, it still feels like I'm doing something wrong. I've been asked to actually explain what the code does and the logic of the increments and decrements, each of the integer arrays provides either an X value or a Y value, these are used to draw lines, all of them with identical X and Y values, then, in the draw function, specific X/Y values (if not all of them) are selected, the increments/decrements add 1/subtract 1 from these specific integer arrays every time the screen refreshes, this extends the lines in certain directions, creating a shape which can be repeated in a pattern indefinitely.
int[] myintegerarray = new int[66];
void setup()
{
background(0,100,0);
myintegerarray[0] = 0;
myintegerarray[1] = 0;
myintegerarray[2] = 0;
myintegerarray[3] = 0;
myintegerarray[4] = 900;
myintegerarray[5] = 0;
myintegerarray[6] = 900;
myintegerarray[7] = 0;
myintegerarray[8] = 450;
myintegerarray[9] = 450;
myintegerarray[10] = 450;
myintegerarray[11] = 450;
myintegerarray[12] = 450;
myintegerarray[13] = 450;
myintegerarray[14] = 450;
myintegerarray[15] = 450;
myintegerarray[16] = 0;
myintegerarray[17] = 900;
myintegerarray[18] = 0;
myintegerarray[19] = 900;
myintegerarray[20] = 900;
myintegerarray[21] = 900;
myintegerarray[22] = 900;
myintegerarray[23] = 900;
myintegerarray[24] = 450;
myintegerarray[25] = 0;
myintegerarray[26] = 450;
myintegerarray[27] = 0;
myintegerarray[28] = 450;
myintegerarray[29] = 900;
myintegerarray[30] = 450;
myintegerarray[31] = 900;
myintegerarray[32] = 0;
myintegerarray[33] = 450;
myintegerarray[34] = 0;
myintegerarray[35] = 450;
myintegerarray[36] = 900;
myintegerarray[37] = 450;
myintegerarray[38] = 900;
myintegerarray[39] = 450;
myintegerarray[40] = 450;
myintegerarray[41] = 450;
myintegerarray[42] = 450;
myintegerarray[43] = 450;
myintegerarray[44] = 450;
myintegerarray[45] = 225;
myintegerarray[46] = 450;
myintegerarray[47] = 225;
myintegerarray[48] = 450;
myintegerarray[49] = 675;
myintegerarray[50] = 450;
myintegerarray[51] = 675;
myintegerarray[52] = 675;
myintegerarray[53] = 450;
myintegerarray[54] = 675;
myintegerarray[55] = 450;
myintegerarray[56] = 225;
myintegerarray[57] = 225;
myintegerarray[58] = 675;
myintegerarray[59] = 675;
myintegerarray[60] = 675;
myintegerarray[61] = 675;
myintegerarray[62] = 225;
myintegerarray[63] = 225;
myintegerarray[64] = 225;
myintegerarray[65] = 225;
size (900, 900);
}
void draw() {
myintegerarray[2] ++;
myintegerarray[3] ++;
myintegerarray[6] --;
myintegerarray[7] ++;
myintegerarray[9] --;
myintegerarray[11] ++;
myintegerarray[12] --;
myintegerarray[14] ++;
myintegerarray[18] ++;
myintegerarray[19] --;
myintegerarray[22] --;
myintegerarray[23] --;
myintegerarray[27] ++;
myintegerarray[31] --;
myintegerarray[34] ++;
myintegerarray[38] --;
myintegerarray[42] ++;
myintegerarray[43] ++;
myintegerarray[40] --;
myintegerarray[41] --;
myintegerarray[44] ++;
myintegerarray[46] --;
myintegerarray[50] ++;
myintegerarray[48] --;
myintegerarray[53] --;
myintegerarray[55] ++;
myintegerarray[58] --;
myintegerarray[59] ++;
myintegerarray[60] ++;
myintegerarray[61] --;
myintegerarray[62] --;
myintegerarray[63] ++;
myintegerarray[64] ++;
myintegerarray[65] --;
line(myintegerarray[0],myintegerarray[1],myintegerarray[2],myintegerarray[3]);
line(myintegerarray[4],myintegerarray[5],myintegerarray[6],myintegerarray[7]);
line(myintegerarray[8],myintegerarray[9],myintegerarray[10],myintegerarray[11]);
line(myintegerarray[12],myintegerarray[13],myintegerarray[14],myintegerarray[15]);
line(myintegerarray[16],myintegerarray[17],myintegerarray[18],myintegerarray[19]);
line (myintegerarray[20],myintegerarray[21],myintegerarray[22],myintegerarray[23]);
line(myintegerarray[24],myintegerarray[25],myintegerarray[26],myintegerarray[27]);
line(myintegerarray[28],myintegerarray[29],myintegerarray[30],myintegerarray[31]);
line(myintegerarray[32],myintegerarray[33],myintegerarray[34],myintegerarray[35]);
line(myintegerarray[36],myintegerarray[37],myintegerarray[38],myintegerarray[39]);
line(myintegerarray[40],myintegerarray[41],myintegerarray[42],myintegerarray[43]);
line(myintegerarray[40],myintegerarray[42],myintegerarray[43],myintegerarray[41]);
line(myintegerarray[44],myintegerarray[45],myintegerarray[46],myintegerarray[47]);
line(myintegerarray[48],myintegerarray[49],myintegerarray[50],myintegerarray[51]);
line(myintegerarray[52],myintegerarray[53],myintegerarray[54],myintegerarray[55]);
line(myintegerarray[56],myintegerarray[53],myintegerarray[57],myintegerarray[55]);
line(myintegerarray[58],myintegerarray[59],myintegerarray[60],myintegerarray[61]);
line(myintegerarray[62],myintegerarray[63],myintegerarray[64],myintegerarray[65]);
line(myintegerarray[60],myintegerarray[63],myintegerarray[58],myintegerarray[65]);
line(myintegerarray[63],myintegerarray[60],myintegerarray[65],myintegerarray[58]);
}

Answer 1

To shorten the initialization of the array, you could use an array initializer:
myintegerarray = {0, 0, 0, 0, 900, 0, 900, ...};
To shorten the incrementing and decrementing logic, you need to have a pattern as to what is being incremented and decremented. Maybe the first half of the array is incremented, and the second half is decremented. Then just use for loops:
for(int i = 0; i < 33; i++){
myintegerarray[i]++;
}
for(int i = 33; i < 66; i++){
myintegerarray[i]--;
}
To shorten the line logic, setup a similar pattern and just use a for loop:
for(int i = 0; i < 66; i+=4){
line(myintegerarray[i],myintegerarray[i+1],myintegerarray[i+2],myintegerarray[i+3]);
}
But really, I wouldn't worry too much about making your code as short as possible. As long as you understand your code and it works, you're doing fine. You'll learn how to make code shorter naturally as you go along. The most important thing is that you can read your own code, so don't worry too much about anything else.