목향수의 백과사전: 2017

2017년 7월 2일 일요일

sys와 system의 권한

<OS(Linux) user>
-root

<DB user> (DB생성 시 만들어진다.)
-sys : sysdba권한(dba + DB생성 + DB 시작/종료)
-system : dba권한
-hr : Object 관리권한

**sys와 system이 사용자를 생성시 부여할 수 있는 최고 권한은 dba권한까지이다.

2017년 6월 18일 일요일

Eclipse의 설정 복원하기

1. File -> Import… 클릭

2. Preferences 선택 후 Next > 클릭

3. Browse… 클릭하여 생성해 놓은 파일을 선택한다.

4. 파일을 선택했으면 Finish

Eclipse의 설정 백업하기

Eclipse를 사용하면서 오류로 많은 고생을 하게 됩니다.

쉽게 해결이 되면 좋지만, 모든 일이 쉽게 해결되지 않을 때가 많습니다.

간혹 정상적인데 계속해서 오류를 분출할 때가 있습니다.

그렇게 해결방법을 알 수 없는 오류를 해결하기 위해 workspace를 새로만드는 것이 가장 좋은 방법일 수도 있습니다.

이때 간단한 개발환경이라면 새로 구성하면 되지만 그렇지 않다면 Eclipse의 설정파일 내보내기를 통해 백업한 뒤 다시 가져오면 기존과 같은 환경을 구성할 수 있습니다.

이렇게 하면 워크스페이스를 새로 구성한 것이기 때문에 완전하게 clean이 됩니다.

** 설정파일 내보내기 방법

1. File -> Export 클릭

2. Preferences 선택 후 Next> 클릭

3. Browse… 클릭

4. 저장할 위치와 파일명을 지정한 후 Finish를 클릭한다.

2017년 3월 10일 금요일

java] 2차원 배열을 출력하고 전체합과 평균 구하기.

// 5,5,5,5,5
// 10,10,10,10,10
// 20,20,20,20,20
// 30,30,30,30,30
// 총합, 평균

해당 모습과 같은 모양으로 출력을 하고 전체의 합과 평균을 구하기

int[][] num = {
{5,5,5,5,5},
{10,10,10,10,10},
{20,20,20,20,20},
{30,30,30,30,30}
};
int sum=0;
int j;
int count=1;

for(int i = 0; i < num.length; i++){

for (j = 0; j < num[i].length; j++){
count++;
sum += num[i][j];
System.out.print(num[i][j]);
}
System.out.println();

}
System.out.println("전체 합은 : " + sum);
System.out.println("평균은 : "+ (double)sum/count);

출력 결과

55555
1010101010
2020202020
3030303030
전체 합은 : 325
평균은 : 15.476190476190476

//먼저 2차원 배열을 만들어 값을 저장한다.

//전체 합을 구할 변수를 만든다.

//세로를 표현할 반복문 만든다.

//가로를 표현할 반복문 만든다.

//각각 출력을 하고, 5회 뒤 줄바꿈을 한다.

//편균은 소수점이 나올 수 있으므로 double형으로 형변환 해준다.

java]2차원 배열의 길이

int[][] arr = {
{5,5,5,5},
{10,10,10},
{40,40,40,40},
{2,2}
};
System.out.println("arr[3]의 길이는 : "+arr[3].length);

//10 20 30 40 50

int[] num = {10,20,30,40,50};
int sum = 0;
for(int i = 0; i<num.length; i++){
sum+=num[i];
System.out.println(+num[i]+" + sum ="+sum);
}

출력결과

arr[3]의 길이는 : 2
10 + sum =10
20 + sum =30
30 + sum =60
40 + sum =100
50 + sum =150

*Point

arr는 2차원 배열이다.

arr[][]와 같이 2차원을 표현 할 수 있지만, 앞에만 적은 arr[3]은 행을 나타내는 결과가 나온다.

배열은 0부터 시작하므로 3은 실직적으로 4번째를 나타내므로 4번째 행의 갯수인 2가 출력된다.

java] 각 배열의 수를 합산하여 출력하기

int[] Java = {85,90,75,80,100};
int[] Jsp = {60,95,80,70,65};
int[] Web = {70,80,100,95,80};
int sum, i;

for (i=0, sum=0; i<Java.length; i++){
sum += Java[i];
}

System.out.println("Java 과목의 합 :"+ sum);

for (i=0, sum=0; i<Jsp.length; i++){
sum += Jsp[i];
}

System.out.println("Jsp 과목의 합 :"+ sum);

for (i=0, sum = 0; i<Web.length; i++){
sum += Web[i];
}

System.out.println("Web 과목의 합 :"+ sum);

java]과목별 학생별 총점을 출력해보자.

int[][] score1={

{85,60,70},

{90,95,80},

{75,80,100},

{80,70,95},

{100,65,80}

};

int[] subject=new int[3]; //과목별 총점을 저장할 변수

int[] student=new int[5]; //학생별 총점을 저장할 변수

int r, c; // row(행), col(열)

System.out.println("과목별 총점 구하기");

for (c=0; c<3; c++){

for (r=0; r<5; r++){

subject[c] += score1[r][c];

}

System.out.println((c+1)+"번 과목의 총합" + subject[c]);

}

for (r=0; r<5; r++){

for (c=0; c<3; c++){

student[r] += score1[r][c];

}

System.out.println((r+1)+"번 학생의 총합 " + student[r]);

}

a,b,c : 과목

1,2,3,4,5 : 학생 이라 가정.

a b c

1 ㅁㅁㅁ

2 ㅁㅁㅁ

3 ㅁㅁㅁ

4 ㅁㅁㅁ

5 ㅁㅁㅁ

2017년 3월 6일 월요일

jsp] application객체 메소드

[web.xml]

<context-param>

<param-name>adminEmail</param-name>

<param-value>admin@naver.com</param-value>
</context-param>

[페이지1]

<body>
<h1>여기는 applicationTest1.jsp입니다.</h1>
<%
application.setAttribute("applicationVal", "이것은 어플리케이션변수 값을 저장한 내용입니다.");
%>
</body>

[페이지2]

<body>
<h1>여기는 applicationTest2.jsp입니다.</h1>
<%= application.getAttribute("applicationVal") %>
<p>
<%--모든 사용자가 사용하는 공통적인 데이터를 web.xml에 저장한 context-param객체의 "adminEmail)변수값 꺼내쓰기 --%>
<%=application.getInitParameter("adminEmail") %>
</body>

어플리케이션 영역 결론 :
- 웹어플리케이션이 시작될때 생성되어 웹어플리케이션이 종료될때까지 어플리케이션 영역의 데이터가 유지됨.
- 이 보관소에 데이터를 보관하면 웹어플리케이션이 실행하는 동안에 모든 서블릿이나 jsp페이지에서 사용할 수 있다.
- 하나의 웹어플리케이션을 모든 사용자가 사용하기 위한 방문자 숫자를 나타낼때..
어플리케이션 객체에 공통적인 값을 저장한다.

jsp]session

jsp를 실행하면 session영역이 요청이 됨.

session영역에 값을 저장한 후 다른 페이지에서 출력되는지 확인.

페이지 1

<body>
<%
/*session객체 메모리 영역 내부에 sessionVal변수을 선언하여 문자열을 저장한다는 뜻 */
session.setAttribute("sessionVal", "이것은 세션변수에 문자열값을 저장한 내용입니다.");
%>
</body>

페이지 2

<body>
/*세션의 값을 불러옴*/
<%= session.getAttribute("sessionVal") %>
</body>

결론 : 클라이언트 요청시 자동으로 생성되는 jsp페이지에서의 session영역은 또다시 다른 jsp페이지를 요청시..
같은 웹브라우저가 닫히기 전까지는 세션영역의 값이 계속 유지 된다.

java]2차원 배열에 저장된 수를 표모양으로 출력하기

// int 2차원 배열 arr을 5*3으로 생성한 후 각 배열에 수를 저장하고 다음과 같은 모양으로 출력을 해보자.

10 90 70
60 80 65
55 60 85
90 75 95
60 30 80

*****

int[][] arr = new int[5][3];

arr[0][0] = 10;
arr[0][1] = 90;
arr[0][2] = 70;
arr[1][0] = 60;
arr[1][1] = 80;
arr[1][2] = 65;
arr[2][0] = 55;
arr[2][1] = 60;
arr[2][2] = 85;
arr[3][0] = 90;
arr[3][1] = 75;
arr[3][2] = 95;
arr[4][0] = 60;
arr[4][1] = 30;
arr[4][2] = 80;

for(int row = 0; row < 5; row++){

for (int col=0; col<3; col++){

System.out.print(arr[row][col]+" ");
}

System.out.println();
}

해설 :

첫 for문으로 행을 나타내고, 두번째 for문으로 열의 출력을 표현

위와 같이 초기화가 가능하고, 아래와 같이도 가능하다.

int[][] arr={{10, 90, 70},{60, 80, 65},{55, 60, 85},{90, 75, 95},{60, 30, 80}};

int[][] arr={

{10, 90, 70},

{60, 80, 65},

{55, 60, 85},

{90, 75, 95},

{60, 30, 80}

};

java] 2차원 배열

1차원 배열은 한줄로 되는 것을 말한다고 하면

2차원 배열은 표와 같은 형태라 보면 된다.

위의 것을 표현하면

int[][] arr= new int [3][5]; 가 되며

세로로 3칸

가로로 5칸 이라는 말이다.

배열 선언시 []의 위치는

int[][] arr = new int [3][5];

int arr[][] = new int [3][5];

int[] arr[] = new int [3][5];

의 모습으로도 가능하다.

그러나 헷갈리니 첫번째 모습으로 선언하자.

초기화는

int[][] arr = {{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5}};

int[][] arr = {

{1,2,3,4,5},

{1,2,3,4,5}

};

위 두가지는 다른 모습이나 보기 좋게 줄바꿈을 했다는 것을 제외하고는 같은 모습이다.
그리고 아래와 같이 개별적으로도 초기화가 가능하다.

arr[0][3]=12;
arr[1][1]=100;
arr[2][3]=3;

출력할 때는

System.out.println("arr[0][3] = "+arr[0][3]);
System.out.println("arr[1][1] = "+arr[1][2]);
System.out.println("arr[2][3] = "+arr[2][3]);

위와 같이 할 수 있다.

2017년 3월 2일 목요일

java] 배열안의 값 중 큰수 구하기

문제 :

double 형 배열에 "9.5,7.0,13.6,7.5,10.0"를 저장 후
저장된 수 중에서 가장 큰 수를 구하여 출력하기.

double[] doNum = {9.5,7.0,13.6,7.5,10.0};
double max = 0;

for (int i=0; i < doNum.length; i++){
if (max <= doNum[i]){
max = doNum[i];
}
}
System.out.println(max);

double 형으로 값을 저장할 변수(배열)와
큰 수를 저장할 double 형 변수를 만든 후
저장한 수와 배열의 수를 차례로 비교하고
비교하는 배열의 수가 크면 저장한 수를 변경하고
작으면 변경하지 않는다.

point
**저장할 변수도 double로 해주어야 정상적으로 저장이 된다.
**max에 저장된 변수와 doNum의 변수를 비교하여 max에 저장한다.

-*-*-*-

max = doNum[0]; //기준을 doNum[0]을 기준으로 잡음
for (int i=0; i<5; i++){ // 기준과 같은 0부터 시작할 경우 오류가 생길 수가 있음. 1부터 하는 것이 좋다.
if(doNum[i]>max){
max=doNum[i];
}
}

java]회문수 구하기...

회문수란....?

대칭수 또는 회문수라 부르며,
순서대로 읽은 수와 거꾸로 읽은 수가 일치하는 수를 말한다.
예를 들어 123321은 회문수이고, 123421은 회문수가 아니다.

int val = 1233321;
int tmp = val;

int re = 0; // 뒤집어서 저장
int num1 = 0, num2=0;

while(tmp != 0){
System.out.println("num1 = re * 10 : "+ num1);
System.out.println("num2 = tmp % 10 : "+ num2);
System.out.println("re = num1+num2 : " + re);
System.out.println("tmp /= 10 : " + tmp);

System.out.println();
num1 = re * 10; //re의 자리수를 올려서 num1에 저장
num2 = tmp % 10; //tmp/10 의 나머지를 저장... 뒤에서부터 하나씩 빼서 저장됨

re = num1+num2; //re의 자리수 올린 수인 num1에 뒤에서 뺀 수를 더한 후 저장

tmp /= 10; // 끝수를 num2에 저장했으므로 끝수 지우고 재저장
}

if (val == re){
System.out.println(val+"은 회문수입니다.");
}else{
System.out.println(val+"은 회문수가 아닙니다.");
}

*-*-*-

처음
num1 = re * 10 : 0
num2 = tmp % 10 : 0
re = num1+num2 : 0
tmp /= 10 : 1233321

1회전 후
num1 = re * 10 : 0
num2 = tmp % 10 : 1
re = num1+num2 : 1
tmp /= 10 : 123332

2회전 후
num1 = re * 10 : 10
num2 = tmp % 10 : 2
re = num1+num2 : 12
tmp /= 10 : 12333

3회전 후
num1 = re * 10 : 120
num2 = tmp % 10 : 3
re = num1+num2 : 123
tmp /= 10 : 1233

4회전 후
num1 = re * 10 : 1230
num2 = tmp % 10 : 3
re = num1+num2 : 1233
tmp /= 10 : 123

5회전 후
num1 = re * 10 : 12330
num2 = tmp % 10 : 3
re = num1+num2 : 12333
tmp /= 10 : 12

6회전 후
num1 = re * 10 : 123330
num2 = tmp % 10 : 2
re = num1+num2 : 123332
tmp /= 10 : 1

1233321은 회문수입니다.

이해하기 난해한 문제이다. 여러번 보자...

java] 배열

배열이란 같은 이름의 변수에 여러칸을 만든다고 생각하면 된다.
다음은 기본적인 형태이다.

int[] number = {1,2};

위의 경우
number라는 이름의 변수에 1번칸에 1, 2번칸에 2를 저장한다는 말
사용할 때는
number[0]
number[1]
의 형태로 1번 2번을 불러올 수 있다.

int[] number1 = new int[5];

위의 경우
number1라는 이름의 변수에 new 연산자를 이용하여, 총 5칸을 만든다는 말이다.
즉,
number1[0]
number1[1]
number1[2]
number1[3]
number1[4]
로 불러 올 수 있으며
기본적으로 int형으로 선언할 경우
기본값이 0으로 초기화가 되어 있다.

int[] arr = new int[5];

arr[0]=10;
arr[1]=1;
arr[2]=4;
arr[3]=33;
arr[4]=11111;

위의 내용과 같이
총 5개의 arr배열을 만들고,
각 배열에 값을 초기화를 해주는 부분이다.

System.out.println("arr[0] : " + arr[0]);
System.out.println("arr[1] : " + arr[1]);
System.out.println("arr[2] : " + arr[2]);
System.out.println("arr[3] : " + arr[3]);
System.out.println("arr[4] : " + arr[4]);

위와 같이 출력이 가능하다.

출력결과
arr[0] : 10
arr[1] : 1
arr[2] : 4
arr[3] : 33
arr[4] : 11111

그리고 반복문으로도 출력이 가능하다.

for (int i=0; i<arr.length; i++){
System.out.println("arr["+i+"] : " + arr[i]);
}

출력결과 동일

int[] arr={1,2,3,4,5};

위와 같이 처음부터 5개의 값을 초기화할 수 있다.

예제문제)

score 배열에 70, 80, 90, 60, 100 을 넣고 총 합과 평균을 구하시오.

int[] score = {70, 80, 90, 60, 100};
int sum=0;

for (int i = 0; i<5; i++){
sum+=score[i];
}

System.out.println("총 합은 : " + sum);
System.out.println("평균은 : " + sum/5);

출력결과
총 합은 : 400
평균은 : 80

java] scanner 를 이용하여 숫자 맞추기

//random

int value = (int)(Math.random()*6)+1;

System.out.println("random 값 : " + value);

// 0.0 *6 <= math.random()*6 < 1.0 *6
// 0.0 <= math.random()*6 < 6.0
// (int) 0.0 <= (int)math.random()*6 < (int)6.0
// 0+1 <= (int)(math.random()*6)+1 < 6+1
// 1 <= (int)(math.random()*6)+1 < 7
// 1 2 3 4 5 6

Math.random() 은 기본으로 0.00000~0.99999까지 출력
Math.random() 뒤에 *숫자를 넣으면 숫자만큼 정수 값이 추가된다.
가령 *6을 하면 총 6개의 숫자를 출력 0.00000~5.99999까지 출력됨.
앞에 int를 명시하면 뒤의 소수점은 버림되어짐.
(int)Math.random()*6 을 하면 결과는 0....
(int)(Math.random()*6) 을 하면 결과는 0~5까지 출력됨.(적용범위의 문제)
(int)(math.random()*6)+1를 하면 1~6 사이의 숫자가 랜덤으로 출력됨.

// 스케너를 이용하여 computer가 뽑은 랜덤 숫자를 맞추기

//1~100까지 랜덤 숫자를 computer가 뽑는다.
//그것을 scanner를 이용하여 숫자를 입력 받는다.
//입력 받은 숫자가 랜덤으로 뽑은 숫자와 비교하여 정답 유무를 판단한다.
//입력 받은 숫자가 크면 크다고 출력
//입력 받은 숫자가 작으면 작다고 출력
//정답을 입력하면 정답과 도전한 횟수를 출력한다.

int random1 = (int)(Math.random()*100)+1;
Scanner s = new Scanner(System.in);
System.out.println("computer : "+ random1);
int count;

for(count=1; ; count++){
System.out.print("computer의 숫자를 맞추시오 : ");
int input = s.nextInt();
if(random1 != input){
if(random1 > input){
System.out.println("입력한 수보다 작습니다.");
}else if(random1 < input){
System.out.println("입력한 수보다 큽니다.");
}
}else{
System.out.println("정답은"+random1+"입니다. 당신은 "+count+"번째에 맞추셨습니다.");
break;
}
}

*-*-*- 위의 내용에서 break문 제거

int random1 = (int)(Math.random()*100)+1;
Scanner s = new Scanner(System.in);
System.out.println("computer : "+ random1);
int count;
int input=0;

for(count=1; random1!=input ; count++){
System.out.print("computer의 숫자를 맞추시오 : ");
input = s.nextInt();
if(random1 != input){
if(random1 > input){
System.out.println("입력한 수보다 작습니다.");
}else if(random1 < input){
System.out.println("입력한 수보다 큽니다.");
}
}
}

System.out.println("정답은"+random1+"입니다. 당신은 "+count+"번째에 맞추셨습니다.");

*-*-*- do while문으로...

int answer = (int)(Math.random() *100)+1;
Scanner s = new Scanner(System.in);
int count = 0;
int input;

do{
count++;
System.out.println("1~100 사이의 값을 입력하세요:");
input = s.nextInt(); // 값 입력
if(answer > input){
System.out.println(" 입력한 수보다 큽니다. ");
} else if (answer < input){
System.out.println(" 입력한 수보다 작습니다.");
} else {
System.out.println("정답입니다!!!");
System.out.println("도전 횟수는 :" + count);
break;
}
} while (true);

java] 문자열 12345의 개별합을 구하시오.

// "12345" -> 1+2+3+4+5 => 15
// charAt() 아스키코드
// 변수.length() 반복문의 길이

String num = "12345";
char chh = ' ';
int sum00 = 0;
System.out.println("num의 갯수는 :"+num.length());
for (int ii=0; ii < num.length(); ii++){
chh = num.charAt(ii);
// sum00 += chh - 48;
sum00 += chh - '0';
System.out.println(sum00);

}
System.out.println("\"12345\"의 개별 합은?" + sum00);

**************************

int number = 12345;
int sum2 =0;
// 1+2+3+4+5 = ?
// 12345 5
// 1234 4
// 123 3
// 12 2
// 1 1

while(number>0){
sum2 += number%10;
number /=10;
// 12345 / 10 => 1234.5 >> 1234
// 1234 / 10 => 123.4 >> 123
// 123 / 10 => 12.3 >> 12
// 12 / 10 => 1.2 >> 1
}
System.out.println("12345의 개별 합은?" + sum2);

java] 함수

String s = new String("Hello Java");

int size = s.length(); // 문자열 길이 구하기
System.out.println("문자열 갯수 : " + size);

char c = s.charAt(6); // s객체의 문자열 중의 6번째 인덱스 값 반환
System.out.println("3번째 문자 : " + c);

int cmp = s.compareTo("Hello Java"); //문자열 비교
System.out.println("문자열 비교 :" + cmp);

String conS = s.concat("!!!"); //기본 문자열의 다른 문자열을 추가
System.out.println("추가문자열 : " + conS);

String subs = s.substring(3, 5); //문자열에서 부분만 출력 (3~5번째)
System.out.println("부분 문자열 : " + subs);

String subs1 = s.substring(3); //문자열에서 부분만 출력 (3번째 이후 쭉)
System.out.println("부분 문자열 : " + subs1);

String toup = s.toUpperCase();
System.out.println("소문자에서 대문자로 변경 : " + toup);

String tolow = toup.toLowerCase();
System.out.println("대문자에서 소문자로 변경 : " + tolow);

출력결과

문자열 갯수 : 10
3번째 문자 : J
문자열 비교 :0
추가문자열 : Hello Java!!!
부분 문자열 : lo
부분 문자열 : lo Java
소문자에서 대문자로 변경 : HELLO JAVA
대문자에서 소문자로 변경 : hello java

java]피보나치 수열

//

피보나치 수열
// 1,1,2,3,5,8,13,...
// 1항-1 2항 -1 (고정)
// 3항 = 1항+2항 4항 = 2항+3항 ...
// 2 1 1 3 1 2
// 5항 = 3항+4항 6항 = 4항+5항
// 5 2 3 8 3 5
// 7항 = 5항+6항 8항 = 6항+7항
// 13 5 8 21 8 13
// 9항 = 7항+8항 10항 = 8항+9항
// 34 13 21 55 21 34
// 1,1,2,....
// 10번째 수는 얼마인지 찾아보기

int num1 = 1;
int num2 = 1;
int num3 = 0;
int sum = 2;
System.out.println("1번 1");
System.out.println("2번 1");
for (int i1 = 3; i1 <= 10; i1++){
num3 = num1 + num2;
num1 = num2;
num2 = num3;
sum += num3;
System.out.println(i1+"번 "+ num3);
}
System.out.println(sum);

출력결과
피보나치 수열
1번 1
2번 1
3번 2
4번 3
5번 5
6번 8
7번 13
8번 21
9번 34
10번 55
143

1번째와 2번째는 1, 1로 초기값을 넣어주고, 합산에 2를 넣음으로써 1번째와 2번째까지 계산했다고 가정하에 3번부터 진행되도록 한다.

2017년 2월 28일 화요일

java]문자열이 숫자인지 아닌지 판별

String value="1203a4";
char ch=' ';
boolean isNumber=true; // 숫자판별 변수 숫자 - true 숫자 아닌 - false

//반복문
//방에 있는 값 데려오기
//그 값 숫자인지 아닌지
//숫자 - 패스
//!숫자 - isNumber false

int i;
for(i=0; i <= value.length(); i++){ //value의 길이만큼 반복
ch=value.charAt(i); //value의 i번째 글자를 빼옴
if(!('0' <= ch && ch <= '9')){ //숫자가 아닐 때 '0'~'9' 사이가 아닐때.
isNumber=false;
break;
}

}
System.out.print((i+1)+"번 문자는 ");

if(isNumber){
System.out.println(value+"는 숫자입니다.");
}else{
System.out.println(value+"는 숫자가 아닙니다.");
}

'0', '9'은 문자 0과 9를 말한다.

java]1+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+...+10)

1+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+...+10)

위의 값을 계산하여라.

for(int num1=1, num2 = 0, sum=0; num1 <= 10; num1++){
System.out.print(num2+"+"+num1+"=");
num2 = num1+num2
System.out.print(num2+" \t");
System.out.print(sum+"+"+num2+"=");
sum = sum+num2;
System.out.println(sum);
// System.out.println(sum + "+"+ num2+ "=" + sum);
}

출력결과

0+1=1 0+1=1
1+2=3 1+3=4
3+3=6 4+6=10
6+4=10 10+10=20
10+5=15 20+15=35
15+6=21 35+21=56
21+7=28 56+28=84
28+8=36 84+36=120
36+9=45 120+45=165
45+10=55 165+55=220

해설 :
앞 줄은 숨겨진 계산 과정
뒷 줄은 문제의 계산 과정.

앞줄은 각각 더해지는 값을 계산하게되고
뒷줄은 계산된 값들의 총 합을 나타낸다.

2017년 2월 27일 월요일

java] 구구단 만들기2

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

위와 같이 구구단을 출력해보자.

for (int l = 1; l <=9; l++){
while(l==1){
for(int dan=2; dan<=9; dan++){
System.out.print(dan+"단\t");
}
System.out.println();
break;
}
for (int k = 2; k<=9; k++){
System.out.print(k+"+"+l+"="+k*l+"\t");
}
System.out.println();
}

java]2x+4y=10 만족하는 x, y(정수)를 구하시오

2x+4y=10 만족하는 x, y(정수)를 구하시오
x = 0~10 , y = 0~10

for (int x=0; x<=10; x++){
for (int y=0; y<=10; y++){
if(((2*x)+(4*y))==10){
System.out.println("x = "+x+", y = "+y);
}

}
}

출력결과

x = 1, y = 2
x = 3, y = 1
x = 5, y = 0

수학을 풀 필요가 없고, 그저 조건식만 만들어주면 해당하는 값을 자동으로 구해준다..

java] (1,5)(2,4)(3,3)(4,2)(5,1) 출력하기

반복문을 사용하여
(1,5)(2,4)(3,3)(4,2)(5,1)
와 같이 두 수의 합이 6이 되도록 출력을 해보자.

구조를 보면 앞의 수는 1부터 올라가고 뒤의 수는 5부터 내려감을 알 수 있다.

int count=0;
for (int a = 1; a<=6; a++){
for (int b=6; b>=1; b--){
if(a+b==6){
count+=1;
System.out.println(a+"+"+b+"="+(a+b));
}
}
}
System.out.println("만족하는 결과의 수는 "+count+"입니다.\n");

출력결과
1+5=6
2+4=6
3+3=6
4+2=6
5+1=6
만족하는 결과의 수는 5입니다.

저기서는 내부 for문의 초기값을 6으로 주었으나
for문들의 초기값들은 크게 상관이 없다.
if문에서 a+b가 6인지 아닌지 판별을 하게 되기 때문이다.

java]for문을 while 문으로 변경

for(int i = 0; i<=10; i++){
for (int j=0; j<=i; j++){
System.out.print("*"); }
System.out.println(i);
}

위의 내용을 while문으로 변경해보자.

int i = 0;
while (i<=10) {
int j=0;
while (j<=i) {
System.out.print("*");
j++;
}
System.out.println(i);
i++;
}

java]1+(-2)+3+(-4)+5+...+... 총합이 100이상일 때 num 값 구해보시오.

int num;
int sum=0;
for(num=1; sum<100; num++){
if(num%2==0){
sum+=(-num);
}else{
sum+=num;
}
}

System.out.println("for 1개 if..else 1개 사용");
System.out.println("1+(-2)+3+(-4)+5+...+ 의 총 합이 100이상일 때 해당하는 숫자는?");
System.out.println("총합 '" + sum + "' 일 때 해당하는 수는 '" + num+ "'");

출력결과
for 1개 if..else 1개 사용
1+(-2)+3+(-4)+5+...+ 의 총 합이 100이상일 때 해당하는 숫자는?
총합 '100' 일 때 해당하는 수는 '200'

exit_for:
for(sum = 0, num=1; ; num++){
if(sum>=100)
break exit_for;
if(num%2==0){
sum+=(-num);
}else{
sum+=num;
}
}
System.out.println("for / if / break 사용,");
System.out.println("1+(-2)+3+(-4)+5+...+ 의 총 합이 100이상일 때 해당하는 숫자는?");
System.out.println("총합 '" + sum + "' 일 때 해당하는 수는 '" + num+ "'");

출력결과
for / if / break 사용,
1+(-2)+3+(-4)+5+...+ 의 총 합이 100이상일 때 해당하는 숫자는?
총합 '100' 일 때 해당하는 수는 '200'

for(int i=1; true; i++, s=-s){ // 1 -1 1 -1 1 -1
num=s*i; //부호결정
sum += num;
if(sum>=100){
break;
}
}

for(int i = 1; sum<100; i++, s=-s){
num=s*i; //부호변경
sum += num; //값저장
}

출력결과
sum : 100
num : 199

어떻게 푸냐에 따라 결과값이 달라질 수 있다.

java]반복문의 제어 break/continue

exit_for:
for(int b=1; b<10; b++){
for(int k=1; k<=10; k++){
if (k%3 ==0)
break exit_for;
System.out.print("k -> " + k);
}
System.out.println("\n a ->"+b);
}

break exit_for;를 통해 맨 위에 있는 exit_for: 로 이동된다.

출력결과
k -> 1k -> 2

b 1회 반복 들어가고 이내 k반복 들어가나 2회 반복 후 break를 만나 끝나버린다.
그러나 break만 적었을 경우 k반복문만 끝날 것이나, exit_for를 적어줌으로 하여
exit_for: 위치로 넘어가 버리고 종료되어 버린다.

for(int j=1; j<=10; j++){
if(j%3==0){//3의 배수일때
continue;
}
System.out.print(j+ " "); }

출력결과
1 2 4 5 7 8 10

continue는 break와는 달리 남아있는 실행을 넘기고 반복의 처음으로 되돌린다.
위의 내용은 3일경우 continue를 실행하므로 3일 때 맨 처음으로 되돌아가게 되어 아래의 print문을 처리하지 않게 된다.
따라서 3, 6, 9의 결과가 출력되지 않았다.

java]for문으로 구구단 출력하자

// 구구단 2~9단
// **2단**
//2 * 1 = 2
//...
//2 * 9 = 18
// **3단**

위와 같은 형태로 출력해보자.

for(int d=2; d<=9; d++){
System.out.println(" **"+d+"**");
for(int num1=1; num1<=9; num1++){
System.out.println(d+" * "+ num1 + " = "+ d*num1);
}
}

java]이중for문으로 *출력하기

// *
// **
// ***
// ****
// *****

for(int i=1; i<=5; i++){
for(int j=1; j<=i; j++){
System.out.print("*");
}
System.out.println();
}

java]이중for문

//이중 for문

// for(초기식;조건식;증감식){
// for(초기식;조건식;증감식){
// 반복할 문장(안)
// }
// 반복할 문장(밖)
// }

for문 안에 for문이 있는 것으로 외부1회 회전에 내부 for반복이 일어난다.
만약 각각 5회씩 반복되도록 하였다면
외부for문은 5회
내부for문은 25회 반복될 것이다.

예)
for(int i=1; i<=5; i++){
System.out.println("i -> " +i);

for(int j=1; j<=5; j++){
System.out.println("j -> "+j);
}
System.out.println("-------------");
}

출력결과
i -> 1
j -> 1
j -> 2
j -> 3
j -> 4
j -> 5
-------------
i -> 2
j -> 1
j -> 2
j -> 3
j -> 4
j -> 5
-------------
i -> 3
j -> 1
j -> 2
j -> 3
j -> 4
j -> 5
-------------
i -> 4
j -> 1
j -> 2
j -> 3
j -> 4
j -> 5
-------------
i -> 5
j -> 1
j -> 2
j -> 3
j -> 4
j -> 5
-------------

예2)

int i;
int a;

System.out.println("시침 ---------- 분침");
System.out.println("a(밖)----------i(안)");

for(a=1; a<5; a++){
for(i=1; i<=5; i++){
System.out.println(a+"----------"+i);
}
}

출력결과

시침 ---------- 분침
a(밖)----------i(안)
1----------1
1----------2
1----------3
1----------4
1----------5
2----------1
2----------2
2----------3
2----------4
2----------5
3----------1
3----------2
3----------3
3----------4
3----------5
4----------1
4----------2
4----------3
4----------4
4----------5

java]1~20 중 2의 배수/3의 배수 아닌 수/ 2와 3의 배수 아닌 수 합산들

total=0;
for(int i=1; i<=20; i++){
// if(i%2==0){
// total += i;
// System.out.println("2의 배수 :"+i);
// }
// if(i%3!=0){
// total += i;
// System.out.println("3의 배수가 아닌 수 : "+i);
// }

//2의 배수가 아닐 때 3의 배수가 아닐 때
if(i%2!=0 && i%3!=0){
total += i;
}
}
// System.out.println("1~20까지 2의 배수만 합산 : "+ total);
// System.out.println("1~20까지 3의 배수가 아닌 수 합산 : "+ total);
System.out.println("1~20까지 2와 3의 배수가 아닌 수 합산 : "+ total);

각각의 주석처리를 바꿔가면서 실행하면 된다..

i%2==0은 2로 나눴을 때 몫이 0인 것 (2의 배수)
i%3!=0은 3으로 나눴을 때 몫이 0이 아닌 것(3의 배수가 아닌 수)
i%2!=0 && i%3!=0은 2로 나눴을 때 몫이 0이 아니고 3으로 나눴을 때 0이 아닌 것(2의 배수도 아니고 3의 배수도 아닌 수)

java]반복문의 제어

int total=0;
for(int i=0; i<=10; i++){
// 짝수의 합
if(i%2==0 && i>0){
total += i;
System.out.println("짝수 : "+i);
// break; // 반복문 밖으로 빠져나간다.
}
}
System.out.println("짝수의 합은 : "+total);

break를 사용하고 안하고의 차이...

위의 주석처리된 break를 주석해제한다면
위의 결과내용은 2를 출력하고 반복을 끝내게 된다.

주석해제시 결과
짝수 : 2
짝수의 합은 : 2

주석 처리를 하게 되면

짝수 : 2
짝수 : 4
짝수 : 6
짝수 : 8
짝수 : 10
짝수의 합은 : 30

위와 같이 나온다.

java]무한루프

for(;true;){
System.out.println("안녕하세요!");
}

위와 같이 할 경우 무한으로 반복하는 것을 의미한다.
끝없이 출력될 것이다...

int i=1;
while(true){
if(i>5){
System.out.println("반갑습니다!");
break;
}
i++;
}

또다른 예로 위와 같은 경우가 있다.
위의 내용은 무한 반복 중에 i가 5보다 클 경우 반갑습니다!를 출력한 후 break로 빠져나가는 내용이다.

break를 사용시 제일 최근 반복문을 빠져나간다.

2017년 2월 26일 일요일

java]do while문

// do while

// do {
// 반복할 내용
// } while (조건문);

예)
일반적인 while문

i=0;
while(i++<=4){
System.out.println(i+" ");
}

동일한 내용의 do while문

i=1;
do{
System.out.println(i+" ");
}while(i++<=4);

두 내용의 차이는
초기값을 먼저 밖에서 하는 것은 같으나
while문의 경우 조건을 먼저 확인 후 반복을 하는 것이고,
do while문은 먼저 1회 진행 후 조건문을 확인한다는 것이 다르다.

// do while문 1~10
System.out.println("do while문으로 1~10 출력");
i=1;
do{
System.out.print(i+" "); }while(i++<10);

마지막에 조건을 확인하므로, 아래의 조건문 i++<10 을 유의해야 한다.

i++<=10 를 하게 되면 10일때 1회 더 반복하므로 11까지 출력되게 된다.

java]전위 연산자 후위 연산자

System.out.print("while문 전위 연산자 : ");
i=1;
while(++i<=5){
// ++i
System.out.print(i+" ");
}
출력결과 : while문 전위 연산자 : 2 3 4 5

++가 앞에 있으면 전위 연산자이다.
처음 i<=5에 적용될 때 1이 증가한 2부터 적용되고 넘어간다.
마지막에 1이 증가하고 5인 상태로 반복되므로 반복문의 종료는 5로 끝난다.

System.out.print("while문 후위 연산자 : ");
i=1;
while(i++<=5){
// i++
System.out.print(i+" ");
}
출력결과 : while문 후위 연산자 : 2 3 4 5 6

++가 뒤에 있으면 후위 연산자이다.
처음 i<=5에 i를 1을 먼저 적용한 후 1 증가된다.
마지막에 i가 5이므로 반복을 하는데 반복문에서는 6으로 반복이 끝난다.

java]while문 - for문과 다른 점.

// 초기화
// while(조건식){
// 반복할 문장
// 증감식
// }

기본적인 문법은 위와 같다.

for 문과 같이 반복한다는 것은 같지만
for문은 조건식 안에 초기화를 해주고, 조건과 증감을 적어주는 형태라면
while는 초기화는 시작하기 전 while문 밖에서 해주어야 하고
증감식은 내부에 적어주어야 하는 것이 다르다.

//1~4까지 출력
int num=0;
while(num<5){
System.out.println("num " +num);
num++;
}

위와 같이 while문 바깥에서 초기화를 한 후 조건식을 적어주고
내부에 증감식을 사용해 반복되는 형태이다.

total = 0;
i = 1;

while(i<=10){
total+=i;
i++;
}
System.out.println("while문으로 1~10까지 합 만들기 : "+total);

출력결과 : while문으로 1~10까지 합 만들기 : 55

위의 것을 for문으로 만들면 아래와 같다.

int i, total=0;
for(i=1; i<=10; i++){
total+=i;
}
System.out.println("for문으로 1~10까지 합 만들기 : "+total);

java]for문으로 1~10까지 합을 만들자.

int total = 0;
for(int i=1; i<=10; i++){
// 1~10 덧셈
total += i;
}
System.out.println(total);

누적산을 이용하여 위와 같이 간단하게 만들 수 있다.

java]역삼각형태로 출력하기(for 문을 사용)

위와 같은 형태의 모양으로 출력을 해보자.

for 문을 사용하여 위의 모양을 만드는 것이 이번에 할 내용.

1 for(int i=6; i>=2; i--){

2 for(int s=1; s<i; s++){

3 System.out.print("*");

4 }

5 System.out.println();

6 for(int k=6; k>i-1 && i>2; k--){

7 System.out.print(" ");

8 }

9 }

생각에 따라서는 어렵게 느껴질 수도 있는 문제이다.

해당 모습을 만드는 것에는 위의 방법과는 다르게 여러가지가 있을 수 있다.

해설...

1번째 줄

첫번째 for문 6에서 2까지 1씩 감소시키며 총 5회 반복한다.

: 5개의 줄을 만들 것이므로 총 5회 반복하도록 한다.

2번째 줄

내부 1번째 for문 1부터 i보다 작을 때까지 1씩 증가하며 *을 출력한다.

처음 시작시 i가 6이므로 1부터 5까지 총 5회 반복하며 *을 5개 출력한다.

5번째 줄

내부 1번째 for문이 종료되고 줄바꿈을 한다.

6번째 줄

내부 2번째 for문 초기값을 6으로 주고 6을 1씩 감소시키며 i-1만큼 반복한다.

그리고 i가 2보다 클때만 반복한다.

1회전

1. for문 s=1 < i=6, s++ => *이 5개 출력된다.

2. 줄바꿈을 한다.

3. for문 k=6 > i=6-1 & 6>2 k++ =>6부터 i까지 반복 6-1 은 5이므로 " "1회 반복 출력

2회전

1. for문 s=1 < i=5, s++ => *이 4회 출력

2. 줄바꿈

3. for문 k=6 > i=5-1 & 5>2 k++ =>6부터 i까지 반복 5-1은 4이므로 " "2회 반복 출력

3회전

1. for문 s=1 < i=4, s++ => *이 3회 출력

2. 줄바꿈

3. for문 k=6 > i=4-1 & 4>2 k++ =>6부터 i까지 반복 4-1은 3이므로 " "3회 반복 출력

......

5회전

1. for문 s=1 < i=2, s++ => *이 1회 출력

2. 줄바꿈

3. for문 k=6 > i=2-1 & 2>2 k++ => 1번 조건은 충족하나 2번 조건이 불충족이므로 반복하지 않고 끝낸다.

더 쉬운 방법도 있으리라 생각됩니다.^^

프로필

카테고리1

Post List

2017년 7월 2일 일요일

2017년 6월 18일 일요일

2017년 3월 10일 금요일

2017년 3월 6일 월요일

2017년 3월 2일 목요일

2017년 2월 28일 화요일

2017년 2월 27일 월요일

2017년 2월 26일 일요일