C0404규칙찾기, C0405규칙찾기입력, C0405행렬

코딩/2-JAVA

C0404규칙찾기, C0405규칙찾기입력, C0405행렬

tree0505 2025. 6. 23. 10:00

C0404규칙찾기

C0404개념01_배열생성

package C0404규칙찾기;

import java.util.Arrays;

[문제]

arr배열에서 4의 배수만 골라 temp배열에 저장하시오.

단, temp의 길이는 4의 배수의 개수 만큼만 설정하시오.

[정답]

temp = {44, 24, 76}

public class C0404개념01_배열생성 {

public static void main(String[] args) {

//초기화를 한다. 비여있는것

int a = 0; //변수는 0

String b = ""; //문자열

int[] arr1 = null; //배열이면 null

//-----------------------

int[] arr = {44, 11, 29, 24, 76};

int[] temp = null;

//배열이기 때문에 null로 초기화를 한다.

// java.lang.NullPointerException:

// Cannot store to int array because "temp" is null

// temp[0] = 44;

// 1. arr배열에서 4의 배수의 개수를 구하기

// 2. temp를 1번에서 구한 개수만큼 생성하기

// 예) temp = new int[3];

// 3. arr배열에서 4의 배수만 temp배열에 저장하기

int count = 0;

//4의 배수의 갯수를 센다.

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

if(arr[i] % 4 == 0) {

count += 1;

}

System.out.println("4의 배수의 개수 = " + count);

temp = new int[count];

//4의 배수만큼 new를 해준다.

[풀이]

i = 0, index = 0 arr[0] % 4 == 0 true temp = [44, 0, 0]

i = 1, index = 1 arr[1] % 4 == 0 false temp = [44, 0, 0]

i = 2, index = 1 arr[2] % 4 == 0 false temp = [44, 0, 0]

i = 3, index = 1 arr[3] % 4 == 0 true temp = [44, 24, 0]

i = 4, index = 2 arr[4] % 4 == 0 true temp = [44, 24, 76]

int index = 0;

//그럼 4의 배수일때마다. 집어 넣는것

//중요한것. temp[index]은 따로 도는거다.

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

//이 i는 arr 꺼이다.

if(arr[i] % 4 == 0) {

temp[index] = arr[i];

index += 1;

}

System.out.println(Arrays.toString(temp));

}

문제

C0404문제02

package C0404규칙찾기_문제;

import java.util.Arrays;

import java.util.Random;

[문제]

arr배열 안에 1 또는 7만 랜덤으로 저장 후 출력하시오.

[예시]

arr = {7, 1, 7, 7, 1, 1, 1}

public class C0404문제02 {

public static void main(String[] args) {

Random ran = new Random();

int[] arr = new int[7];

//arr이라는 이름의 정수형 배열을 선언하고, 크기 7로 초기화합니다.

//배열의 초기값은 모두 0으로 자동 설정됩니다.

// 실제 내부는 이렇게 초기화되어 있음:

//arr = {0, 0, 0, 0, 0, 0, 0};

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

//i는 배열 인덱스를 나타내며, 0부터 6까지 반복됩니다.

//arr.length는 7이므로, 총 7번 반복됩니다.

int r = ran.nextInt(2);

if(r == 0) {

arr[i] = 7;

}else {

arr[i] = 1;

}

System.out.println(Arrays.toString(arr));

}

C0404문제03
- 반복문이 도는게.
- for (int i = 0 ; i< 3; i++)
  - i는 0번. 즉 배열의 0번방 부터 저장이 된다.
- for ( int i = arr2.length -1; i>0; i--)
  - 배열의 마지막 번호부터 배열이 저장되는것
- ✅ 1. for (int i = 0; i < arr1.length - 1; i++)
  - 👉 i = 0부터 시작해서 점점 커지면서 증가 (i++)
  - 👉 즉, 배열의 앞에서 뒤로 순차적으로 도는 거예요.
  - 👉 이건 0번 방부터 하나씩 차례대로 접근하는 겁니다.
  예:
  i = 0 → 1 → 2 → 3 (마지막 i = 4는 제외됨)
  ✅ 2. for (int i = arr2.length - 1; i > 0; i--)
  - 👉 i = 4부터 시작해서 점점 작아지면서 감소 (i--)
  - 👉 즉, 배열의 뒤에서 앞쪽으로 순서대로 접근합니다.
  - 👉 이건 마지막 방부터 하나씩 거꾸로 접근하는 거예요.
  예:
  i = 4 → 3 → 2 → 1
  (참고: i > 0이기 때문에 i = 0은 실행 안 돼요)

package C0404규칙찾기_문제;

import java.util.Arrays;

[문제1] arr1 배열의 값들을 앞으로 한칸씩 당기고 맨 뒤에 a의 값을 저장한다.

[정답1] arr1 = {20,30,40,50,90}

[문제2] arr2 배열을 뒤로 하나씩 밀어낸 후 맨 앞에 b의 값을 저장한다.

[정답2] arr2 = {60,10,20,30,40}

public class C0404문제03 {

public static void main(String[] args) {

int[] arr1 = { 10,20,30,40,50 };

//→ 이미 있는 배열 arr1의 값들을 수정하는 겁니다.

//새로운 배열을 만드는 게 아니라, 같은 배열 안에서 값을 덮어쓰는 방식이에요

//arr1[i] = arr1[i+1];는 오른쪽 값을 왼쪽에 복사해서 덮어쓰기(overwrite) 하는 거고,

//마지막에 arr1[arr1.length-1] = a;로 마지막 자리에 새로운 값을 넣는 거예요.

int a = 90;

for(int i = 0; i<arr1.length-1; i++) {

// arr1.length-1 => 앞에서부터 반복하면서 마지막 인덱스 전까지만 반복한다는 뜻입니다.

//배열이 저장되는 순서가.

//int i = 0; //=> 0번방 부터 저장.

arr1[i] = arr1[i+1];

}

arr1[arr1.length-1] = a;

System.out.println(Arrays.toString(arr1));

//-------------------------------------------

int[] arr2 = { 10,20,30,40,50 };

int b = 60;

for(int i = arr2.length-1; i>0; i--) {

//반복문을 거꾸로 돌리면.

//배열이 저장되는 순서가. 뒤에서부터 저장이 된다.

//[60, 10, 20, 30, 40] => 저장되는 순서가.

//40부터 저장이 된다.

// 4 , 4 - 1

// 3 , 3 - 1

// 2 , 2 - 1

// 1 , 1 - 1

arr2[i] = arr2[i-1]; // 50 = 40 , 40 = 30

}

arr2[0] = b;

System.out.println(Arrays.toString(arr2));

}

C0404문제05
- b[index] = arr[0]
  - b배열의 0번째 방에 1이 저장이 된것이고.
  - 아직은 index는 0이다.
- 첫번째때.
  - if(b[index] != arr[i] )
    - 아직은 index는 0이기 때문에.
    - b [ 0 ] != arr [ 1 ]
      - int i = 1; 즉 1번부터 돌기 때문에. arr [ 1 ]
      - b [ 0 ] => 값은 1
      - arr [ 1 ] => 값 1
      - 즉 같기 때문에. 인덱스는 늘지 않는다.
      - if 조건이 맞지 않기 때문에.
      - b [ 0 ] 은 그대로 있고. arr [ i ]
        
        arr [ i ] . arr의 방번호만 계속는다.
      - 그래서 겹치지 않게 저장이 되는거다.

package C0404규칙찾기_문제;

import java.util.Arrays;

[문제]

arr배열에 중복되는 숫자는 제외하고 숫자 1개씩만 압축해서

b배열에 저장하시오.

[정답]

b = {1, 3, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0}

public class C0404문제05 {

public static void main(String[] args) {

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

int[] b = new int[arr.length];

int index = 0;

b[index] = arr[0];

//처음에는 무조건 첫 번째 값을 복사 (중복 체크할 기준이 없으니까)

//index는 여전히 0이에요.

//b배열에 0번방에 1을 저장하고. 아직 index는 0이다.

for(int i = 1; i<arr.length; i++) {

System.out.println("i = " + i + ", index = " + index + ", b[" + index + "] != arr[" + i + "] " + (b[index] != arr[i]) + " " + Arrays.toString(b));

if(b[index] != arr[i]) {

//b는 [index]는 계속 고정이고. arr만 바뀐다.

//b와 arr이 계속 같다면. index는 늘지 않으니. arr만 계속 바뀌고.

//b와 arr이 틀려졌을때. 그제야 index가 올라간다.

//그래서 서로 겹치지 않게 저장이 되는거다.

index +=1;

b[index] =arr[i];

}

System.out.println(Arrays.toString(b));

}

C0405규칙찾기입력

C0405념01_삭제

package C0405규칙찾기입력;

import java.util.Arrays;
import java.util.Scanner;

/*
[문제]
a배열 안의 값을 한 개 입력받는다.
b배열 안에 위에서 입력한 값을 제외하고 복사한다.
단, 없는 값 입력 시 예외처리를 하시오.
[예시]
입력 : 30
결과 : b = {10, 20, 40, 50, 0}

입력 : 100
결과 : 값을 잘못 입력했습니다.
*/

public class C0405념01_삭제 {
public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int[] a = { 10, 20, 30, 40, 50 };
//a를 하나 삭제해서.
int[] b = { 0, 0, 0, 0, 0 };
//b에 하나 적게 넣고 싶은것

Systehttp://m.out.print("입력 : ");
int num = scan.nextInt();

int index = -1;
for(int i=0; i<a.length; i++) {
if(a[i] == num) {
index = i;
break;
}
}

/*
[풀이]
num = 30

i = 0, bIndex = 0 a[0] != 30 true b = [10,  0,  0,  0, 0]
i = 1, bIndex = 1 a[1] != 30 true b = [10, 20,  0,  0, 0]
i = 2, bIndex = 2 a[2] != 30 false b = [10, 20,  0,  0, 0]
i = 3, bIndex = 2 a[3] != 30 true b = [10, 20, 40,  0, 0]
i = 4, bIndex = 3 a[4] != 30 true b = [10, 20, 40, 50, 0]
*/

if(index == -1) {
System.out.println("값을 잘못 입력했습니다.");
} else {
int bIndex = 0;
//bIndex를 따로 만들어서 저장을 하는것
for(int i=0; i<a.length; i++) {
if(a[i] != num) { //그 값이 아닐때만 저장함.
b[bIndex] = a[i];
bIndex += 1;
}
}

System.out.println(Arrays.toString(b));
}

scan.close();

}
}

C0405규칙찾기입력_문제

C0405문제02

package C0405규칙찾기입력_문제;

import java.util.Arrays;

import java.util.Scanner;

[문제]

값을 입력받고 data 배열에서 해당 값을 제외한 나머지를

b배열에 순차적으로 저장하시오.

단, 같은 값이 여러개 있으면 가장 첫번째의 값 한개만 삭제후 저장하시오.

[예시]

data = {5,2,6,8,5,6};

입력 : 2

b = {5,6,8,5,6,0}

입력 : 6

b = {5,2,8,5,6,0}

public class C0405문제02 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int[] data = {5,2,6,8,5,6};

int[] b = {0,0,0,0,0,0};

System.out.println("입력 : ");

int value = scan.nextInt();

int index = -1;

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

if(value == data[i]) {

index = i; //방번호를 저장

break;

}

if(index == -1) {

System.out.println("값 입력 오류 ");

}else {

int bIndex = 0;

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

if( i != index) {

//사용자가 6을 입력하면.

//index 2이 저장이 되고.

//첫번째 i는 data의 0번이니까.

//i[0] = 5

//첫번째때 바퀴는. 5 != 2

b[bIndex] = data[i];

bIndex += 1;

}

System.out.println(Arrays.toString(b));

}

scan.close();

}

C0405문제03

package C0405규칙찾기입력_문제;

import java.util.Arrays;

import java.util.Scanner;

[문제]

값을 입력받아 data배열에서 해당 값을 제외하고

배열 b에 저장하시오.

단, 같은 값이 여러개 있으면 전부 제외하시오.

[예시]

입력 : 5

결과 : {2,6,8,6,0,0}

public class C0405문제03 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int[] data = {5,2,6,8,5,6};

int[] b = {0,0,0,0,0,0};

System.out.println("입력 : ");

int input = scan.nextInt();

//사용자로부터 값을 입력받음 → 이 값을 data에서 모두 제거할 것

int index = 0;

//b 배열에 값을 넣기 위한 위치(index)를 나타냄 (이걸 bIndex라고 해도 의미상 더 명확함)

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

if(input != data[i]) {

//사용자가 입력한 값 input 과 data[i]

//사용자가 입력한 값(input)과 data[i]가 다르면,

//data[i] 배열의 값들이 같지 않으면.

//즉, 현재 요소가 제거 대상이 아니라면

//b배열에 저장을 하라.

//즉 사용자가 입력한 값이 같지 않으면 b배열에 저장을 해라.

//b배열에 복사한다.

b[index] = data[i]; // b 배열에 유효한 값을 저장

//data[i]은 자동으로 사용자가 입력하지 않는 값만 남는건가?

//→ 자동으로 남는 게 아니라, 조건에 따라 복사될 때만 저장되는 거예요!

// 조건을 만족한 data[i] 값을 b배열의 index 위치에 저장한다.

// 이 시점에서 data[i]는 input과 다르기 때문에 유효한 값이다.

index += 1;

}

System.out.println(Arrays.toString(b));

}

C0405문제04

package C0405규칙찾기입력_문제;

import java.util.Arrays;

import java.util.Scanner;

[문제]

값을 입력받아 data배열에서 해당 값을 제외하고

배열 b에 저장하시오.

단, 같은 값이 여러개 있으면 마지막의 값 한개만 삭제하시오.

[예시]

입력 : 5

결과 : {5,2,6,8,6,0}

public class C0405문제04 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int[] data = {5,2,6,8,5,6};

int[] b = {0,0,0,0,0,0};

System.out.println("입력 : "); //사용자가 data의 배열의 값을 입력

int input = scan.nextInt();

int index = 0;

//첫번째 반복문

//사용자가 적은 값의 data[i]배열의 방번호를 찾기 위해서.

//사용자가 5의 값을 적으면.

//data배열안에는 5라는 값이 2개가 있다.

//첫번째 5의 방번호인 0번 방번호가 저장이 되는 것이 아니라.

//2번째 5인 4번 방번호가 저장이 된다.

//같은 값이 여러 개 있는 경우, 마지막에 나오는 값의 방번호만 저장됩니다.

//사용자가 입력한 값과 일치하는 data 배열의 인덱스를 찾는다.

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

if(input == data[i]) {

//input => 사용자가 입력한 b배열중 데이터 1개의 값

//data[i] => data[i]안에 있는 데이터 값이 같다면.

index = i;

//i => data[i]

//즉 사용자가 적은 data배열의 값이. data[i]의 방번호와 같으면.

//i 방번호를 저장해라.

}

System.out.println(index);

//---------------------------------------------------

//2번째 반복문

//1번째 반복문에서 방번호를 찾았고.

//그것을 빼고 b배열에 저장하기 위해.

//index에 저장된 방번호(i == index)는 건너뛰고, 나머지 값을 b[bIndex]에 복사합니다.

//결과적으로 마지막에 나온 5만 제외되고 나머지는 다 복사됩니다.\

//첫 번째 반복문에서 찾은 index를 제외한 값을 b 배열에 저장한다.

// 따라서 마지막에 등장한 입력값 하나만 제외된다.

int bIndex = 0;

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

if(i != index) {

//i => data의 방번호

//index는 사용자가 적은 값중. 마지막 값의 방번호.

b[bIndex] = data[i];

bIndex += 1;

}

System.out.println(Arrays.toString(b));

}

C0406문제01

package C0405행렬_문제;

[문제]

b배열을 다음과 같이 삼각형 모양으로 출력하시오.

[정답]

456

7890

public class C0406문제01 {

public static void main(String[] args) {

int[] b = {1,2,3,4,5,6,7,8,9,0};

* r = 0, c = 0

* 0 => r = 0, c = 0

* 1 => r = 1, c = 0

* 2 => r = 1, c = 1

* 3 => r = 2, c = 0

* 4 => r = 2, c = 1

* 5 => r = 2, c = 2

* 6 => r = 3, c = 0

* 1

* 2 3

int row = 0;

int count = 0;

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

/* r = 0, c = 0;

* r = 1 , c = 0 => c + 1

* 1 , r = 1 , c = 0

* 2 3 , r = 2, c = 0

* 4 5 6 , r = 3, c = 0

System.out.print(b[i]); //배열에서 하나의 값만 출력하라

//b[0] = 1 / row = 0 / row = 1 . count = 0

//b[1] = 2 / row = 2 . count = 0;

//b[2] = 3 / row

//??? 카운트가 늘어나는 조건. row가 늘어나는 조건이 언제 만족이 되지?

if(row == count) {

row +=1 ;

//다음 줄로 넘어가기 위해 한 줄에 몇 개를 출력할지 정하는 기준을 늘리는 역할

count = 0;

System.out.println();

}else {

// row += 1; 이때는 로우가 늘어나지 않는다.

count += 1;

}

C0405념02_삭제

package C0405규칙찾기입력;

import java.util.Arrays;
import java.util.Scanner;

/*
[문제]
아래 c배열은 번호와 값이 한 쌍인 배열이다.
번호를 하나 입력받아 c배열에 있는 번호이면,
그 번호와 값만 제외하고 d배열에 복사한다.
[예시]
입력 : 1002
결과 : d = {1001, 40, 1003, 70 , 0, 0}
*/

public class C0405념02_삭제 {
public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int[] c = { 1001, 40, 1002, 65, 1003, 70 };
int[] d = { 0, 0, 0, 0, 0, 0 };

Systehttp://m.out.print("입력 : ");
int bunho = scan.nextInt(); // 1002

int index = -1;
for(int i=0; i<c.length; i++) {
if(i % 2 == 0 && bunho == c[i]) {
index = i; // 2
break;
}
}

/*
[풀이]
bunho = 1002
index = 2

i = 0, dIndex = 0 i%2==0 && i!=2 true d = [1001, 40, 0, 0, 0, 0]
i = 1, dIndex = 2 i%2==0 && i!=2 false d = [1001, 40, 0, 0, 0, 0]
i = 2, dIndex = 2 i%2==0 && i!=2 false d = [1001, 40, 0, 0, 0, 0]
i = 3, dIndex = 2 i%2==0 && i!=2 false d = [1001, 40, 0, 0, 0, 0]
i = 4, dIndex = 2 i%2==0 && i!=2 true d = [1001, 40, 1003, 70, 0, 0]
i = 5, dIndex = 4 i%2==0 && i!=2 false d = [1001, 40, 1003, 70, 0, 0]
*/

if(index == -1) {
System.out.println("값을 잘못 입력했습니다.");
} else {
int dIndex = 0; //전용 인덱스
for(int i=0; i<c.length; i++) {
if(i % 2 == 0 && i != index) {
d[dIndex] = c[i];
d[dIndex + 1] = c[i + 1];

dIndex += 2;
}
}
System.out.println(Arrays.toString(d));
}

scan.close();

}
}

C0405념03_삽입

package C0405규칙찾기입력;

import java.util.Arrays;
import java.util.Random;

/*
[문제]
(1) 삽입할 위치 (2) 삽입할 값
삽입할 위치를 랜덤(0 ~ 2)으로 저장하고,
삽입할 위치를 기준으로 전부 뒤로 한 칸씩 이동한 후,
삽입할 값을 삽입할 위치에 저장한다.
[예시]
index = 2
arr = {10, 20, 60, 30, 0}

index = 1
arr = {10, 60, 20, 30, 0}
*/

public class C0405념03_삽입 {
public static void main(String[] args) {

Random ran = new Random();

int[] arr = { 10,20,30,0,0 };
int value = 60; // 삽입할 값

int index = ran.nextInt(3);
index = 1;
System.out.println("index = " + index);

/*
[풀이]
index = 1
value = 60
*
arr = [10, 20, 30, 0, 0]

arr[4] = arr[3]
arr[3] = arr[2]
arr[2] = arr[1]

arr[1] = 60
*/
for(int i=arr.length - 1; i>index; i--) {
// System.out.println(i);
arr[i] = arr[i - 1];
}
arr[index] = value;
System.out.println(Arrays.toString(arr));

}
}

C0405행렬

C0406개념01_삼각형

package C0405행렬;

[문제]

b배열을 다음과 같이 삼각형 모양으로 출력하시오.

[정답]

456

7890

public class C0406개념01_삼각형 {

public static void main(String[] args) {

int[] b = {1,2,3,4,5,6,7,8,9,0};

[풀이]

i = 0, row = 0, count = 0 b[0] ↵ row == count true

i = 1, row = 1, count = 0 b[1] row == count false

i = 2, row = 1, count = 1 b[2] ↵ row == count true

i = 3, row = 2, count = 0 b[3] row == count false

i = 4, row = 2, count = 1 b[4] row == count false

i = 5, row = 2, count = 2 b[5] ↵ row == count true

i = 6, row = 3, count = 0 b[6] row == count false

i = 7, row = 3, count = 1 b[7] row == count false

i = 8, row = 3, count = 2 b[8] row == count false

i = 9, row = 3, count = 3 b[9] ↵ row == count true

int row = 0;

int count = 0;

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

System.out.print(b[i]);

if(row == count) {

row += 1;

count = 0;

System.out.println(); //줄바꿈

//늘어나면. 2개면 줄바꿈

} else {

count += 1;

}

C0406개념02_가로세로합

package C0405행렬;

import java.util.Arrays;

아래 배열은 1~9 사이의 숫자가 섞여서 저장되어 있는

길이가 9인 배열이다.

arr 배열을 아래와 같이 사각형 모양으로 출력하고,

[문제1] 각 줄의 가로합을 garo배열에 차례대로 저장하고 출력하시오.

[정답1] garo = {12, 14, 19}

[문제2] 각 줄의 세로합을 sero배열에 차례대로 저장하고 출력하시오.

[정답2] sero = {19, 12, 14}

public class C0406개념02_가로세로합 {

public static void main(String[] args) {

int arr[] = {

2, 4, 6,

8, 1, 5,

9, 7, 3

};

int[] garo = {0,0,0}; // {2+4+6 , 8+1+5 , 9+7+3}

//garo는 한번에 한칸씩 가야한다. 그래서 전용 인덱스를 만든다. garoIndex

int[] sero = {0,0,0}; // {2+8+9 , 4+1+7 , 6+5+3}

garo[0] = arr[0] + arr[1] + arr[2]

garo[1] = arr[3] + arr[4] + arr[5]

garo[2] = arr[6] + arr[7] + arr[8]

// 가로방법1)

int garoIndex = 0;

for(int i=0; i<9; i+=3) {

//한번에 3칸씩 간다.i+=3

// System.out.println(i + ", " + (i + 1) + ", " + (i + 2));

garo[garoIndex] = arr[i] + arr[i + 1] + arr[i + 2];

//arr은 한번에 3칸씩

//garo[garoIndex] => 1칸씩 이동

garoIndex += 1;

}

System.out.println(Arrays.toString(garo));

// 가로방법2)

arr = [

2, 4, 6,

8, 1, 5,

9, 7, 3

]

index = 0, i = 0 garo[0] += 2 garo = [ 2,0,0]

index = 0, i = 1 garo[0] += 4 garo = [ 6,0,0]

index = 0, i = 2 garo[0] += 6 garo = [12,0,0]

index = 1, i = 3 garo[1] += 8 garo = [12, 8,0]

index = 1, i = 4 garo[1] += 1 garo = [12, 9,0]

index = 1, i = 5 garo[1] += 5 garo = [12,14,0]

index = 2, i = 6 garo[2] += 9 garo = [12,14, 9]

index = 2, i = 7 garo[2] += 7 garo = [12,14,16]

index = 2, i = 8 garo[2] += 3 garo = [12,14,19]

i = 9

//가로 2번째 방법

int index = 0;

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

//9번 돌음

garo[index] += arr[i];

//arr[i] => 1칸씩 쭉 간다.

//index => 3번마다 증가시킨다.

if(i % 3 == 2) {

index += 1;

//3번마다 증가시킨다.

}

System.out.println(Arrays.toString(garo));

//--------------------------------------------------

// 세로

i = 0 sero[0 % 3]

i = 1 sero[1 % 3]

i = 2 sero[2 % 3]

i = 3 sero[3 % 3]

i = 4 sero[4 % 3]

i = 5 sero[5 % 3]

i = 6 sero[6 % 3]

i = 7 sero[7 % 3]

i = 8 sero[8 % 3]

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

//i++ => 1칸씩 감

sero[i % 3] += arr[i];

}

System.out.println(Arrays.toString(sero));

}

'코딩 > 2-JAVA' 카테고리의 다른 글

C06중첩반복 => C0601중첩반복 ~ C0605소수여러개 (0)	2025.06.23
C05배열과데이터 (0)	2025.06.23
C04배열 => C0401날짜 , C0402중복숫자 , C0403교환 (1)	2025.06.20
C03반복문 => C0304반복문입력 (0)	2025.06.20
C03반복문 => C0301공약수 ~ C0303연립방정식_개념연습 (0)	2025.06.19

현재글C0404규칙찾기, C0405규칙찾기입력, C0405행렬

tree0505 님의 블로그

tree0505 님의 블로그 입니다.

q, 랑,

Today :
Yesterday :

tree0505 님의 블로그