Oop lab/java1 - ประวัติรุ่นแก้ไข

Jittat: /* นับคู่เรียงผิด */

2014-08-18T05:22:17Z

นับคู่เรียงผิด

Jittat: /* นับมากกว่า */

2014-08-18T05:21:01Z

นับมากกว่า

Jittat: /* นับ */

2014-08-18T05:07:19Z

นับ

Jittat: /* หา */

2014-08-18T04:44:44Z

หา

Jittat: /* กลับหน้าหลัง */

2014-08-18T04:43:19Z

กลับหน้าหลัง

Jittat: /* กลับหน้าหลัง */

2014-08-18T04:33:10Z

กลับหน้าหลัง

Jittat: /* นับคู่เรียงผิด */

2014-08-18T04:08:19Z

นับคู่เรียงผิด

Jittat: /* เรียงกันหรือเปล่า? */

2014-08-18T04:00:46Z

เรียงกันหรือเปล่า?

Jittat: /* เรียงกันหรือเปล่า? */

2014-08-18T03:59:48Z

เรียงกันหรือเปล่า?

Jittat: /* ทดสอบจำนวนเฉพาะ */

2014-08-18T03:32:50Z

ทดสอบจำนวนเฉพาะ

←รุ่นแก้ไขก่อนหน้า		รุ่นแก้ไขเมื่อ 05:22, 18 สิงหาคม 2557
แถว 415:		แถว 415:

	== นับคู่เรียงผิด ==		== นับคู่เรียงผิด ==
		+	เขียนเมท็อด '''Inversion.count''' ที่รับอาร์เรย์ ar จากนั้นนับจำนวน inversion ใน ar โดยที่ inversion คือคู่ของข้อมูลที่เรียงผิดลำดับกัน ถ้าเราต้องการให้อาร์เรย์เรียงจากน้อยไปหามาก
		+
		+	เช่น ในอาร์เรย์: 1, 4, 3, 2, 5 จะมี inversion คือ (4,3), (4,2), (3,2) ดังนั้นถ้าเรานับคู่ที่เรียงผิด จะได้ว่ามี 3 คู่
		+
		+	<syntaxhighlight lang="java">
		+	public class Inversion {
		+	public static int count(int[] ar) {
		+	return 0;
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	<syntaxhighlight lang="java">
		+	public class InversionTest {
		+
		+	@Test
		+	public void testEmptyArray() {
		+	assertEquals(0, Inversion.count(new int[] {}));
		+	}
		+
		+	@Test
		+	public void testOneElement() {
		+	assertEquals(0, Inversion.count(new int[] { 7 }));
		+	}
		+
		+	@Test
		+	public void testTwoElements() {
		+	assertEquals(0, Inversion.count(new int[] { 1, 7 }));
		+	assertEquals(1, Inversion.count(new int[] { 7, 3 }));
		+	}
		+
		+	@Test
		+	public void testSorted() {
		+	assertEquals(0, Inversion.count(new int[] { 1, 2, 3, 4, 5, 6 }));
		+	assertEquals(6, Inversion.count(new int[] { 6, 5, 4, 3 }));
		+	}
		+
		+	@Test
		+	public void testList() {
		+	assertEquals(2, Inversion.count(new int[] { 1, 3, 2, 5, 4 }));
		+	assertEquals(4, Inversion.count(new int[] { 6, 5, 10, 3 }));
		+	}
		+	}
		+	</syntaxhighlight>

@@ แถว 399: / แถว 399: @@
    public void testNoGreaterThan() {
      assertEquals(0,
-         ArrayCountCond.countGreaterThan(new int[] { 200, 300 }, 100));
+         ArrayCountCond.countGreaterThan(new int[] { 200, 300 }, 400));
      assertEquals(0,
-         ArrayCountCond.countGreaterThan(new int[] { 100, 200 }, 100));
+         ArrayCountCond.countGreaterThan(new int[] { 100, 200 }, 300));
+   }
@@ แถว 407: / แถว 407: @@
    public void testSomeGreaterThan() {
      assertEquals(1,
-         ArrayCountCond.countGreaterThan(new int[] { 99, 200, 300 }, 100));
+         ArrayCountCond.countGreaterThan(new int[] { 301, 200, 300 }, 300));
      assertEquals(2,
-         ArrayCountCond.countGreaterThan(new int[] { 99, 200, 5, 300 }, 100));
+         ArrayCountCond.countGreaterThan(new int[] { 99, 100, 200, 5, 300 }, 100));
+   }
+}

@@ แถว 377: / แถว 377: @@
 </syntaxhighlight>
-== นับ ==
+== นับมากกว่า ==
 == นับคู่เรียงผิด ==

@@ แถว 336: / แถว 336: @@
 == หา ==
 == นับ ==
 == นับคู่เรียงผิด ==

@@ แถว 290: / แถว 290: @@
 เขียนเมท็อด ArrayReverse.reverse ที่รับอาร์เรย์ของจำนวนเต็ม และคืนอาร์เรย์ของจำนวนเต็มที่เรียงกลับหน้าหลัง
-ในโค้ดที่เรามีให้ มีการสร้างอาร์เรย์ผลลัพธ์ให้แล้ว
+ในโค้ดที่เรามีให้ มีการสร้างอาร์เรย์ผลลัพธ์ให้แล้ว  สังเกตว่าเราเรียก member length ของอาร์เรย์เพื่ออ่านความยาว
 <syntaxhighlight lang="java">

←รุ่นแก้ไขก่อนหน้า		รุ่นแก้ไขเมื่อ 04:33, 18 สิงหาคม 2557
แถว 288:		แถว 288:

	== กลับหน้าหลัง ==		== กลับหน้าหลัง ==
		+	เขียนเมท็อด ArrayReverse.reverse ที่รับอาร์เรย์ของจำนวนเต็ม และคืนอาร์เรย์ของจำนวนเต็มที่เรียงกลับหน้าหลัง
		+
		+	ในโค้ดที่เรามีให้ มีการสร้างอาร์เรย์ผลลัพธ์ให้แล้ว
		+
		+	<syntaxhighlight lang="java">
		+	public class ArrayReverse {
		+	public static int[] reverse(int[] ar) {
		+	int[] res = new int[ar.length];
		+
		+	// add your code here
		+
		+	return res;
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	สังเกตการใช้เมท็อด assertArrayEquals ด้านล่างด้วย
		+
		+	<syntaxhighlight lang="java">
		+	public class ArrayReverseTest {
		+
		+	@Test
		+	public void testEmptyArray() {
		+	assertArrayEquals(new int[] {},
		+	ArrayReverse.reverse(new int[] {}));
		+	}
		+
		+	@Test
		+	public void testOneElement() {
		+	assertArrayEquals(new int[] { 10 },
		+	ArrayReverse.reverse(new int[] { 10 }));
		+	assertArrayEquals(new int[] { 20 },
		+	ArrayReverse.reverse(new int[] { 20 }));
		+
		+	}
		+
		+	@Test
		+	public void testManyElements() {
		+	assertArrayEquals(new int[] { 50, 40, 30, 20, 10 },
		+	ArrayReverse.reverse(new int[] { 10, 20, 30, 40, 50 }));
		+	assertArrayEquals(new int[] { 2, 1, 2, 1, 4 },
		+	ArrayReverse.reverse(new int[] { 4, 1, 2, 1, 2 }));
		+
		+	}
		+	}
		+	</syntaxhighlight>

	== หา ==		== หา ==

@@ แถว 259: / แถว 259: @@
 	@Test
 	public void testTwoElements() {
-		assertTrue(ArrayOrder.isAscending(new int[] { 1,2 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 1, 2 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { -10,9 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { -10, 9 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { 0,1 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 0, 1 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 2,1 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 2, 1 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { -9,-10 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { -9, -10 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 1,0 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 1, 0 }));
+	}
 	@Test
 	public void testSimpleList() {
-		assertTrue(ArrayOrder.isAscending(new int[] { 1,2,5,7 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 1, 2, 5, 7 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { -1,10,50 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { -1, 10, 50 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 50,60,70,60 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 50, 60, 70, 60 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 10,9,8,7,6,5 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 10, 9, 8, 7, 6, 5 }));
+	}
@@ แถว 278: / แถว 278: @@
 	public void testWithDuplicates() {
 		assertTrue(ArrayOrder.isAscending(new int[] { 0,0 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { 100,100 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 100, 100 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { 1,1,3 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 1, 1, 3 }));
-		assertTrue(ArrayOrder.isAscending(new int[] { 0,1,1,1 }));
+		assertTrue(ArrayOrder.isAscending(new int[] { 0, 1, 1, 1 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 2,1,3,3 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 2, 1, 3, 3 }));
-		assertFalse(ArrayOrder.isAscending(new int[] { 0,0,1,1,4,4,2 }));
+		assertFalse(ArrayOrder.isAscending(new int[] { 0, 0, 1, 1, 4, 4, 2 }));
+	}
+}

←รุ่นแก้ไขก่อนหน้า		รุ่นแก้ไขเมื่อ 03:59, 18 สิงหาคม 2557
แถว 238:		แถว 238:

	== เรียงกันหรือเปล่า? ==		== เรียงกันหรือเปล่า? ==
		+	เขียนเมท็อด '''ArrayOrder.isAscending''' ที่รับอาร์เรย์แล้วคืนค่าจริงถ้าสมาชิกในอาร์เรย์มีค่าไม่ลดลง (คือจะเพิ่มขึ้นหรือเท่าเดิมก็ได้) ดูตัวอย่างจากใน TestCase
		+
		+	<syntaxhighlight lang="java">
		+	public class ArrayOrder {
		+	public static boolean isAscending(int[] ar) {
		+	return false;
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	<syntaxhighlight lang="java">
		+	public class ArrayOrderTest {
		+	@Test
		+	public void testOneElement() {
		+	assertTrue(ArrayOrder.isAscending(new int[] { 1 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { -10 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { 0 }));
		+	}
		+
		+	@Test
		+	public void testTwoElements() {
		+	assertTrue(ArrayOrder.isAscending(new int[] { 1,2 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { -10,9 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { 0,1 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 2,1 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { -9,-10 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 1,0 }));
		+	}
		+
		+	@Test
		+	public void testSimpleList() {
		+	assertTrue(ArrayOrder.isAscending(new int[] { 1,2,5,7 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { -1,10,50 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 50,60,70,60 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 10,9,8,7,6,5 }));
		+	}
		+
		+	@Test
		+	public void testWithDuplicates() {
		+	assertTrue(ArrayOrder.isAscending(new int[] { 0,0 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { 100,100 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { 1,1,3 }));
		+	assertTrue(ArrayOrder.isAscending(new int[] { 0,1,1,1 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 2,1,3,3 }));
		+	assertFalse(ArrayOrder.isAscending(new int[] { 0,0,1,1,4,4,2 }));
		+	}
		+	}
		+	</syntaxhighlight>
		+
	== นับคู่เรียงผิด ==		== นับคู่เรียงผิด ==

←รุ่นแก้ไขก่อนหน้า		รุ่นแก้ไขเมื่อ 03:32, 18 สิงหาคม 2557
แถว 153:		แถว 153:

	== ทดสอบจำนวนเฉพาะ ==		== ทดสอบจำนวนเฉพาะ ==
		+	เขียนเมท็อด '''Prime.isPrime''' ในคลาส Prime ที่คืนค่า true เมื่อข้อมูลที่ป้อนมาเป็นจำนวนเฉพาะ
		+
		+	<syntaxhighlight lang="java">
		+	public class Prime {
		+	public static boolean isPrime(int n) {
		+	return false;
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	สังเกตว่าเราต้องการทดสอบ boolean เพื่อความชัดเจนเราจะสั่ง assertTrue กับ assertFalse แทน
		+
		+	<syntaxhighlight lang="java">
		+	public class PrimeTest {
		+
		+	@Test
		+	public void testPrime() {
		+	assertTrue(Prime.isPrime(2));
		+	assertTrue(Prime.isPrime(3));
		+	assertTrue(Prime.isPrime(5));
		+	assertTrue(Prime.isPrime(157));
		+	assertTrue(Prime.isPrime(56687));
		+	assertTrue(Prime.isPrime(102551));
		+	}
		+
		+	@Test
		+	public void testComposite() {
		+	assertFalse(Prime.isPrime(4));
		+	assertFalse(Prime.isPrime(200));
		+	assertFalse(Prime.isPrime(75));
		+	assertFalse(Prime.isPrime(396809));
		+	assertFalse(Prime.isPrime(96172057));
		+	}
		+
		+	@Test
		+	public void testOne() {
		+	assertFalse(Prime.isPrime(1));
		+	}
		+	}
		+	</syntaxhighlight>

	== ค่าสูงสุด ==		== ค่าสูงสุด ==