고정 헤더 영역
상세 컨텐츠
본문
import java.util.Scanner;
public class ㅋ44 {
public static void main(String[] args) {
dan(0);
}
public static void dan(int z){
Scanner sc = new Scanner(System.in);
int b = sc.nextInt();
z = z+b;
System.out.println(z);
dan(z);
}
}1. 가위, 바위, 보 게임을 RockScissPaper 클래스로 만들어서
NumBaseball과 같은 구성을 만들어보세요.
public class RockScissPaper {
//몇승 몇무 몇패인지 셀 변수
private int win = 0;
private int draw = 0;
private int lose = 0;
//승점 담아줄 변수(승:1, 무:0, 패:-1)
private int score = 0;
//승무패 기록을 담아줄 배열
private int[] wdl;
//게임 실행 메소드
public void start() {
while(true) {
Scanner sc = new Scanner(System.in);
//사용자가 입력한 round 만큼 게임진행
System.out.print("진행할 게임의 판 수를 입력하세요.");
int round = sc.nextInt();
wdl = new int[round];
//총 10판 진행
for(int i = 0; i < wdl.length; i++) {
//클래스 안에 랜덤 변수를 발생시키는 메소드
//1 ~ 3까지 랜덤 변수 발생(1:가위, 2:바위, 3:보)
int randomVal = generateRandom();
//int randomVal2 = generateRandom();
//사용자 입력 값 받아서 정수형 변환해주는 메소드
int userNum = convertUserInput(sc);
if(userNum == 0) {
System.out.println("잘못 입력하셨습니다.");
//해당 게임을 다시 진행하기 위해 1 감소
//for문에서 continue문을 만나면 증감식으로 이동하기 때문
i--;
continue;
}
//승, 무, 패 판단해주는 메소드
//가위, 바위, 보 비교
//무승부
judgeWdl(userNum, randomVal, i);
}
//승점 계산해주는 메소드
//승점 계산
sumScore();
if(reGame()) {
break;
} else {
continue;
}
}
}
//1~3 중 랜덤 값 발생시키는 메소드
public int generateRandom() {
}
//사용자 입력 값을 정수형을 변환해주는 메소드
public int convertUserInput(Scanner sc) {
}
//승, 무, 패 판단 메소드
public void judgeWdl(int userNum, int randomVal, int i) {
}
//승점 계산 및 출력 메소드
public void sumScore() {
}
}Java로 야구게임을 구현해 보겠다. 규칙은 아래와 같다.
- 1~9 사이의 중복되지 않는 3개의 정수를 생성한다.
- 사용자는 3개의 숫자를 입력한다.
- 생성된 3개의 숫자를 맞추는데 위치까지 정확히 맞춰야 한다.
- 숫자와 숫자의 위치까지 일치하면 strike 로 판정한다.
- 숫자는 맞지만 위치가 틀렸다면 ball 로 판정한다.
- 숫자3개가 모두 일치하지 않으면 out 으로 판정한다.
- 3 strike 가 되면 게임은 종료된다.
- 시도한 횟수를 표시한다.
- 계속할지 종료할지 여부를 물어보고 다음 진행을 한다.
1. 더하기, 빼기 곱하기 나누기를 수행하는 각 클래스
Add, Sub, Mul, Div를 만드세요
이들은 모두 다음 필드와 메서드를 가집니다
1) int타입의 a, b 필드 : 연산하고자 하는 숫자들
2) void setValue(int a, int b) : 숫자를 객체에 설정
3) int calculate(): 해당 목적에 맞는 연산을 실행하고 그 결과를 리턴합니다
Add, Sub, Mul, Div모두 공통된 필드와 메서드가 존재하므로
Calc를 정의하고 이들이 Calc를 상속받게 하세요
그리고 Calc의 배열에 자식 객체들을 담고
calculate를 실행시키세요
Calc[] calcArr = new Calc[4];
calcArr[0] = new Add();
calcArr[1] = new Sub();
calcArr[2] = new Mul();
calcArr[3] = new Div();
calcArr[0].calculate(); ---------------------> 덧셈실행
calcArr[1].calculate(); ---------------------> 뺄셈실행
calcArr[2].calculate(); ---------------------> 곱셈실행
calcArr[3].calculate(); ---------------------> 나눗셈실행
1. 다음 두 개의 static메소드를 가진 ArrayUtility클래스를 만들어보고 사용해보세요
static double[] intToDouble(int[] source); // int배열을 double배열로 변환
static int[] doubleToInt(double[] source); // double배열을 int배열로 변환
2. 다음 두 개의 static 가진 ArrayUtility2클래스를 만들어보고 사용하세요
static int[] concat(int[] s1, int[] s2); // s1과 s2를 연결한 새로운 배열 리턴
static int[] remove(int[] s1, int[] s2); // s1에서 s2배열의 숫자를 모두 삭제한 새로운 배열 리턴
3.21
1. Calculator 클래스를 만들고 인스턴스 중첩 클래스로
Add, Sub, Mul, Div 클래스를 만드세요.
각각 int add(int a, int b)
int sub(int a, int b)
int mul(int a, int b)
int div(int a, int b)
메소드를 가진 인스턴스 중첩 클래스를 구현하시면 됩니다.
3.22
1. 사용자가 입력한 문자열을 순서대로 정리하세요.
순서는 유니코드 값 오름차순으로 정리.
&&&&&&&&&&&&&&&&&&&&& 매우중요함 매우
매우중요함
아주중요!!! 배열의 자리를 바꾼다!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11
2. 사용자가 입력한 문자열(단, 숫자로만 구성돼야함)을
정수형으로 바꿔주는 메소드 int convertToInt(String str)
을 작성하세요. ex) "532" -> 532, "-714" -> -714
3. 사용자가 영문자로만 구성된 문자열과 정수를 1개 입력합니다.
해당 문자열에서 알파벳 대문자는 입력된 정수만큼 증가,
알파벳 소문자는 입력된 정수만큼 감소된 새로운 문자열을 출력하세요.
a에서 1 감소하면 z로 Z에서 1 증가하면 A로 순환됩니다.
ex) OoOpGh, 2 -> QmQnIf 출력
1. Reverse라는 클래스를 만들고 메소드로
String reverseString(String str)를 만듭니다.
매개변수로 받은 str을 거꾸로 만든 String을 리턴하도록 만드세요.
2. 사용자가 입력한 문자열에서 중복된 문자를 제거한 문자열을 출력하세요.
매우중요함 매우매우매우
아우 너무너무너무너무 어려움.... 너무어려움
3. 사용자가 입력한 문자열에서 3의 배수 자리의 문자는 3으로 5의 배수 자리의 문자는 5로 변경하여 출력하세요.
3.23
1. 인터페이스 Student - void saveInfo();
- void printInfo();
- double getAvg(); => round로 소수점 두 자리까지만 표출
클래스 CommonStat - int sno; 학번
- StringBuffer name;
- String[] subject;
- int[] finalExam;
위 인터페이스와 클래스를 상속받은 MathStudent, EngStudent, ComStudent 구현
학생별로 수강중인 과목의 개수가 다릅니다.
그리고 MainPage(메인화면 페이지)
InputStudentInfo 클래스(학생정보 입력 페이지)
InputSubject 클래스(과목과 점수 입력 페이지)
PrintStInfo(학생정보 출력 페이지)
PrintStRank(학과별 학생 성적 평균 순위)를 클래스로 나눠서 화면을 구성하세요.
------학적관리------
1. 학생정보 입력
2. 학생정보 검색
3. 학생정보 전체출력
4. 학과별 성적 순위
5. 종료
------학생정보 입력------
1. 기본정보 입력
2. 과목정보 입력
------기본정보 입력------
학번 :
이름 :
학과 :
------과목정보 입력------
과목을 입력하세요.
점수를 입력하세요.
------학생정보 검색------
검색할 학생의 학번을 입력하세요.
1
학번 : 1
이름 : 홍길동
학과 : 클래스로 유추
평균 점수 : 75.34
------학생정보 전체출력------
학번 : 1
이름 : 홍길동
학과 : 클래스로 유추
평균 점수 : 75.34
------------------------------------
학번 : 2
이름 : 김길동
학과 : 클래스로 유추
평균 점수 : 90.15
1. 크기가 30인 StringBuffer에 "hello"라는 문자열이 담겨있다.
비어있는 바이트의 공간을 b, i, t가 반복되어 들어가도록 모두 채우세요. 어려움.
2. "유용한 클래스는 많다. 다양한 라이브러리를 활용한다."라는 문자열이 있을때
사용자가 정수를 입력하고 문자열을 거꾸로 만든 문자열의 정수 인덱스의 문자를 출력하세요.
4. 재귀메소드를 이용해 사용자가 입력한 숫자까지의 합을 구하시오. -- 두가지 방법으로
3.24
1. 2001년 12월 19일이 결혼기념일인 부부가 있다.
윤년이 있는 년도에는 결혼기념일의 날짜를 하루씩 더하기로 했다.
2022년의 결혼기념일 날짜를 구하세요.
2. 사용자 입력한 문자열에서 연속된 동일한 문자를 찾고
연속된 동일한 문자를 발견했을 때 하나빼고 다 제거하여
출력하세요. (단, 대소문자 구분함. StringBuilder를 사용하세요.)
ex) aabbcdeffaaaaynguuuuuu -> abcdefayngu
3. 사용자가 두 개의 날짜(yyyy-MM-dd 형식)를 입력하고 입력받은
두 날짜 사이의 날짜를 모두 출력하세요. (Calendar 클래스를 사용하세요).
ex) 2023-01-29 2023-02-05 입력
출력 2023-01-29
2023-01-30
2023-01-31
2023-02-01
2023-02-02
2023-02-03
2023-02-04
2023-02-05
1. 사용자가 입력한 날짜(yyyy-MM-dd 형식으로 입력받음)에 add 메소드로 3일뒤로 변경하고
yyyy-MM-dd 형식으로 출력하세요. (SimpleDateFormat 클래스 사용. SimpleDateFormat의
parse() 메소드를 이용하면 String -> Calendar로 변환가능)
2. 길이가 8이며 한글로 된 요일이 저장되어 있는 요일 배열을 만들고
사용자가 입력한 날짜(yyyy-MM-dd 형식으로 입력받음)의 요일을 한글로 출력하세요.
3. 두 개의 날짜 데이터 2023-03-15 20:31:45와 2021-07-08 11:58:04의 차이를
시 분 초 형태로 나타내시오.
3.27
1. 사용자가 입력한 문자열에서 가장 많이 등장하는 문자와 그 개수를 출력하세요.
(Map<Character, Integer> 형태의 Map과 Entry 사용) =============== 매우중요함
2. 사용자가 입력한 5개의 정수를 저장하는 List<Integer>를 생성하고
연속된 두 수의 합이 가장 커지는 구간의 두 수를 출력하세요.
ex) [1, 2, 3, 4, 5] => 4, 5 출력
//3. 사용자가 입력한 6개의 정수를 저장하는 List<Integer>를 생성하고
// 두 수의 합이 유일한 값이 되는 개수를 출력하세요.(중복 숫자 사용불가)
// ex) [1, 2, 3, 4, 5, 6] => 총 4개(3, 4, 10, 11)
4. 회원 클래스 Member(private int no, private String id, private String name,
private Date lastLoginDate, private String Status)를 만들고 getter와
setter를 만듭니다. lastLoginDate와 오늘날짜의 차를 날짜로 리턴하는 메소드
public long getDiffDate();를 만들고 차가 365일 이상되는 회원의 상태를
"N"으로 변경합니다. Status의 초기값은 "Y"로 주시고 List<Member>를 만들어
10개의 데이터를 입력합니다(생성자로 10개 객체생성).
10명중 정지된 회원(Status가 "N"인 회원)의 수를 출력하세요.
1. 학생이름을 key로 시험점수를 value로 가지는 Map<String, Integer>를 생성하고
4명의 학생 데이터를 입력한 후 4명 중 최고 점을 맞은 학생의 이름과 점수을 출력하세요.
2. 정수 배열 {1, 2, 3, 4, 5}에서 두 수의 합을 구할 때 같은 값이 나오는 개수 세서
Map<String, Integer>에 담은 후 출력하세요.
ex) {"3" : 1({1, 2}), "4" : 1({1, 3}), "5" : 2({1, 4}, {2, 3})}
3. 16일 숙제였던 PhoneInfo를 List<Map<String, String>>이용하여 재구성하세요.
3.28
1. Map<String, String> memberMap(key는 이름, value는 역할) 멤버변수로 가지고
Group(Map<String, String> map) 생성자로 memberMap에 저장하며 getter/setter와
해당 group의 조장을 Entry<String, String>형태로 리턴하는 getCaptin메소드를
가지는 클래스 Group을 구현
2. Group을 상속받은 GroupA~F까지 만들고 각각 기본생성자에서 부모의 생성자를 호출하여
memberMap에 정보를 저장하는 클래스를 구현
기본생성자() {
Map<String, String> map = new HashMap<String, String>();
map.put(이름1, 역할1);
.....
super(map);
}
3. StudyGroup<T>라는 제네릭클래스를 만들고 List<T>으로 6개의 조를 모두 가지는
리스트를 멤버변수로 가지고 getter/setter 만들고 List<Entry<String, String>>
형태로 각 조의 조장의 정보(이름, 역할)를 리턴하는 메소드 getCaptins를 구현하세요.
(Group)T <= 이런식의 형변환이 가능합니다.
1. key와 value 모두 Number를 상속받은 클래스의 타입을 가지고 key, value의 곱이 가장 큰
Entry를 리턴하는 메소드 getMaxMul을 구현하세요.
2. Map을 매개변수로 받아서 key는 정순 출력, value는 역순 출력하는 printKVDesc라는 제네릭 메소드를
구현하세요. 1 : 5
2 : 4
3 : 3
3. T 배열을 받아서 합, 차, 곱셈, 나눗셈을 연산해주는 Calculator 제네릭 클래스를 구현하세요.
각 메소드는 double로 리턴하고 add, sub, mul, div로 메소드명을 갖습니다.
(Math.round()로 소수점 두자리까지만 표출)
import java.util.Arrays;
import java.util.Scanner;
public class z42 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] myball = new int[3];
int play = 0;
while (play < 3) {
int strike = 0;
int ball = 0;
for (int i = 0; i < myball.length; i++) {
myball[i] = sc.nextInt();
}
System.out.println(Arrays.toString(myball));
int[] comball = new int[3];
for (int i = 0; i < comball.length; i++) {
comball[i] = (int) (Math.random() * 5) + 1;
for (int j = 0; j < i; j++) {
if (comball[i] == comball[j]) {
i--;
}
}
}
System.out.println(Arrays.toString(comball));
for (int i = 0; i < myball.length; i++) {
for (int j = 0; j < comball.length; j++) {
if (myball[i] == comball[j] && i == j) {
strike++;
} else if (myball[i] == comball[j] && i != j) {
ball++;
}
}
}
System.out.println(strike + "스트라이크 " + ball + "볼");
if (strike == 0 && ball == 0) {
System.out.println("당신은 아웃임니다.");
System.exit(1);
} else if (strike == 3) {
System.out.println("3스트라이크 끝");
System.exit(1);
}
play++;
}
}
}
import java.util.Random;
import java.util.Scanner;
public class BaseBallVarGame {
public static void main(String[] args) {
Random random = new Random();
Scanner scanner = new Scanner(System.in);
//게임에서 사용할 변수
int com1, com2, com3;
int user1, user2, user3;
int randomCnt = 0;//난수생성 카운트
int gameCount = 0;//게임 카운트
int strikeCnt=0, ballCnt=0;//스크라이크,볼 카운트
//게임전체반복
while(true) {
//중복되지 않는 3개의 난수생성
while(true) {
//몇번만에 난수가 생성되는지 확인
randomCnt++;
//1~9사이의 난수생성
com1 = random.nextInt(100) % 9 + 1;
com2 = random.nextInt(100) % 9 + 1;
com3 = random.nextInt(100) % 9 + 1;
if(!(com1==com2 || com2==com3 || com3==com1)) {
//중복되지 않는 난수 생성에 성공하면 루프탈출
break;
}
}////while end
//난수확인
System.out.println(randomCnt+"회:"+com1+" "+com2+" "+com3);
while(true) {
//사용자로부터 3개의 정수를 입력받는다.
System.out.println("3개의정수를 입력하세요(1~9)");
System.out.println("스페이스로 구분하시고 마지막에 Enter를 눌러주세요");
user1 = scanner.nextInt();
user2 = scanner.nextInt();
user3 = scanner.nextInt();
//게임카운트 1회 증가
gameCount++;
//판단1 - 스크라이크(숫자와 위치까지 일치)
if(com1==user1) strikeCnt++;
if(com2==user2) strikeCnt++;
if(com3==user3) strikeCnt++;
//판단2 - 볼(숫자는 일치하나 위치가 다를때)
if(com1==user2 || com1==user3) ballCnt++;
if(com2==user1 || com2==user3) ballCnt++;
if(com3==user1 || com3==user2) ballCnt++;
//게임종료판단
if(strikeCnt==3) {
System.out.println("3스트라이크 게임종료");
System.out.println(gameCount+"번만에 맞추셨습니다.");
break;//루프탈출
}
else {
//하나도 못맞추는 경우
if(strikeCnt==0 && ballCnt==0) {
System.out.println("아웃입니다");
}
else {
System.out.printf("%d스트라이크, %d볼\n",
strikeCnt, ballCnt);
}
//스트라이크, 볼 카운트 초기화
strikeCnt = 0;
ballCnt = 0;
//continue문은 필요없음.
}
}////while end
System.out.println("한게임 더 하시겠습니까?(0:종료,1:재시작)");
int restart = scanner.nextInt();
if(restart==0) {
//게임종료
System.out.println("\n==게임이 종료되었습니다.==\n");
//실행되는 즉시 main함수가 종료된다.
System.exit(0);
}
else if(restart==1){
//게임을 재시작하기 위해 카운트변수 초기화
strikeCnt = 0;
ballCnt = 0;
gameCount = 0;
System.out.println("\n==게임을 재시작합니다.==\n");
}
}//게임 전체 반복 while end
}//main 메서드 end
}//class 끝
public class s41 {
public static void main(String[] args) {
calc[] cal = new calc[1];
cal[0] = new add();
cal[0].setvalue(4,5);
System.out.println(cal[0].calculate());
}
}
class add extends calc{
@Override
int calculate(){
return this.a + this.b;
}
}
class calc {
int a;
int b;
void setvalue(int a, int b){
this.a = a;
this.b = b;
}
int calculate(){
return this.a - this.b;
}
}import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Collectors;
public class z40 {
public static void main(String[] args) {
int[] s1 = {1,3,4,5,6};
int[] s2 = {1,2,3,4};
int[] ggg = z40.kkk(s1, s2);
System.out.println(Arrays.toString(ggg));
}
public static int[] kkk(int[]s1, int[]s2){
ArrayList<Integer> s11 = (ArrayList<Integer>) Arrays.stream(s1).boxed().collect(Collectors.toList());
ArrayList<Integer> s12 = (ArrayList<Integer>) Arrays.stream(s2).boxed().collect(Collectors.toList());
for(int i=s11.size()-1;i>=0;i--){
for(int j=s12.size()-1;j>=0;j--){
if(s11.get(i)==s12.get(j)){
s11.remove(i);
}
}
}
int[] kh = s11.stream().mapToInt(a->a).toArray();
return kh;
}
}
public class ㅋ41 {
public static void main(String[] args) {
ㅋ41 z = new ㅋ41();
ㅋ41.calculator bb = z.new calculator();
ㅋ41.calculator.add zz =bb.new add();
System.out.println(zz.add(1,3));
}
class calculator{
class add{
int add(int a, int b){
return a+b;
}
}
class sub{
int sub(int a, int b){
return a-b;
}
}
class mul{
int mul(int a, int b){
return a*b;
}
}
class div{
int div(int a, int b){
return a/b;
}
}
}
}
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;
//2. 사용자가 입력한 문자열에서 중복된 문자를 제거한 문자열을 출력하세요.
//
// 매우중요함 매우매우매우
//해쉬셋, 어레이리스트 정순 -- ,어레이리스트 뒤에서 -- or break;
public class z1 {
public static void main(String[] args) {
String a = "bbbaaccc";
ArrayList<String> zz = new ArrayList<>();
zz = Arrays.stream(a.split("")).collect(Collectors.toCollection(ArrayList<String>::new));
//모로가도 그냥 있으면 지워버리면 된다.
//뒤어소 앞으로 오는거면 브레이크만 하면 되는데 아펭서 뒤로가는거면 인덱스가 바뀌어서 i--를 해야한다.
//스트림을 하는 방법도 두개가 있다. collectors.tocollection 을 하거나 ccollectors.tolist를 해도 된다.
for(int i=0;i<zz.size()-1;i++){
for(int j=i+1;j<zz.size();j++){
if(zz.get(i).equals(zz.get(j))){
zz.remove(i);
i--;
break;
}
}
}
// HashSet<String> ba = new HashSet<>();
// for(int i=0;i<zz.size();i++){
//
// ba.add(zz.get(i));
// }
//
// System.out.println(ba);
//for(int i=zz.size()-1;i>=1;i--){
// for(int j=i-1;j>=0;j--){
//
// if(zz.get(i).equals(zz.get(j))){
//
// zz.remove(i);
//
// }
// }
//
//
//}
System.out.println(zz);
}
}
//}
//
//import java.util.ArrayList;
// import java.util.Arrays;
// import java.util.stream.Collectors;
//
//public class z42 {
// public static void main(String[] args) {
//
//
//
//
//
//
//
// String a = "aaa11111111111111bbc";
//
// String[] b = a.split("");
// ArrayList<String> ass = (ArrayList<String>) Arrays.stream(b).collect(Collectors.toList());
//
// for(int i=0;i<ass.size();i++){
//
// for(int j=0;j<i;j++){
// if(ass.get(i).equals(ass.get(j))){
// ass.remove(i);
// i--;
//이건 i를 --해서 도돌이표한다 이것도 좋은방법
// }
//
// }
//
// }
//
// System.out.println(ass.getClass());
// System.out.println(ass);
//
//
//
//
//
//
//
//
//
//
//
// }
//}
//import java.util.ArrayList;
// import java.util.Scanner;
//
//public class z2 {
// public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
//
// System.out.print("문자열을 입력하세요: ");
// String input = scanner.nextLine();
//
// ArrayList<Character> list = new ArrayList<>();
//
// for (int i = 0; i < input.length(); i++) {
// char c = input.charAt(i);
// if (!list.contains(c)) {
// list.add(c);
// }
// }
//
// char[] arr = new char[list.size()];
//
// for (int i = 0; i < list.size(); i++) {
// arr[i] = list.get(i);
// }
//
// String output = new String(arr);
//
// System.out.println("중복 문자를 제거한 문자열: " + output);
// }
//}import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//3. 사용자가 입력한 문자열에서 3의 배수 자리의 문자는 3으로 5의 배수 자리의 문자는 5로 변경하여 출력하세요.
public class z1 {
public static void main(String[] args) {
String haha = "111111111111111111111";
StringBuilder a = new StringBuilder(haha);
for(int i=0;i<a.length();i++){
if(i!=0&&i%3==0){
a.setCharAt(i-1,'3');
}
if(i!=0&&i%5==0){
a.setCharAt(i-1,'5');
}
}
System.out.println(a);
}
}import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//1. 크기가 30인 StringBuffer에 "hello"라는 문자열이 담겨있다.
// 비어있는 바이트의 공간을 b, i, t가 반복되어 들어가도록 모두 채우세요. 어려움.
public class z1 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer(30);
sb.append("hello");
while(sb.length()<sb.capacity()){
sb.append("b");
if(sb.length()<30){
sb.append("i");
}
if(sb.length()<30){
sb.append("t");
}
}
System.out.println(sb);
System.out.println(sb.capacity());
}
}import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//2. "유용한 클래스는 많다. 다양한 라이브러리를 활용한다."라는 문자열이 있을때
// 사용자가 정수를 입력하고 문자열을 거꾸로 만든 문자열의 정수 인덱스의 문자를 출력하세요.
public class z1 {
public static int zz = 0;
public static void main(String[] args) {
String a = "유용한 클래스는 많다. 다양한 라이브러리를 활용한다.";
// String[] z = a.split("");
//
//
// String zz = "";
// for(int i=z.length-1;i>=0;i--){
//
// zz+=z[i];
// }
//
// System.out.println(zz);
StringBuilder aa = new StringBuilder(a);
aa.reverse();
String z = aa.toString();
System.out.println(z);
}
}
public class ㅋ44 {
public static int b=0;
public static void main(String[] args) {
double a = 10000;
int b = 0;
while(b<10){
a = a*1.1;
b++;
}
System.out.println(a);
System.out.println(k(10000));
}
public static double k(double z){
b++;
if(b==11){
return z;
}else{
return k(z*1.1);
}
}
}import java.util.Scanner;
public class ㅋ44 {
public static int p = 0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
System.out.println(recursivesum(a));
}
public static int n(int z) {
p++;
if (z == 0) {
return 0;
} else {
if (p < z) {
return n(z) + 1;
} else {
return z;
}
}
///// 내가한거
}
public static int recursivesum(int n){
if(n==1){
return 1;
}
else{
return n+recursivesum(n-1);
}
}
}public class ㅋ44 {
public static int z = 0;
/// 이것도 된다.
public static void main(String[] args) {
System.out.println(can(11));
System.out.println(10000*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1);
}
public static double can(double a) {
z++;
if (z < a) {
return can(a) * 1.1;
} else {
return 10000;
}
}
}public class ㅋ44 {
public static int z = 0;
/// 이것도 된다.
public static void main(String[] args) {
System.out.println(can(11));
System.out.println(dan(11));
System.out.println(10000*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1*1.1);
}
public static double can(double a) {
z++;
if (z < a) {
return can(a) * 1.1;
} else {
return 10000;
}
}
public static double dan(double a){
if(a==1){
return 10000;
}else{
return 1.1*dan(a-1);
}
}
}여기는 내가 원한대로 된거같긴 한데....
import java.util.Scanner;
//4. 재귀메소드를 이용해 사용자가 입력한 숫자까지의 합을 구하시오. -- 두가지 방법으로
public class z1 {
public static int z = 0;
public static void main(String[] args) {
z1.kk(1);
}
public static int kk(int a){
z+=a;
System.out.println(z);
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
return kk(n);
}
public static void sum(int a) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
z += num;
System.out.println(z);
sum(z);
}
// public static int sum(int a){
//
// if( a ==0){
//
// return 0;
// }else{
//
// return a+sum(a-1);
//
// }
//
// }
}
public class ㅋ44 {
public static void main(String[] args) {
String a = "aaaabbc";
char[] chars = a.toCharArray();
int maxCount = 0;
char maxChar = ' ';
for (int i = 0; i < chars.length; i++) {
int count = 0;
for (int j = 0; j < chars.length; j++) {
if (chars[i] == chars[j]) {
count++;
}
}
if (count > maxCount) {
maxCount = count;
maxChar = chars[i];
}
}
System.out.println("The most frequent character is '" + maxChar + "', which appears " + maxCount + " times.");
}
}이렇게도 풀 수 있음.
import java.text.SimpleDateFormat;
import java.util.*;
//1. 사용자가 입력한 문자열에서 가장 많이 등장하는 문자와 그 개수를 출력하세요.
// (Map<Character, Integer> 형태의 Map과 Entry 사용) =============== 매우중요함
public class z1 {
public static void main(String[] args) {
String a = "abceddddd";
HashMap<Character,Integer> bb = new HashMap<>();
for(int i=0;i<a.length();i++){
if(!bb.containsKey(a.charAt(i))){
bb.put(a.charAt(i),1);
}else{
bb.put(a.charAt(i),bb.get(a.charAt(i))+1);
}
}
System.out.println(bb);
}
}
import java.text.SimpleDateFormat;
import java.util.*;
//2. 사용자가 입력한 5개의 정수를 저장하는 List<Integer>를 생성하고
// 연속된 두 수의 합이 가장 커지는 구간의 두 수를 출력하세요.
// ex) [1, 2, 3, 4, 5] => 4, 5 출력
public class z1 {
public static void main(String[] args) {
ArrayList<Integer> a = new ArrayList<>();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
a.add(5);
int key = 0;
int val = 0;
int sum = 0;
for(int i=0;i<a.size()-1;i++){
if(a.get(i)+a.get(i+1)>sum){
key = a.get(i);
val = a.get(i+1);
sum = a.get(i) + a.get(i+1);
}
}
System.out.println(key);
System.out.println(val);
System.out.println(sum);
}
}import java.text.SimpleDateFormat;
import java.util.*;
//3. 사용자가 입력한 6개의 정수를 저장하는 List<Integer>를 생성하고
// 두 수의 합이 유일한 값이 되는 개수를 출력하세요.(중복 숫자 사용불가)
// ex) [1, 2, 3, 4, 5, 6] => 총 4개(3, 4, 10, 11)
public class z1 {
public static void main(String[] args) {
ArrayList<Integer> a = new ArrayList<>();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
a.add(5);
a.add(6);
HashMap<Integer, Integer> aa = new HashMap<>();
for (int i = 0; i < a.size() - 1; i++) {
for (int j = i + 1; j < a.size(); j++) {
if (!aa.containsKey(a.get(i) + a.get(j))) {
aa.put(a.get(i) + a.get(j), 1);
} else {
aa.put(a.get(i) + a.get(j), aa.get(a.get(i) + a.get(j)) + 1);
}
}
}
System.out.println(aa);
int num=0;
for(Map.Entry<Integer,Integer> entry : aa.entrySet()){
if(entry.getValue()==1){
num++;
}
}
System.out.println(num);
}
}
import java.text.SimpleDateFormat;
import java.util.*;
//4. 회원 클래스 Member(private int no, private String id, private String name,
//private Date lastLoginDate, private String Status)를 만들고 getter와
// setter를 만듭니다. lastLoginDate와 오늘날짜의 차를 날짜로 리턴하는 메소드
//public long getDiffDate();를 만들고 차가 365일 이상되는 회원의 상태를
// "N"으로 변경합니다. Status의 초기값은 "Y"로 주시고 List<Member>를 만들어
// 10개의 데이터를 입력합니다(생성자로 10개 객체생성).
// 10명중 정지된 회원(Status가 "N"인 회원)의 수를 출력하세요.
public class z1 {
public static void main(String[] args) {
List<member> k = new ArrayList<>();
k.add(new member(1,"ha","king",new Date(121,0,1),"Y"));
k.add(new member(2,"gha","king",new Date(130,4,15),"Y"));
k.add(new member(3,"gha","king",new Date(100,5,1),"Y"));
int num=0;
for(int i=0;i<k.size();i++){
if(k.get(i).getDiffDate()>365){
k.get(i).setStatus("N");
num++;
}
}
System.out.println(num);
}
}
class member{
public long getDiffDate(){
Date now = new Date();
return (now.getTime() - this.lastlogindate.getTime())/(1000*60*60*24);
}
private int no;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getLastlogindate() {
return lastlogindate;
}
public void setLastlogindate(Date lastlogindate) {
this.lastlogindate = lastlogindate;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
private String id;
private String name;
private Date lastlogindate;
private String status;
public member(int no, String id, String name, Date lastlogindate, String status) {
this.no = no;
this.id = id;
this.name = name;
this.lastlogindate = lastlogindate;
this.status = status;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
@Override
public String toString() {
return "member{" +
"no=" + no +
", id='" + id + '\'' +
", name='" + name + '\'' +
", lastlogindate=" + lastlogindate +
", status='" + status + '\'' +
'}';
}
}import java.util.*;
//1. 학생이름을 key로 시험점수를 value로 가지는 Map<String, Integer>를 생성하고
// 4명의 학생 데이터를 입력한 후 4명 중 최고 점을 맞은 학생의 이름과 점수을 출력하세요.
public class z1 {
public static void main(String[] args) {
HashMap<String, Integer> aa = new HashMap<>();
aa.put("a", 1);
aa.put("b", 2);
aa.put("c", 3);
aa.put("d", 4);
aa.put("e", 5);
aa.put("f", 6);
aa.put("g", 7);
Map.Entry<String, Integer> maxEntry = aa.entrySet().stream()
.filter(entry -> entry.getValue() != null)
.max(Comparator.comparingInt(Map.Entry::getValue))
.orElse(null);
System.out.println("Entry: " + maxEntry);
Map.Entry<String,Integer> aaa = aa.entrySet().stream().max(Comparator.comparingInt(Map.Entry::getValue)).orElse(null);
}
}
// Comparator<Map.Entry<String, Integer>> valueComparator =
// (entry1, entry2) -> entry1.getValue().compareTo(entry2.getValue());
// Map.Entry<String, Integer> maxEntry = aa.entrySet().stream()
// .filter(entry -> entry.getValue() != null)
// .max(valueComparator)
// .orElse(null);
// HashMap<String, Integer> aa = new HashMap<>();
//
//aa.put("a", 1);
// aa.put("b", 2);
// aa.put("c", 3);
// aa.put("d", 4);
// aa.put("e", 5);
// aa.put("f", 6);
// aa.put("g", 7);
//
// Map.Entry<String, Integer> maxEntry = null;
// for (Map.Entry<String, Integer> entry : aa.entrySet()) {
// if (entry.getValue() != null) { // null이 아닌 경우만 처리
// if (maxEntry == null || entry.getValue() > maxEntry.getValue()) {
// maxEntry = entry;
// }
// }
// }
//
// System.out.println("Entry: " + maxEntry);
import java.util.*;
//2. 정수 배열 {1, 2, 3, 4, 5}에서 두 수의 합을 구할 때 같은 값이 나오는 개수를 세서
// Map<String, Integer>에 담은 후 출력하세요.
// ex) {"3" : 1({1, 2}), "4" : 1({1, 3}), "5" : 2({1, 4}, {2, 3})}
public class z1 {
public static void main(String[] args) {
HashMap<String,Integer> aa = new HashMap<>();
aa.put("a",1);
aa.put("b",2);
aa.put("c",3);
aa.put("d",4);
aa.put("e",5);
aa.put("f",6);
aa.put("g",7);
Map.Entry<String,Integer> a = null;
for(Map.Entry<String,Integer> entry : aa.entrySet()){
if(a==null||entry.getValue()>a.getValue()){
a=entry;
}
}
System.out.println(a);
}
}
// HashMap<String, Integer> aa = new HashMap<>();
//
//aa.put("a", 1);
// aa.put("b", 2);
// aa.put("c", 3);
// aa.put("d", 4);
// aa.put("e", 5);
// aa.put("f", 6);
// aa.put("g", 7);
//
// Map.Entry<String, Integer> maxEntry = null;
// for (Map.Entry<String, Integer> entry : aa.entrySet()) {
// if (entry.getValue() != null) { // null이 아닌 경우만 처리
// if (maxEntry == null || entry.getValue() > maxEntry.getValue()) {
// maxEntry = entry;
// }
// }
// }
//
// System.out.println("Entry: " + maxEntry);
import java.util.*;
//2. 정수 배열 {1, 2, 3, 4, 5}에서 두 수의 합을 구할 때 같은 값이 나오는 개수를 세서
// Map<String, Integer>에 담은 후 출력하세요.
// ex) {"3" : 1({1, 2}), "4" : 1({1, 3}), "5" : 2({1, 4}, {2, 3})}
public class z1 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
Map<Integer, Integer> aaa = new HashMap<>();
for(int i = 0; i < a.length-1; i++){
for(int j = i+1; j < a.length; j++){
int sum = a[i] + a[j];
if(!aaa.containsKey(sum)){
aaa.put(sum, 1);
} else {
aaa.put(sum, aaa.get(sum) + 1);
}
}
}
Iterator<Map.Entry<Integer,Integer>> iterator = aaa.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<Integer,Integer> aaaa = iterator.next();
if(aaaa.getValue()==1){
iterator.remove();
}
}
// Iterator<Map.Entry<Integer, Integer>> iterator = aaa.entrySet().iterator();
// while(iterator.hasNext()){
// Map.Entry<Integer, Integer> entry = iterator.next();
// if(entry.getValue() == 1){
// iterator.remove();
// }
// }
System.out.println(aaa);
}
}
//
// Iterator는 컬렉션의 요소에 접근하고 반복문을 수행하는 데 사용되는 인터페이스입니다. Iterator는 hasNext() 메소드를 사용하여 컬렉션의 다음 요소가 존재하는지 확인하고, next() 메소드를 사용하여 컬렉션에서 다음 요소를 반환합니다. 또한 remove() 메소드를 사용하여 컬렉션에서 현재 요소를 제거할 수 있습니다.
//
// 위 코드에서는 aaa 맵의 entrySet() 메소드를 사용하여 Set<Map.Entry<Integer, Integer>> 객체를 가져옵니다. 그리고 iterator() 메소드를 호출하여 Iterator<Map.Entry<Integer, Integer>> 객체를 가져옵니다.
//
// 그리고 while 루프를 사용하여 iterator 객체에서 다음 요소가 존재하는지 확인합니다. iterator 객체에서 다음 요소를 가져올 때는 next() 메소드를 사용합니다. 이때, next() 메소드는 다음 요소를 나타내는 Map.Entry<Integer, Integer> 객체를 반환합니다.
//
// 그리고 가져온 Map.Entry<Integer, Integer> 객체의 값을 확인하여, 값이 1인 경우에는 remove() 메소드를 사용하여 해당 요소를 맵에서 제거합니다.
//
// 즉, 위 코드는 aaa 맵에서 값이 1인 요소를 모두 제거하는 코드입니다. Iterator를 사용하여 맵의 요소를 순회하고, 값이 1인 요소를 찾아 제거하는 것이 핵심입니다.import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
//1. key와 value 모두 Number를 상속받은 클래스의 타입을 가지고 key, value의 곱이 가장 큰
// Entry를 리턴하는 메소드 getMaxMul을 구현하세요.
public class z1 {
public static void main(String[] args) {
Map<Integer, Integer> kik = new HashMap<>();
kik.put(1, 3);
kik.put(2, 6);
kik.put(7, 9);
kik.put(1, 0);
z1.haha(kik);
System.out.println(z1.haha(kik));
}
public static <K extends Number,V extends Number> Map.Entry<K,V> haha(Map<K,V> kik){
double max = -12445.0;
Map.Entry<K,V> maxx = null;
for(Map.Entry<K,V> entry : kik.entrySet()){
if(entry.getKey().doubleValue() * entry.getValue().doubleValue()>max){
maxx = entry;
max = entry.getValue().doubleValue() * entry.getKey().doubleValue();
}
}
System.out.println(max);
return maxx;
}
}
//
// }
// public static <K extends Number,V extends Number>Map.Entry<K,V> haha(Map<K,V> a){
// Double max = -12453.0;
// Map.Entry<K,V> bb = null;
// for(Map.Entry<K,V> entry : a.entrySet()){
//
// if(entry.getKey().doubleValue()*entry.getValue().doubleValue()>max.doubleValue()){
//
// max = entry.getKey().doubleValue()*entry.getValue().doubleValue();
// bb = entry;
// }
//
// }
//
// System.out.println(max);
// return bb;
// }
//
//
//}
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
//
//2. Map을 매개변수로 받아서 key는 정순 출력, value는 역순 출력하는 printKVDesc라는 제네릭 메소드를
// 구현하세요. 1 : 5
// 2 : 4
// 3 : 3
public class z1 {
public static void main(String[] args) {
Map<Integer,String> kkk = new HashMap<>();
kkk.put(1,"ha");
kkk.put(2,"haq");
kkk.put(3,"hwga");
kkk.put(4,"wha");
kkk.put(5,"ha");
kkk.put(6,"a");
z1.printkvdesc2(kkk);
}
public static <T extends Number, V> void printkvdesc2(Map<T, V> m) {
ArrayList<T> key = new ArrayList<>();
ArrayList<V> value = new ArrayList<>();
for (Map.Entry<T, V> entry : m.entrySet()){
key.add(entry.getKey());
value.add(entry.getValue());
}
Collections.reverse(value);
Map<T,V> haha = new HashMap<>();
for(int i=0;i<key.size();i++){
haha.put(key.get(i), value.get(i));
}
System.out.println(haha);
}
}import java.util.Comparator;
import java.util.Map;
public class MapUtils {
public static <K extends Comparable<K>, V extends Comparable<V>> void printKVDesc(Map<K, V> map) {
map.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.sorted(Map.Entry.<K, V>comparingByValue().reversed())
.forEach(entry -> System.out.println(entry.getKey() + " : " + entry.getValue()));
}
public static void main(String[] args) {
Map<Integer, Integer> map = Map.of(
1, 3,
2, 4,
3, 5
);
printKVDesc(map);
}
}
//3. T 배열을 받아서 합, 차, 곱셈, 나눗셈을 연산해주는 Calculator 제네릭 클래스를 구현하세요.
// 각 메소드는 double로 리턴하고 add, sub, mul, div로 메소드명을 갖습니다.
// (Math.round()로 소수점 두자리까지만 표출) 푸는 두가지방법
import java.util.Arrays;
public class z1 {
public static void main(String[] args) {
Double[] g = {1.35,2.135,3.16,4.61};
hahaha ha = new hahaha();
// int[] z = {1,2,3};
// Integer[] boxed = Arrays.stream(z).boxed().toArray(Integer[]::new);
// 박스화
System.out.println(ha.add(g));
System.out.println(ha.minus(g));
System.out.println(ha.multiply(g));
System.out.println(ha.divide(g));
}
}
class hahaha<T extends Number> {
double add(T[] a) {
double sum = 0;
for (int i = 0; i < a.length; i++) {
sum += a[i].doubleValue();
}
return sum;
}
double minus(T[] a){
double sum=0;
for(int i=0;i<a.length;i++){
sum-=a[i].doubleValue();
}
return Math.round(sum*100)/100;
}
double multiply(T[] a){
double sum = 1;
for(int i=0;i<a.length;i++){
sum*=a[i].doubleValue();
}
return Math.round(sum*100)/(double)100;
}
double divide(T[] a){
double sum = 1;
for(int i=0;i<a.length;i++){
sum*=a[i].doubleValue();
}
return sum;
}
}
//import java.util.Arrays;
//
//public class z3 {
//
// public static void main(String[] args) {
//
// int[] z = {1,2,3};
// Integer[] boxed = Arrays.stream(z).boxed().toArray(Integer[]::new);
//
// Calculator c = new Calculator(boxed);
//
// System.out.println(c.add());
// }
//
//
//}
//class Calculator<T extends Number> {
//
// private final T[] numbers;
//
// public Calculator(T[] numbers) {
// this.numbers = numbers;
// }
//
// public double add() {
// double sum = 0;
// for (T number : numbers) {
// sum += number.doubleValue();
// }
// return Math.round(sum * 100) / 100.0;
// }
//
// public double sub() {
// double diff = numbers[0].doubleValue();
// for (int i = 1; i < numbers.length; i++) {
// diff -= numbers[i].doubleValue();
// }
// return Math.round(diff * 100) / 100.0;
// }
//
// public double mul() {
// double product = 1;
// for (T number : numbers) {
// product *= number.doubleValue();
// }
// return Math.round(product * 100) / 100.0;
// }
//
// public double div() {
// double quotient = numbers[0].doubleValue();
// for (int i = 1; i < numbers.length; i++) {
// quotient /= numbers[i].doubleValue();
// }
// return Math.round(quotient * 100) / 100.0;
// }
//}'될때까지 외우기' 카테고리의 다른 글
| [자바]문제모음4 (0) | 2023.04.14 |
|---|---|
| [자바] 문제모음3 (3) | 2023.04.14 |
| [자바] 문제모음1 (0) | 2023.04.14 |
| [람다] 문자열 두개 받아서 비교하는거 (0) | 2023.04.04 |
| [스트림] 꼭 외우기. 배열에서 가장 긴 문자를 리턴 (0) | 2023.03.31 |
댓글 영역