011. 실행 흐름의 컨트롤(반복문) while, do~while, for문 실습

2023.02.08 (수)

실행 흐름의 컨트롤 (반복문)
while문 실습

• Test051
  - 반복문(while문) 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - 반복문(while문) 실습
=================================================*/

// 사용자로부터 임의의 정수를 입력받아
// 입력받은 정수가 소수인지 아닌지를 판별하여
// 결과를 출력하는 프로그램을 구현한다.

// ※ 소수 : 1 또는 자기 자신의 값 이외에 어떤 수로도
//			 나누어 떨어지지 않는 수.
//			 단, 1은 소수가 아님.

// 실행 예)
// 임의의 정수 입력 : 10
// 10 → 소수 아님
// 계속하려면 아무 키나 누르세요...

// 임의의 정수 입력 : 11
// 11 → 소수
// 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test051
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("임의의 정수 입력 : ");
		int n = Integer.parseInt(br.readLine());

		int i = 2;
		boolean flag = true;

		while (i<n)
		{
			if (n % i == 0)
			{
				flag = false;
				break;
			}
			i++;
		}

		if (flag && n!=1)		// true 이자 1이 아닌 수
			System.out.printf("%d → %s\n", n, "소수");
		else
			System.out.printf("%d → %s\n", n, "소수아님");
	}	
}

// 실행 결과

/*
임의의 정수 입력 : 13
13 → 소수
계속하려면 아무 키나 누르십시오 . . .
*/

/*
임의의 정수 입력 : 1
1 → 소수아님
계속하려면 아무 키나 누르십시오 . . .
*/

※ 소수 판별에 1인지 아닌지 검증 절차가 한 번 더 필요한데 이미 출력해버리면 수정이 불가능하기 때문에
     boolean 값을 통해 잠정적인 값을 들고, 최종 확인 후에 출력하는 구조

※ if (boolean (논리연산자&&) 수식)                    // 양쪽 값이 전부 true가 아니면 false

---

• Test052
  - 반복문(while문) 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - 반복문(while문) 실습
=================================================*/

// 사용자로부터 임의의 두 정수를 입력받아
// 입력받은 두 정수 중
// 작은 수 부터 큰 수 까지의 합을 구하여
// 결과를 출력하는 프로그램을 구현한다.

// 실행 예)
// 첫 번째 정수 입력 : 100
// 두 번째 정수 입력 : 200
// >> 100 ~200 까지의 합 : xxxx
// 계속하려면 아무 키나 누르세요

// 첫 번째 정수 입력 : 1000
// 두 번째 정수 입력 : 2
// >> 2 ~ 1000 까지의 합 : xxxx
// 계속하려면 아무 키나 누르세요

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test052
{
	public static void main(String[] args) throws IOException
	{
		// 주요 변수 선언 및 초기화
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n;			//-- 루프 변수로 활용할 변수 선언
		int su1, su2;	//-- 첫 번째, 두 번째 사용자 입력값을 담아낼 변수
		int result=0;		//-- 누적합을 담아낼 변수

		// 연산 및 처리

		System.out.print("첫 번째 정수 입력 : ");
		su1 = Integer.parseInt(br.readLine());
		
		System.out.print("두 번째 정수 입력 : ");
		su2 = Integer.parseInt(br.readLine());

		// 입력받은 두 수의 크기 비교 및 자리바꿈
		// 즉, su1이 su2보다 큰 경우... 두 수의 자리를 바꿀 수 있도록 처리
		if (su1>su2)
		{
			// 자리바꿈
			su1=su1^su2;
			su2=su2^su1;
			su1=su1^su2;
		}

		// 반복 연산 수행
		// 반복 연산을 수행하기에 앞서 (반복 연산을 수행하기 전에)
		// 작은 수를 따로 저장하여 루프 변수로 활용한다.

		n = su1;

		while (n<=su2)
		{
			result += n;
			n++;
		}

		// 결과 출력
		System.out.printf(">> %d ~ %d 까지의 합 : %d\n", su1, su2, result);

	}
}

// 실행 결과

/*
첫 번째 정수 입력 : 300
두 번째 정수 입력 : 10
>> 10 ~ 300 까지의 합 : 45105
계속하려면 아무 키나 누르십시오 . . .
*/

/*
첫 번째 정수 입력 : 50
두 번째 정수 입력 : 100
>> 50 ~ 100 까지의 합 : 3825
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test053
  - 반복문(while문) 실습

// ○ 과제
// 사용자로부터 임의의 정수를 입력받아
// 1 부터 입력받은 그 정수까지의
// 전제 합과, 짝수의 합과, 홀수의 합을
// 각각 결과 값으로 출력하는 프로그램을 구현한다.

// 실행 예) // 임의의 정수 입력 : 586
// >> 1 ~ 586 까지 정수의 합 : xxxx
// >> 1 ~ 586 까지 짝수의 합 : xxxx
// >> 1 ~ 586 까지 홀수의 합 : xxxx
// 계속하려면 아무 키나 누르세요....

풀이)

import java.io.BufferedReader;		// 입력 받아옴
import java.io.InputStreamReader;	// 입력받은 값을 번역
import java.io.IOException;			// 예외처리

public class Test053
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader (new InputStreamReader(System.in));		// 사용자로부터 변수를 받아오기 위해 사용

		int n; // 사용자로부터 입력받을 임의의 정수를 담을 변수
		int a = 1; // 1 부터 n 까지 증가할 루프 변수
		int sum, even, odd;	// 전체의 합을 담을 변수, 짝수의 합을 담을 변수, 홀수의 합을 담을 변수

		sum = even = odd = 0;		// sum, even, odd 값을 초기화하여 값을 증가/감소 시킬 수 있게 함

		System.out.print("임의의 정수 입력 : "); // 사용자에게 출력
		n = Integer.parseInt(br.readLine()); // 사용자가 위 출력을 보고 입력한 값을 담음 
											 // br.readLine으로 문자열값을 받아오고
											 // Integer.parseInt로 정수형태로 변환하여 가져옴

		while (a<=n)			// a가 n 값까지 도달할때까지 반복하겠다
		{
			sum += a;			// 정수의 합 변수에 a만큼 증감
			if (a%2 ==0)		// 정수가 짝수일 경우
			{
				even +=a;		// 짝수합에 a만큼 증감
			}
			else if (a%2!=0)	// 정수가 홀수일 경우
			{
				odd +=a;		// 홀수합에 a만큼 증감
			}
			a++;				// a 를 1만큼 증가

		}

		//결과 출력
		System.out.printf("\n>> 1 ~ %d 까지 정수의 합 : %d\n", n, sum);		//한 줄 개행 후 1부터 (입력값)까지 정수의 합 : (합계) , (입력값), (정수의 합)
		System.out.printf(">> 1 ~ %d 까지 짝수의 합 : %d\n", n, even);		//한 줄 개행 후 1부터 (입력값)까지 짝수의 합 : (합계) , (입력값), (짝수의 합)
		System.out.printf(">> 1 ~ %d 까지 홀수의 합 : %d\n", n, odd);		//한 줄 개행 후 1부터 (입력값)까지 홀수의 합 : (합계) , (입력값), (홀수의 합)

	}
}

---

• Test054
  - 반복문(while문) 실습

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test054
{
	public static void main(String [] args) throws IOException
	{
		// 주요 변수 선언 및 초기화
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int dan;		// 사용자로부터 입력 값을 정수 형태로 담아낼 변수 (→ 단)

		// 연산 및 처리
		System.out.print("원하는 단 (구구단) 입력 : ");
		dan = Integer.parseInt(br.readLine());

		if (dan<1 || dan>9)
		{
			System.out.println("1 부터 9 까지의 정수만 입력이 가능합니다.");
			return;
		}

		int n=0;			// 곱해지는 수를 담아낼 변수

		// 결과 출력 (반복문 구성 → 반복 출력)
		while (n<9)
		{
			n++;
			System.out.printf("%d * %d = %d\n", dan, n, (dan*n));
		}

	}
}

---

실행 흐름의 컨트롤 (제어문)
- 반복문(do~while문) 

• do~while문
  - 『do~while』문은 『while』문과 마찬가지로 특정한 영역을 반복 수행하는 반복문이다.
   다만, 『do~while』문이 『while』문과 다른점은 조건식에 대한 검사를 반복문을 수행한 이후에 한다는 것이다.
  이와 같은 성격으로 인해 반드시 한 번은 수행하게 되는 특징을 갖는다.

// do~while 문의 형식 및 구조
	do
	{
		실행문;
	}
	while (조건식) ;

	// while ↔ do~while ↔ for 변환 가능

// do~ while 문의 활용 모델
// 예를 들어...
// 사용자로부터 특정 범위의 수가 입력 될 때 까지
// 입력받는 행위 자체를 반복해서 수행해야하는 상황이라 가정한다.

// 즉, 최소 한 번은 사용자의 입력값을 받아오는 처리를 수행해야
// 원하는 범위의 값을 제대로 입력했는지 확인할 수 있고
// 이 과정을 거쳐야 반복을 추가로 수행해야 할지 말지의 여부를
// 결정할 수 있는 상황이 된다.

---

• Test055
  - do ~ while 문 관찰

public class Test055
{
	public static void main(String[] args)
	{
		// ※ while 반복문을 통해 구현했던 내용들을
		//	  do~while 문을 통해서도 구현할 수 있다.
		/*
		int n =1;

		do
		{
			System.out.println("n : " +n);
			n++;
		}
		while (n<=10);
		*/

		/*
		int n =1;

		do
		{
			n++;
			System.out.println("n : " +n);
		}
		while (n<=10);
		*/
		/*
		int n =0;

		do
		{
			n++;
			System.out.println("n : " +n);
		}
		while (n<=10);
		*/
		/*
		int n =0;

		do
		{
			n++;
			System.out.println("n : " +n);
		}
		while (n<10);
		*/
		/*
		int n =0;

		do
		{
			System.out.println("n : " + ++n);
		}
		while (n<10);
		*/

		java.util.Scanner sc = new java.util.Scanner(System.in);
		int num;

		do
		{
			System.out.print("100 이상의 정수를 입력하세요 : ");
			num = sc.nextInt();
		}
		while (num<100);

		System.out.print(num + " → 100 이상의 정수 입력 완료~!!!\n");

---

• Test056_1 (추가 과제)
  - do~while문 실습

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - 반복문(do~while문) 실습
=================================================*/

// ○ 과제
//		추가 정책 적용 후 『Test056_1.java』의 형태로 구성하여 제출한다.
//----------------------------------------------------------------------
//		---------개인별 수립!
//		(음수 입력시에 어떻게 표현할 것인지) 
//============================================================
//	조건 : -1을 제외한 음수의 경우에는 오류메세지 출력 후 종료
//============================================================
// 사용자로부터 여러 개의 양의 정수를 입력받고
// 그 합을 계산하여 출력하는 프로그램을 작성한다.
// 단, 사용자에 의해 -1 이 입력되는 순간
// 반복하던 입력 행위를 중지하고
// 그 동안 입력된 정수의 합을 출력해주는 프로그램을 구현한다.
// 즉, -1 을 입력 중지 커맨드로 활용한다.
// do~ while 문을 활용하여 문제를 해결할 수 있도록 한다.

// 실행 예)
// 1번째 정수 입력(-1 종료) : 10
// 2번째 정수 입력(-1 종료) : 5
// 3번째 정수 입력(-1 종료) : 8
// 4번째 정수 입력(-1 종료) : 9
// 5번째 정수 입력(-1 종료) : -1

// >> 현재까지 입력된 정수의 합 : 32
// 계속하려면 아무 키나 누르세요...


// 1번째 정수 입력(-1 종료) : -1
// >> 현재까지 입력된 정수의 합 : 0
// 계속하려면 아무 키나 누르세요...


// 이미 외부에서 만들어진 기능을 가지고 들어옴 (참조)

import java.io.BufferedReader;		// 입력 받아옴
import java.io.InputStreamReader;	// 입력받은 값을 번역
import java.io.IOException;			// 예외처리

public class Test056_1
{
	public static void main(String[] args) throws IOException
	{
		//인스턴스 생성
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 		// 사용자로부터 변수를 받아오기 위해 사용

		// 주요 변수 선언 및 초기화

		int num;		// 사용자로부터 입력받을 정수
		int a=1;		// 사용자로부터 몇번째 입력받는지 안내할 변수
		int sum=0;		// 사용자로부터 입력받은 정수 누적 합

		// 연산 처리

		do		// 무조건 한번은 실행되는 do~while문 사용			// 사용자에게 의사를 물어보고 지속 혹은 종료 해야해서
		{
			System.out.printf("%d 번째 정수 입력(-1 종료) : ", a);	// 사용자에게 출력
			num = Integer.parseInt(br.readLine());	// 사용자가 입력한 값을 가져옴
			
			if (num < -1)		//	-1을 제외한 음수일 경우
			{
				System.out.println("오류"); // 오류 문구 출력
				return; // 프로그램 종료
			}
			else		// 양의 정수인 경우
			{
				sum += num;	// 합계에 해당 정수를 증감
				a++;	// 몇번째인지 나타내는 변수를 1증가
				
			}
		 }

			while (num != -1);	// -1을 입력했을 경우에 반복문을 더이상 반복하지 않고 빠져나옴

		// 최종결과 출력

		System.out.printf(">> 현재까지 입력된 정수의 합 : %d\n", (sum+1));

		
	}
}

---

실행 흐름의 컨트롤 (제어문)
- 반복문(for 문) 

• for  문
  - 『for』문은 정해진 횟수만큼 반복해야 하는 경우 유용하게 사용되어지는 반복문으로
   『while』문과 마찬가지로 반복 실행해야 하는 구문이 조건에 맞지 않을 경우 한 번도 수행하지 않을 수 있으며
   루프 변수의 초기값, 조건식, 증감식 등을 한 지점에서 확인할 수 있기 때문에 가독성이 높은 반복문에 해당한다.

○	형식 및 구조

	for (수식1; 수식2; 수식3)
	{
		실행문;
	}

	수식1은 루프변수의 초기화를 위해 사용되며,
			최초 단 한 번만 실행된다.
	수식2는 조건식을 나타내는 것으로 이 조건식(수식2)이 만족하면(true)
			루프를 반복해서 수행하게 된다.
			『for』문의 진행순서는 수식2가 참이면 반복문을 수행하고
			수식3을 실행한 후 수식2의 조건식을 다시 검사하는 구조로 진행된다.
			따라서 처름에 조건식의 처리 결과가 거짓일 경우
			『for』루프를 한 번도 수행하지 않게 되는 것이다.
	수식3은 루프 변수의 재초기화를 위해 사용되어지며,
			반복문의 조건식을 무너뜨리게 되는 증감식으로 처리하는 것이 일반적이다.
			컴마(『,』)를 이용하여 여러 문장을 동시에 수행할 수도 있다.

---

• Test057
  - for 문 관찰

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - 반복문(for문) 실습
=================================================*/

public class Test057
{
	public static void main(String[] args)
	{
		int n=1,m;		// n : while 문에서 사용할 루프 변수
						// m : for 문에서 사용할 루프 변수

		while (n<=10)
		{
			System.out.println("n=" +n);
			n++;
		}
		System.out.println();

		// ※ 위의 while 문을 for 문으로 바꾼다.
        
		// 방법1
		for (m=1; m<=10; m++)
		{
			System.out.println("m=" +m);
		}
		// 방법2
		for (m=1; m<=10; m++)
			System.out.println("m=" +m);
	}
}

---

• Test058
  - for 문 실습

 

/*================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
	   - 반복문(for문) 실습
=================================================*/

// 1 부터 100 까지의 정수 중에서
// 4의 배수만 출력하는 프로그램을 구현한다.
// 단 , for 문을 활용해야 하며
// 한 줄에 5개씩만 출력할 수 있도록 한다.

// 실행 예)
//      4   8   12   16   20
//     24  28   32   36   40
//              :
//	            :
// 계속하려면 아무 키나 누르세요...

public class Test058
{
	public static void main(String[] args)
	{
		for (int n=4 ;n<=100 ; n+=4 )
		{
			//System.out.println("n="+n);
			//System.out.print(n + " ");
			System.out.printf("%4d", n);

			// 출력 구문이 4*5의 배수인 상태가 될 때마다
			// 개행
			if (n%(4*5)==0) // n이 4*5의 배수인 상태가 될 때 마다
			{
				//개행
				System.out.println();
			}
		}
	}
}

// 실행 결과 

/*
   4   8  12  16  20
  24  28  32  36  40
  44  48  52  56  60
  64  68  72  76  80
  84  88  92  96 100
계속하려면 아무 키나 누르십시오 . . .
*/

---

• Test059
  - 반복문(for문) 실습
  - 다중 for문 (반복문의 중첩)을 활용한 구구단 출력 실습

/*====================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
- 반복문(for문) 실습
- 다중 for문 (반복문의 중첩)을 활용한 구구단 출력 실습
=====================================================*/

/*
// 실행 예)
==[2단]==
2 * 1 = 2
2 * 2 = 4
	:

==[3단]==
	:

9 * 9 = 81
계속하려면 아무 키나 누르세요...
*/
public class Test059
{
	public static void main(String[] args)
	{
		int i,j;		// 루프 변수
		
		// 웅~~~~ 
		for (i=2; i<=9 ; i++) // 단 처리(2) → 2 3 4 5 6 7 8 9
		{
			//테스트(확인)
			//System.out.println("i="+i);
			System.out.printf("\n==[%d단]==\n", i);

			for (j=1; j<=9; j++) // 곱해지는 수 처리 (j) → 1 2 3 4 5 6 7 8 9
			{
				//테스트(확인)
				//System.out.println("j="+j);
				System.out.printf("%d * %d = %d\n", i, j, (i*j));
			}
		}
	}
}

---

• Test060
  - 반복문(for문) 실습
  - 다중 for문 (반복문의 중첩)을 활용한 구구단 출력 실습

/*====================================================
	 ■■■ 실행 흐름의 컨트롤 (제어문) ■■■
- 반복문(for문) 실습
- 다중 for문 (반복문의 중첩)을 활용한 구구단 출력 실습
=====================================================*/

// ① 2중첩 * 2 해결 
// ② 3중첩 * 1 해결


// 실행 예)
/*
2 * 1 =  2	3 * 1 =  3  4 * 1 =  4  5 * 1 =  5
2 * 2 =  4	3 * 2 =  6  4 * 2 =  8  5 * 2 = 10
2 * 3 =  6	3 * 3 =  9  4 * 3 = 12  5 * 3 = 15
2 * 4 =  8	3 * 4 = 12  4 * 4 = 16  5 * 4 = 20
2 * 5 = 10	3 * 5 = 15  4 * 5 = 20  5 * 5 = 25
2 * 6 = 12	3 * 6 = 18  4 * 6 = 24  5 * 6 = 30
2 * 7 = 14	3 * 7 = 21  4 * 7 = 28  5 * 7 = 35
2 * 8 = 16	3 * 8 = 24  4 * 8 = 32  5 * 8 = 40
2 * 9 = 18	3 * 9 = 27  4 * 9 = 36  5 * 9 = 45

6단~~~~~~~ 7단~~~~~~~~ 8단~~~~~~~~ 9단~~~~~~~~
// 대충 위랑 같은 모양~
*/

public class Test060
{
	public static void main(String[] args)
	{
		// 방법 1 - 2중첩 2개 사용
		/*
		for (int a=1; a<=9; a++)
		{
			for (int b=2; b<=5; b++)
			{
				if ( b != 5)
					System.out.printf("%3d  *%3d = %3d", b, a, a*b);
				else if (b == 5)
					System.out.printf("%3d  *%3d = %3d\n", b, a, a*b);
			}
		}
		System.out.println();
        
		for (int c=1; c<=9 ; c++)
		{
			for (int d=6; d<=9; d++)
			{
				if ( d != 9 )
					System.out.printf("%3d  *%3d = %3d", d, c, c*d);
				else if (d == 9)
					System.out.printf("%3d  *%3d = %3d\n", d, c, c*d); 
			}
		}
		*/

		// 방법 2 - 3중첩
		// for 3중첩
		int i,j,k;
		for (k=0; k<2; k++) // 가장 큰 2단을 나누는 기준 2-6 3-7 4-8 5-9 숫자가 4씩 차이남을 이용
		{			
			for (j=1; j<10; j++) // 단 안에서 곱해지는 수를 맡음
			{
				for (i=2; i<6; i++) // 구구단의 단의 기준이 되는 수
				{
					if (i%5==0)
					{
						System.out.printf("%3d *%2d = %3d", i+4*k, j, (i+4*k)*j);
						System.out.println();
					}
					else
						System.out.printf("%3d *%2d = %3d", i+4*k, j, (i+4*k)*j);
				}
			}
			System.out.println();
		}


	}
}

// 실행 결과

/*
  2  *  1 =   2  3  *  1 =   3  4  *  1 =   4  5  *  1 =   5
  2  *  2 =   4  3  *  2 =   6  4  *  2 =   8  5  *  2 =  10
  2  *  3 =   6  3  *  3 =   9  4  *  3 =  12  5  *  3 =  15
  2  *  4 =   8  3  *  4 =  12  4  *  4 =  16  5  *  4 =  20
  2  *  5 =  10  3  *  5 =  15  4  *  5 =  20  5  *  5 =  25
  2  *  6 =  12  3  *  6 =  18  4  *  6 =  24  5  *  6 =  30
  2  *  7 =  14  3  *  7 =  21  4  *  7 =  28  5  *  7 =  35
  2  *  8 =  16  3  *  8 =  24  4  *  8 =  32  5  *  8 =  40
  2  *  9 =  18  3  *  9 =  27  4  *  9 =  36  5  *  9 =  45

  6  *  1 =   6  7  *  1 =   7  8  *  1 =   8  9  *  1 =   9
  6  *  2 =  12  7  *  2 =  14  8  *  2 =  16  9  *  2 =  18
  6  *  3 =  18  7  *  3 =  21  8  *  3 =  24  9  *  3 =  27
  6  *  4 =  24  7  *  4 =  28  8  *  4 =  32  9  *  4 =  36
  6  *  5 =  30  7  *  5 =  35  8  *  5 =  40  9  *  5 =  45
  6  *  6 =  36  7  *  6 =  42  8  *  6 =  48  9  *  6 =  54
  6  *  7 =  42  7  *  7 =  49  8  *  7 =  56  9  *  7 =  63
  6  *  8 =  48  7  *  8 =  56  8  *  8 =  64  9  *  8 =  72
  6  *  9 =  54  7  *  9 =  63  8  *  9 =  72  9  *  9 =  81

계속하려면 아무 키나 누르십시오 . . .
*/

 

// 개인적 감상

for 문을 중첩할 수록 머리 속이 복잡해지는게 실시간으로 느껴졌다. 그동안 for문을 반복할 기회가 있어 조금은 익숙해졌는지, 다시 한 번 풀때는 수월하게 풀 수 있었다.

 

코딩도 반복을 통해서 익숙해질 수 있을거라는 생각이 들고, 그래도 조금씩 발전하는 나를 보는게 뿌듯하다 :)