^O^ Binary Calculate Plus & Display ^O^

//define Array of  is Gobal variable
boolean [] A = {
  true, false, true, true
};//put in first number to you want calculate
boolean [] B = {
  true, false, true, false
}; //put in second number to you want calculate
boolean [] C= new boolean [5]; //show the result and define count of index in boolean
boolean [] note = {
  false, false
}; //show the number to note
int index = 0;
int start = 65;
int r = 100;
void setup () {
  size (550, 250);
  background (102, 051, 000);
  index = A.length-1;
    while (index >= 0) {
    if (A[index] == true && B[index] == true) {
      note [0] = true;
      C[index] = false;
      if (note[1] == true) {
        C[index] = true;
      } //clear old note
      else {
        C[index] = false;
      }
      note[1] = note [0]; //move the number note to new column
    }
    else if (A[index] == false && B[index] == false) {
      note[0] = false; //set value of note is zero or clear note[0]
      C[index] = false;
      if (note[1] == true) {
        C[index] = true;
      }
      else {
        C[index] = false;
      } //maybe accidence
      note[1] = note [0]; //move the number note to new column
    }
    else { //cotinue frist up
      note[0] = false; // just expain and nothing all right
      C[index] = true;
      if (note [1] == true) {
        C[index] = false;
        note[0] = true;  //use in case 11 + 01 = 100 or next number is 1 + 0 , 0+1 from 1 + 1
      }
      else {
        C[index] = true; //if other case is all true such as 1+1 , 0+0
      }
      note[1] = note[0];
    }
    index = index - 1; //define for stop loop by do lower value
  } //finished loop (just do one time)
 
  if (A[0] == true && B[0] == true) { //new order to print result
    print ("1");
  }
  index = 0; //define new value of index
  while (index < A.length && index < B.length) { //normaly index must lesser than length of Array
    if (C[index] == true) {
      print ("1");
    }
    if (C[index] == false) {
      print ("0");
    }
    index = index + 1;
  }
  index = 0;
   while (index < C.length) {
    if (C[index] == true) {
      fill (255, 000, 102);
      stroke (255, 255, 000);
      strokeWeight (2);
      ellipse (start, 125, r, r);
      start = (start + r)+5;
    }
    else {
    fill (153, 255, 000);
    ellipse (start, 125, r, r);
    start = (start + r)+5;
    }
    index = index + 1;
  }
}

O_O Binary Calculation MINUS & Display O_O

ความหมายการแสดงผลคำตอบ : วงกลมสีแดง  => เลขศูนย์ (False)
                          วงกลมสีน้ำเงิน  => เลขหนึ่ง (True)
 
//กำหนด Array ของ Boolean เป็นตัวแปรประเภท Global variables
boolean [] A = {
  true, false, true, true
};//ใส่เลขที่เป็นตัวตั้ง ที่ต้องการคำนวณ โดยใช้ Array ชื่อ A เป็นตัวเก็บค่าของเลขฐานสองในรูปของ Boolean คือ true = 1 และ false = 0 แบบฟอร์มคือ Boolean [] ชื่อของ Boolean = {ค่าของตัวแปรที่เก็บไว้ใน Array แต่ละ index}; เพิ่มเติม index เริ่มนับตั้งแต่ศูนย์ 
boolean [] B = {
  true, false, false, false
}; //ใส่เลขที่เป็นตัวลบ ที่ต้องการคำนวณ โดยใช้ Array ชื่อ B เป็นตัวเก็บค่าของเลขฐานสองในรูป boolean
boolean [] C= new boolean [4]; //เป็น Array ชื่อ C ที่ไว้เก็บค่าของผลลัพธ์ที่คำนวณได้ และกำหนดจำนวนของ Array นี้ให้มีทั้งหมด 4 index โดยใช้คำสั่ง new Boolean [จำนวนช่องของ Array];
int index = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปรชื่อ index นั่นเอง (ใช้เป็นค่าบอกตำแหน่งของช่องแต่ละ index)int slide = 1; //ความหมายคือ นำ 1 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร slide นั่นเอง (ใช้เป็นตัวเลื่อนตำแหน่งที่ต้องการยืมค่า)
int start = 100; (ใช้เป็นค่าเริ่มต้นในการวาดภาพวงกลมเพื่อแสดงผล)
int r = 100; (ใช้เป็นค่าบอกความกว้างของวงกลมที่วาด)
int d = 15; (ใช้เป็นค่าบอกระยะห่างของวงกลมแต่ละวง)

void setup () { //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
  size (550, 250); //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
  background (255, 255, 000); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000
  index = A.length-1; //กำหนดให้ index เท่ากับความยาวของ array ลบ 1
  while (index >= 0) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จนกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ iืndex มากกว่าหรือเท่ากับ 0 จะสั่งให้กระทำส่งนั้นๆไปเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยลดค่าให้กับตัวแปรในกรณีนี้คือ index นั่นเอง
    if (A[index] == false && B[index] == true) {
      A[index-slide] = !A[index-slide];
      C[index] = true;
    }//เป็นการสร้างเงื่อนไขโดย if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่าใน A[index] คือศูนย์ และ B[index] คือหนึ่งจะให้ช่องหน้าหน้า A[index] เป็นอีกตัวหนึ่ง เช่นถ้า A[index] มีค่าเท่ากับ ศูนย์ ก็ให้เป็น หนึ่งแทน จากนั้นให้ C[inex] มีค่าเท่ากับหนึ่ง (ใช้ในกรณี 0-1 = 1 แล้วต้องยืมตัวหน้าตามหลักการลบเลขฐานสอง)
    else if (A[index] == true && B[index] == false) { //โดย else if เป็นการกำหนดเงื่อนไขเป็นจริงได้หลายเงื่อนไขเพื่อเป็นทางเลือกในการตัดสินใจ หลักการใช้คล้ายๆกับเงื่อนไข if  ในกรณีนี้หมายถึง ถ้า A[index] มีค่าเท่ากับหนึ่ง และ B[index] เท่ากับศูนย์ ให้ C[index] เท่ากับหนึ่ง (ใช้ในกรณี 1-0 = 1)      C[index] = true;
      if (A[index] == true && B[index] == true) {
        C[index] = false;
      } (ใช้ในกรณี 1-1 = 0)
      if (A[index] == false && B[index] == false) {
        C[index] = false;
      }(ใช้ในกรณี 0-0 = 0)
    }
    index = index - 1; //ลดค่าของ index ลงเพื่อหยุดการวนลูป
  }
  index = 0; //กำหนด index ใหม่ให้มีค่าเท่ากับศูนย์
  while (index < A.length && index < B.length) { //ถ้า index ไม่เกินความยาวของ Array A และ B ทำตามเงื่อนไขนี้
    if (C[index] == true) { //ถ้า C[index] == true ให้พิมพ์หนึ่ง (เป็นคำสั่งแสดงค่าออกมาเป็นตัวเลข)
      print (1);
    }
    if (C[index] == false) { //ถ้า C[index] == false ให้พิมพ์Lศูนย์
      print (0);
    }
    index = index + 1; //กำหนดค่าของ index ให้มากขึ้นเพื่อหลุด loop
  }
  index = 0; (ใช้ในการวาดรูปวงกลมเพื่อแสดงผล)
  while (index < C.length) {
    if (C[index] == true) { (ถ้าคำตอบเป็น true ให้วาดรูปวงกลมสีน้ำเงิน โดยแต่ละวงห่างกัน เท่ากับ (start + r)+d)
      fill (000, 000, 255);
      stroke (120, 051, 000);
      strokeWeight (5);
      ellipse (start, 125, r, r);
      start = (start + r)+d;
    }
    else { (ถ้าคำตอบไม่เป็น true ให้วาดรูปวงกลมสีแดง)
      stroke (120, 051, 000);
      strokeWeight (5);
      fill (255, 000, 051);
      ellipse (start, 125, r, r);
      start = (start + r)+d;
    }
    index = index + 1;
  }}

Some UFO

int xPos; //เป็นการประกาศตัวแปรชื่อ xPos ชนิดที่เป็น Local variables
int count;//เป็นการประกาศตัวแปรชื่อ Count ชนิดที่เป็น Local variables
int Difference=200; //เป็นการประกาศและกำหนดค่าของตัวแปร Difference โดยค่าที่เป็นจำนวนเต็มคือ 200 ทางขวาของ Assignment Operator ใส่ให้กับตัวแปร Difference ทางซ้าย
void setup()  //เป็นการประกาศฟังก์ชั่น setup โดย void จะกระทำเฉพาะในฟังก์ชั่นเท่านั้น
{
  size(500, 500); //เป็นการกำหนดขนาดของ Canvas โดยที่ size (ขนาดของแกนx, ขนาดของแกนy);
  xPos=0; //เป็นการกำหนดค่าของตัวแปร xPos ชนิดที่เป็นจำนวนเต็ม
  count=xPos; //เป็นการกำหนดค่าของตัวแปร count ให้เท่ากับค่าของตัวแปร xPos
}
void draw() //เป็นการประกาศฟังก์ชั่น draw โดย void จะกระทำเฉพาะในฟังก์ชั่นเท่านั้น
{
  int yPos=100; //เป็นการประกาศและกำหนดค่าของตัวแปร yPos ชนิดที่เป็นจำนวนเต็ม ให้เท่ากับ 100
  int[] A = {
    1, 3, 2
  }; //เป็นการประกาศและกำหนดค่าให้กับตัวแปรชุด A โดยนำค่าต่างๆ ที่เป็นจำนวนเต็ม ของจำนวน UFO ตามแต่ละแถวใส่ลงในวงเล็บปีกกา
  background(051, 000, 153); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000
  int i=0; //เป็นการประกาศและกำหนดค่าของตัวแปร i ชนิดที่เป็นจำนวนเต็ม ให้เท่ากับ 0
  while (i<A.length) //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จนกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ i น้อยกว่าความยาวของตัวแปรชุด A นั้น จะสั่งให้กระทำส่งนั้นๆไปเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปรในกรณีนี้คือ i นั่นเอง
  {
    drawSomeUFO(xPos, yPos, A[i]); //เป็นการเรียกใช้ฟังก์ชั่นชื่อ drawSomeUFO
    yPos=yPos+150; //เป็นการปรับค่าให้กับตัวแปร yPos โดยเพิ่มขึ้นทีละหนึ่งร้อยห้าสิบ
    i=i+1; //เป็นการปรับค่าให้กับตัวแปร i โดยเพิ่มขึ้นทีละหนึ่ง
  }
  if (count<=width) //เป็นการสร้างเงื่อนไข ให้กับการเคลื่อนที่ โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่า count น้อยกว่าหรือเท่ากับค่า width เป็นจริง ให้  xPos เพิ่มขึ้นทีละหนึ่ง และ count เพิ่มขึ้นทีละหนึ่ง
  {
    xPos=xPos+1;
    count=count+1;
  }
  if (count>width || xPos==width) //เป็นการสร้างเงื่อนไข ให้กับการเคลื่อนที่ โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่า count มากกว่าค่า width  หรือxPos เท่ากับ width เป็นจริง ให้ xPos ลดลงทีละหนึ่ง และ count เพิ่มขึ้นทีละหนึ่ง
  {
    xPos=xPos-1;
    count=count+1;
  }
  if (count==width*2) { //เป็นการสร้างเงื่อนไข ให้กับการเคลื่อนที่ โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่า count เท่ากับค่า width คูณสองเป็นจริง ให้  count เท่ากับศูนย์
    count=0;
  }
}
void drawSomeUFO(int xPos, int yPost, int A)  //เป็นการประกาศฟังก์ชั่น drawSomeUFOและกำหนดตัวแปร xPos, yPost,  A ที่เป็นจำนวนเต็มโดย void จะกระทำเฉพาะในฟังก์ชั่นเท่านั้น
{
  int i=0; //เป็นการประกาศและกำหนดค่าของตัวแปร i ชนิดที่เป็นจำนวนเต็ม ให้เท่ากับ 0
  while (i<A) //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ i น้อยกว่าความยาวของตัวแปรชุด A นั้น จะสั่งให้เข้าเงื่อนไขการวาดต่างๆไปเรื่อยๆ จนกว่าเงื่อนไขจะเป็นเท็จนั่นเอง
  {
    stroke(255, 255, 255); //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
    fill(255, 255, 000); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
    ellipse(xPos, yPost, 80, 100); //คือคำสั่งที่ใช้ในการวาดรูปทรงกลม หรือทรงรีก็ได้ โดย ellipse (ค่าxที่เป็นจุดศูนย์กลางวงกลม, ค่าyที่เป็นจุดศูนย์กลางวงกลม, ขนาดความยาวของวงกลมตามแกนx, ขนาดความยาวของวงกลมตามแกนy); ถ้าขนาดความยาวของวงกลมตามแกนx กับ ขนาดความยาวของวงกลมตามแกนy เท่ากันจะเป็นวงกลม แต่ถ้าไม่จะเป็นวงรี
    fill(255, 051, 153);
    ellipse(xPos, yPost, 140, 40);
    xPos = xPos + Difference; //เป็นการเพิ่มค่าให้ xPos บวกกับค่าของ Difference
    i=i+1;//เป็นการเพิ่มค่าให้ i ทีละหนึ่ง
  
  }
} //ปีกกาปิด เพื่อจบฟังก์ชั่น

Bar Chart About Percentage of youth aged 0-4 years according to living arrangements by living with parents And Calculate Min/Max/Average.

float[]B = {63.6, 19.7, 14.5, 2.2}; //เป็นการกำหนดค่าตัวแปรชุด โดยนำค่าต่างๆ ที่เป็นทศนิยม ของข้อมูลมาใส่ลงในวงเล็บปีกกา
String[]A = {
  "Living with both parents", "Living with neither parent", "Living with mother only", "Living with father only"};  //เป็นการกำหนดค่าตัวแปรชุด โดยนำข้อมูลชนิดที่เป็นประโยคมาใส่ในวงเล็บปีกกา ภายใต้เครื่องหมายคำพูด
int i;//เป็นการประกาศตัวแปร i นิดที่เป็น Local variables
int x = 4;//เป็นการประกาศและกำหนดค่าของตัวแปร x โดยค่าที่เป็นจำนวนเต็มทางขวาของ Assignment Operator ใส่ให้กับตัวแปร x ทางซ้าย
float sum;  //เป็นการประกาศตัวแปร ชนิดที่เป็นทศนิยมหรือเลขยกกำลัง ของ sum
float average; //เป็นการประกาศตัวแปร ชนิดที่เป็นทศนิยมหรือเลขยกกำลัง ของ sum
void setup() { //เป็นการประกาศฟังก์ชั่น setup โดย void จะกระทำเฉพาะในฟังก์ชั่นเท่านั้น
  size(500, 500); //เป็นการกำหนดขนาดของ Canvas โดยที่ size (ขนาดของแกนx, ขนาดของแกนy);
  background(102, 051 , 000);  //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000
  drawColumn(); //เป็นการเรียกใช้ฟังก์ชั่นชื่อ drawColumn
  float max = B[0]; //เป็นการกำหนดตัวแปร max ให้กับตัวแปรชุด B ใน index 0
  float min = B[0]; //เป็นการกำหนดตัวแปร min ให้กับตัวแปรชุด B ใน index 0
  int i = 0;  //เป็นการประกาศและกำหนดค่าของตัวแปร i ชนิดจำนวนเต็มให้มีค่าเท่ากับศูนย์
  while (i< B.length) {  //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จนกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ i น้อยกว่าหรือเท่ากับ ความยาวของตัวแปรชุด B นั้น จะสั่งให้กระทำส่งนั้นๆไปเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปรในกรณีนี้คือ i นั่นเอง
    if (B[i] >= max) { //เป็นการสร้างเงื่อนไข ให้กับการเคลื่อนที่ โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ  จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่าในตัวแปรชุด B ที่ index i มากกว่าหรือเท่ากับค่าของ max  เป็นจริง ให้ max = B[i]
      max = B[i];
    }
    if (B [i]<= min) {  //โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่าในตัวแปรชุด B ที่ index i น้อยกว่าหรือเท่ากับค่าของ min  เป็นจริง ให้ max = B[i]
      min = B [i];
      i=i+1;  //การเปลี่ยนค่าให้กับตัวแปร i โดยเพิ่มขึ้นทีละหนึ่ง
    }
    if (i==x) { //โดยที่ if คือการตั้งเงื่อนไขที่ว่าถ้าจริงให้ทำ ถ้าเท็จไม่ทำ จะได้ว่า if (กำหนดค่าที่เปลี่ยนแปลงไปภายใต้เงื่อนไข) { กำหนดค่าที่ต้องการให้เปลี่ยนเมื่อเงื่อนไขสมบรูณ์; }โดยในที่นี้หมายถึง ถ้าค่าในตัวแปร i เท่ากับค่าของ x  เป็นจริง ให้เอาค่าในตัวแปรชุด B ทั้งหมดมาบวกกัน และเอามาหารด้วย x จะได้ค่าเฉลี่ย
      sum=B[0]+B[1]+B[2]+B[3];
      average=sum/x;
    }
  }
  println("Max="+max); //เป็นคำสั่งที่ใช้พิมพ์ค่า โดย println("เป็นข้อความที่ต้องการพิมพ์แสดงผล"+เป็นการแสดงผลที่คำนวณได้);
  println("Min="+min);
  println("Average="+average);
}
void drawColumn() { //เป็นการประกาศฟังก์ชั่น drawColumn โดย void จะกระทำเฉพาะในฟังก์ชั่นเท่านั้น
  int x = 50;
  int y = 300;
  int w = 70;
  int v = 180; 
  stroke(255, 255, 000);   //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
  strokeWeight (2); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);
  line(0, y, 500, y); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
  while (i<B.length) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ i น้อยกว่าความยาวของตัวแปรชุด B นั้น จะสั่งให้เข้าเงื่อนไข if ไปเรื่อยๆ จนกว่าเงื่อนไขจะเป็นเท็จนั่นเอง
    if (i==0) { //เป็นการแสดงเงื่อนไขว่าถ้า i = 0 ให้เติมสี
      fill(255, 000, 153);
    }
    if (i==1) {//เป็นการแสดงเงื่อนไขว่าถ้า i = 1 ให้เติมสี
      fill(102, 255, 255);
    }
    if (i==2) {//เป็นการแสดงเงื่อนไขว่าถ้า i = 2 ให้เติมสี
      fill(153, 255, 000);
    }
    if (i==3) {//เป็นการแสดงเงื่อนไขว่าถ้า i = 3 ให้เติมสี
      fill(255, 000, 000);
    }
   
    rect(x, y, w, -B[i]*4);  //เป็นการสร้างรูปสีเหลี่ยม โดย rect (จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนx, จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนy, ค่าขนาดความกว้างตามแกนx, ค่าขนาดความกว้างตามแกนy, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนขวา, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างขวา);
    text(B[i]+"%", x, y-B[i]-200);
    rect(16, 162+v, 5, 5);
    text(A[i], 25, 170+v);
   
    x=x+110; //การเปลี่ยนค่าให้กับตัวแปร x โดยเพิ่มขึ้นทีละหนึ่งร้อยสิบ
    v=v+30;
    i=i+1;
  }
  fill(255,255,000); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
   textFont(createFont("JasmineUPC", 22)); //เป็นคำสั่งกำหนดขนาด และแบบของตัวหนังสือ
   text("PERCENT",10,15);  //เป็นคำสั่งกำหนดตำแหน่งของตัวหนังสือที่พิมพ์ภายใต้ "__"
   text("TYPE",450,330);
}

ข้อมูลจาก National Statistical Office

Bridge

void setup () {   //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
  size (500, 500);  //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
  background (051, 204, 255); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000
  //variable เป็นบรรทัดที่จะมีการประกาศตัวแปร
  int count = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร count นั่นเอง
  int n = 10; //ความหมายคือ นำ 10 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร n นั่นเอง
  int x = 250;
  int y = 10;
  int z = 0;
  int a = 0;
  int w = 485;
  int q = 500;

  //loop สามารถนำ while มาช่วยในการสร้าง loop ได้
  while (count<=n) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ count น้อยกว่าหรือเท่ากับ ค่าของ n นั้น จะสั่งให้วาดเส้นตรงออกมาเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปร a และ count นั่นเอง
    stroke (255, 255, 255); //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
    strokeWeight (5); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);

    line (x, y+a, z+a, w); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
    line (x, y+a, q-a, w);
       
    a = a+20; //เป็นการเพิ่มค่าให้กับตัวแปร a หมายความว่า a จะมีค่าเท่ากับ ค่าของตัวแปร a บวกกับค่าที่เป็นจำนวนเต็มคือ 20
    count = count +1;
  }
 
  //draw Pole วาดแกนขั้วตรงกลาง
  fill (153, 225, 000); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
  quad (225, 10, 275, 10, 325, 500, 175, 500); //เป็นการสร้างรูปสี่เหลี่ยมใดๆ โดย quad (ค่าxที่เป็นจุดแรกของสี่เหลี่ยม, ค่าyที่เป็นจุดแรกของสี่เหลี่ยม, ค่าxที่เป็นจุดที่สองของสี่เหลี่ยม, ค่าyที่เป็นจุดที่สองของสี่เหลี่ยม, ค่าxที่เป็นจุดที่สามของสี่เหลี่ยม, ค่าyที่เป็นจุดที่สามของสี่เหลี่ยม, ค่าxที่เป็นจุดสุดท้ายของสี่เหลี่ยม, ค่าyที่เป็นจุดสุดท้ายของสี่เหลี่ยม);
  fill (153, 153, 153);
  rect (0, 485, 500, 15); //เป็นการสร้างรูปสีเหลี่ยม โดย rect (จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนx, จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนy, ค่าขนาดความกว้างตามแกนx, ค่าขนาดความกว้างตามแกนy, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนขวา, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างซ้าย, ค่าความแมนของมุมสี่เหลี่ยมด้านล่างขวา);
 
  //draw sun วาดพระอาทิตย์
  noStroke (); //คือคำสั่งที่ยกเลิกการวาดเส้น
  fill (255, 051, 000);
  ellipse (430, 100, 80, 80); //คือคำสั่งที่ใช้ในการวาดรูปทรงกลม หรือทรงรีก็ได้ โดย ellipse (ค่าxที่เป็นจุดศูนย์กลางวงกลม, ค่าyที่เป็นจุดศูนย์กลางวงกลม, ขนาดความยาวของวงกลมตามแกนx, ขนาดความยาวของวงกลมตามแกนy); ถ้าขนาดความยาวของวงกลมตามแกนx กับ ขนาดความยาวของวงกลมตามแกนy เท่ากันจะเป็นวงกลม แต่ถ้าไม่จะเป็นวงรี
 
}//ปีกกาปิด เพื่อจบฟังก์ชั่น

Curve stitching of Bird

void setup () { //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
  size (500, 500); //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
  background (255, 051, 102); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000

  //variable  เป็นบรรทัดที่จะมีการประกาศตัวแปร
  int count = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร count นั่นเอง
  int n = 100; //ความหมายคือ นำ 10 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร n นั่นเอง
  int x = 0;
  int y = 500;
  int z = 500;
  int a = 0;
  int w = 100;
  int p = 200;
  int l = 300;

  //loop  สามารถนำ while มาช่วยในการสร้าง loop ได้
  while (count<=n) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ count น้อยกว่าหรือเท่ากับ ค่าของ n นั้น จะสั่งให้วาดเส้นตรงออกมาเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปร x และ count นั่นเอง
    stroke (000, 000, 000); //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
    strokeWeight (0.8); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);
    line (p-a, l+z, p+a, l-z); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
   
    stroke (255, 255, 000);
    strokeWeight (3);
    line (x, y-z, x+a, y);
    stroke (255, 255, 255);
    strokeWeight (2);
    line (x+w, y-z-w, w+x+a, y-w);
       
    z = z-10;  //เป็นการเพิ่มค่าให้กับตัวแปร z หมายความว่า z  จะมีค่าเท่ากับ ค่าของตัวแปร z บวกกับ10
    a = a+10;
    count = count +1;
  }
} //ปีกกาปิด เพื่อจบฟังก์ชั่น

Express way

void setup () { //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
  size (500, 500); //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
  background (255, 255, 000); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000

  //variable เป็นบรรทัดที่จะมีการประกาศตัวแปร
  int count = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร count นั่นเอง
  int n = 5; //ความหมายคือ นำ 5 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร n นั่นเอง
  int x = 0;
  int y = 150;
  int z = 300;
  int space = 100;

  //loop  สามารถนำ while มาช่วยในการสร้าง loop ได้
  while (count<=n) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ count น้อยกว่าหรือเท่ากับ ค่าของ n นั้น จะสั่งให้วาดเส้นตรงออกมาเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปร x และ count นั่นเอง
    stroke (204, 102, 000); //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
    strokeWeight (30); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);
    line (x, y, x, y+z); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
    x = x+space; //เป็นการเพิ่มค่าให้กับตัวแปร x หมายความว่า x จะมีค่าเท่ากับ ค่าของตัวแปร x บวกกับค่าของตัวแปร space
    count = count+1;
  }
 
  //draw Beam วาดคานของทางด่วน
  stroke (153, 051, 000);
  strokeWeight (50);
  line (0, y, 500, y);
 
  //draw car วาดรถ
  stroke (000, 000, 000);
  strokeWeight (5);
  fill (000, 204, 255); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
  rect (200, y-70, 100, 50, 300, 10, 10, 10); //เป็นการสร้างรูปสีเหลี่ยม โดย rect (จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนx, จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนy, ค่าขนาดความกว้างตามแกนx, ค่าขนาดความกว้างตามแกนy, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนขวา, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างขวา);
  fill (000, 000, 000);
  ellipse (230, y-20, 15, 10); //คือคำสั่งที่ใช้ในการวาดรูปทรงกลม หรือทรงรีก็ได้ โดย ellipse (ค่าxที่เป็นจุดศูนย์กลางวงกลม, ค่าyที่เป็นจุดศูนย์กลางวงกลม, ขนาดความยาวของวงกลมตามแกนx, ขนาดความยาวของวงกลมตามแกนy); ถ้าขนาดความยาวของวงกลมตามแกนx กับ ขนาดความยาวของวงกลมตามแกนy เท่ากันจะเป็นวงกลม แต่ถ้าไม่จะเป็นวงรี
  ellipse (270, y-20, 15, 10);
}  //ปีกกาปิด เพื่อจบฟังก์ชั่น

@ Mobile @

void setup () {  //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
   size (500, 500); //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
   background (051, 000, 000); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000

   //variable เป็นบรรทัดที่จะมีการประกาศตัวแปร
   int count = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร count นั่นเอง
   int n = 3; //ความหมายคือ นำ 3 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร n นั่นเอง
   int x = 100;
   int y = 20;
   int z = 300;
   int space = 100;

   //draw Beam วาดแกนหรือคานของโมบาย
   stroke (255, 000, 000);  //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
   strokeWeight (50); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);
   line (50, 80, 450, 80); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
   line (250, 0, 250, 80);

   //loop สามารถนำ while มาช่วยในการสร้าง loop ได้
   while (count<=n) {  //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ count น้อยกว่าหรือเท่ากับ ค่าของ n นั้น จะสั่งให้วาดเส้นตรงออกมาเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปร x และ count นั่นเอง
     stroke (255, 255, 000);
     strokeWeight (10);
     line (x, y, x, y+z);
     x = x+space;  //เป็นการเพิ่มค่าให้กับตัวแปร x หมายความว่า x จะมีค่าเท่ากับ ค่าของตัวแปร x บวกกับค่าของตัวแปร space
     count = count+1;
   }

   //draw small Circle Bead วาดลูกปัดลูกเล็ก
   stroke (000, 000, 255);
   strokeWeight (5);
   Circle (100, 80, 10, 10); //เป็นการเรียกใช้ฟังก์ชั่นแบบ with parameter คือต้องกำหนดค่าเข้าไปในฟังก์ชั่นก่อนจึงจะทำงานได้ ผลที่ได้จะเปลี่ยนไปตามค่าที่กำหนด มีข้อดีคือถ้าต้องการเรียกใช้คำสั่ง
เหมือนกันหลายๆครั้ง วิธีนี้สามารถช่วยประหยัดเวลาในการเขียนได้ ส่วนในบรรทัดนี้เป็นการกำหนดค่า และเรียกใช้คำสั่งวาดวงกลมในฟังก์ชั่นชื่อ Circle นั่นเอง
   Circle (200, 80, 10, 10);
   Circle (300, 80, 10, 10);
   Circle (400, 80, 10, 10);

   //draw big Circle Bead วาดลูกปัดเม็ดใหญ่
   stroke (153, 051, 153);
   strokeWeight (5);
   Circle (100, 250, 50, 10);
   Circle (200, 250, 50, 10);
   Circle (300, 250, 50, 10);
   Circle (400, 250, 50, 10);

   fill (255, 000, 102); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
   Circle (100, 180, 50, 100);
   Circle (200, 180, 50, 100);
   Circle (300, 180, 50, 100);
   Circle (400, 180, 50, 100);

   //draw Square Bead วาดลูกปัดเม็ดสี่เหลี่ยม
   stroke (051, 255, 000);
   strokeWeight (5);
   fill (255, 000, 051);
   rect (75, y+z, 50, 80); //เป็นการสร้างรูปสีเหลี่ยม โดย rect (จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนx, จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนy, ค่าขนาดความกว้างตามแกนx, ค่าขนาดความกว้างตามแกนy, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนขวา, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างขวา);
   rect (175, y+z, 50, 80);
   rect (275, y+z, 50, 80);
   rect (375, y+z, 50, 80);
 }  //เครื่องหมายนี้แสดงถึงการสิ้นสุดของฟังก์ชั่น Setup

 void Circle (int c, int v, int b, int m) {  //เป็นการประกาศฟังก์ชั่นชื่อ Circle โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ และเป็นแบบ functions with parameter คือดังที่กล่าวไว้ด้านบน
   ellipse (c, v, b, m); //คือคำสั่งที่ใช้ในการวาดรูปทรงกลม หรือทรงรีก็ได้ โดย ellipse (ค่าxที่เป็นจุดศูนย์กลางวงกลม, ค่าyที่เป็นจุดศูนย์กลางวงกลม, ขนาดความยาวของวงกลมตามแกนx, ขนาดความยาวของวงกลมตามแกนy); ถ้าขนาดความยาวของวงกลมตามแกนx กับ ขนาดความยาวของวงกลมตามแกนy เท่ากันจะเป็นวงกลม แต่ถ้าไม่จะเป็นวงรี
 }

^o^ Rail Way

void setup () { //เป็นการประกาศฟังก์ชั่นชื่อ setup โดย void ที่อยู่ข้างหน้าหมายถึงทำเฉพาะในฟังก์ชั่นไม่มีการเรียกค่ากลับ
  size (500, 500); //เป็นการกำหนดขนาดของcanvas โดย size (ขนาดของแกนx, ขนาดของแกนy);
  background (153, 255, 000); //เป็นการเพิ่มสีให้กับพื้นหลัง โดย background(สีแดง, สีเขียว, สีน้ำเงิน); ค่าของสีแต่ละตัวมีได้สูงสุดไม่เกิน 255 และต่ำสุดที่ 000

  //variable เป็นบรรทัดที่จะมีการประกาศตัวแปร
  int count = 0; //เป็นบรรทัดที่ประกาศ และกำหนดตัวแปร โดย int คือค่าของตัวแปรที่เป็นจำนวนเต็ม หลักการคือนำค่าทางด้านขวาของเครื่องหมาย = ไปใส่ให้ทางด้านซ้ายเรียกว่า Assingment Operator ในที่นี้หมายถึง นำ 0 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร count นั่นเอง
  int n = 10; //ความหมายคือ นำ 10 ซึ่งเป็นจำนวนเต็ม ทางด้านขวาของเครื่องหมาย = ไปใส่ค่าให้กับตัวแปรทางด้านซ้าย คือตัวแปร n นั่นเอง
  int x = 30;
  int y = 250;
  int z = 100;
  int space = 50;

  //draw Rail way //วาดทางรถไฟโดยใช้ loop
  stroke (102, 051, 000); //คือคำสั่งเกี่ยวกับการเติมสีเส้น โดย stroke (ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
  strokeWeight (15); //เป็นการกำหนดความหนาของเส้น โดยstrokeWeight(ค่าความหนาของเส้น);
  line (0, y, 500, y); //เป็นการสร้างเส้น โดย line (ค่าพิกัดจุดเริ่มของx, ค่าพิกัดจุดเริ่มของy, ค่าพิกัดจุดสิ้นสุดของx, ค่าพิกัดจุดสิ้นสุดของy);
  line (0, y+z, 500, y+z);

 //loop สามารถนำ while มาช่วยในการสร้าง loop ได้
  while (count<=n) { //เป็นคำสั่ง while ซึ่งหลักการคือ ถ้าเงื่อนไขที่กำหนดเป็นจริงจะกระทำตามที่เราสั่งไว้ ไปเรื่อยๆ จะกว่าเงื่อนไขนั้นจะเป็นเท็จ รูปแบบการเขียนคือ while (เงื่อนไข){คำสั่ง} โดยในข้อนี้สามารถอธิบายได้ว่า ขณะที่ count น้อยกว่าหรือเท่ากับ ค่าของ n นั้น จะสั่งให้วาดเส้นตรงออกมาเรื่อยๆ ถ้าอยากให้หยุดเราต้องทำให้สถานะการณ์นี้เป็นเท็จ โดยเพิ่มค่าให้กับตัวแปร x และ count นั่นเอง
    stroke (051, 000, 000);
    strokeWeight (10);
    line (x, y, x, y+z);
    x = x+space; //เป็นการเพิ่มค่าให้กับตัวแปร x หมายความว่า x จะมีค่าเท่ากับ ค่าของตัวแปร x บวกกับค่าของตัวแปร space
    count = count+1;
  }

  //draw Smokestack วาดปล่องควัน
  stroke (051, 051, 051);
  strokeWeight (5);
  fill (102, 102, 102); //เป็นการเติมสีให้กับรูปร่างที่เราสร้าง โดยfill(ค่าของสีแดง, ค่าของสีเขียว, ค่าของสีน้ำเงิน);
  rect (200, 150, 40, 60, 10); //เป็นการสร้างรูปสีเหลี่ยม โดย rect (จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนx, จุดเริ่มต้นของการวาดสี่เหลี่ยมตามแกนy, ค่าขนาดความกว้างตามแกนx, ค่าขนาดความกว้างตามแกนy, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านบนขวา, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างซ้าย, ค่าความโค้งมนของมุมสี่เหลี่ยมด้านล่างขวา);

 //draw train  เป็นการวาดตัวรถไฟ
  fill (255, 000, 153);
  rect (50, 200, 200, 100, 300, 10, 10, 300);
  fill (000, 000, 000);
  rect (250, 230, 20, 50, 30);
  fill (255, 000, 102);
  rect (270, 200, 150, 100, 20);
  fill (000, 000, 000);
  rect (420, 230, 20, 50, 30);
  fill (255, 051, 102);
  rect (440, 200, 150, 100, 20);
}  //ปีกกาปิด เพื่อจบฟังก์ชั่น

Functions

= Easy =

Proposition => Write the object definition functions for an object called car with four properties: model, make, year and price and define value respectively 67, 83, 12 and 25. (กำหนดฟังก์ชั่นชื่อ car สำหรับโจทย์ต่อไปนี้ model, make, year, price และใส่ค่าที่เป็นจำนวนเต็มตามลำดับ 67, 83, 12, 25)

Solution =>
void car () {
int model = 67;
int make = 83;
int year = 12;
int price = 25;
}


Explain => จากโจทย์ให้กำหนดฟังชั่นที่ชื่อ car สำหรับเรียกชื่อ model, make, year, price ซึ่งทำได้ดังนี้


void car () { //เป็นการประกาศฟังก์ชั่นชื่อ car และ void ข้างหน้าคือการไม่เรียกค่ากลับ
int model = 67; //เป็นการประกาศตัวแปรชื่อmodelทางซ้าย โดยรับค่าจำนวนเต็มคือ 67 ทางด้านขวา
int make = 83;
int year = 12;
int price = 25;
}
 From : Teach yourself java script in a week => ISBN : 1-57521-073-8

= Medium=

Proposition => For each of the following problem, decide which is more appropriate, an if-else or an if in function Explain your answers. Students who are candidates for admission to a college submit their SAT scores. If a student's score is equal to or greater than a certain value, print a letter of acceptance for the student. Otherwise, print a rejection notice. (ลองใช้ if-else หรือ if ในฟังก์ชั่นช่วยในการอธิบายโจทย์ต่อไปนี้ นักเรียนที่สมัครเข้าศึกษาต่อที่วิทยาลัยโดยใช้คะแนนSATถ้าคะแนนของนักเรียนมากกว่าหรือเท่ากับค่าคงที่ที่เรากำหนด ให้พิมพ์คำว่า acceptance  แต่ถ้าไม่พิมพ์คำว่า rejection)


Solution =>
void setup () {
  //variable
  int SAT = 50;
  int x = 30;
  if (SAT>=x) {
    println ("acceptance");
  }
  else {
    println ("rejection");
  }
}
Explain =>
void setup () { //เป็นการประกาศฟังก์ชั่นชื่อ setup โดยที่ไม่มีการเรียกค่ากลับเนื่องจากมี void
  //variable
  int SAT = 50; //เป็นการประกาศตัวแปร โดยที่ตัวเลขทางด้านขวามือ คือคะแนนสอบSATของนักเรียนแต่ละคนนี่สมมุติให้เป็น 50 จะนำค่าไปใส่ให้กับตัวแปรชื่อ SAT ทางซ้ายมือของเครื่องหมายเท่ากับ  int x = 30; // ตัวแปร x คือค่าคงตัวที่เรากำหนดใช้เป็นเกณฑ์ในการเปรียบเทียบ
  if (SAT>=x) { //เป็นเงื่อนไข คือถ้า SAT มากกว่าหรือเท่ากับ x จะพิมพ์คำว่า acceptance ซึ่งแปลว่ายอมรับ ถ้าไม่จะพิมพ์คำว่า rejection แปลว่าปฏิเสท นั่นเอง    println ("acceptance");
  }
  else {
    println ("rejection");
  }
}
 From : Programming and Problem solving with Java => ISBN_13 : 978-0-7637-3402-2

= Hard =

Proposition => Create User define functions for draw a picture multiple circles.(สร้างฟังก์ชั่นที่กำหนดเอง สำหรับวาดภาพวงกลมหลายวง)

Solution =>
void MulCircle (int x, int r) {
  ellipse (x, 50, r, r);
}
void setup () {
  size (100, 100);
  MulCircle (10, 10);
  MulCircle (20, 10);
  MulCircle (30, 10);
  MulCircle (40, 10);
  MulCircle (50, 10);
  MulCircle (60, 10);
  MulCircle (70, 10);
  MulCircle (80, 10);
  MulCircle (90, 10);
}


Explain =>
void MulCircle (int x, int r) {
  ellipse (x, 50, r, r);
} //เป็นการสร้างฟังก์ชั่นใหม่ โดยชื่อ MulCircle ภายในประกอบด้วยตัวแปร x, r และคำสั่งที่ใช้วาดวงกลม
void setup () {
  size (100, 100);
  MulCircle (10, 10); //เป็นการเรียกใช้ฟังก์ชั่น โดยวิธีเรียกใช้คือ ใช้แค่ชื่อ และใส่ค่าของพารามิเตอร์ ถ้ามี ดังตัวอย่าง ชื่อฟีงก์ชั่นคือ MulCircle มีพารามืเตอร์คือ (10, 10) นั่นเอง
  MulCircle (20, 10);
  MulCircle (30, 10);
  MulCircle (40, 10);
  MulCircle (50, 10);
  MulCircle (60, 10);
  MulCircle (70, 10);
  MulCircle (80, 10);
  MulCircle (90, 10);
} //เป็นฟังก์ชั่นชื่อ setup ซึ่งจะถูกเรียกใช้ก่อนเสมอ โดยในที่นี้สร้างขึ้นมาเพื่อเรียกใช้ฟังก์ชั่น MulCircle เป็นการวากวงกลมนั่นเอง

 From : Programming and Problem solving with Java => ISBN_13 : 978-0-7637-3402-2