์ด ๋ฌธ์ ์๋ ํ์ค ์ ๋ ฅ์ผ๋ก ๋ ๊ฐ์ ์ ์ n๊ณผ m์ด ์ฃผ์ด์ง๋๋ค. ๋ณ(*) ๋ฌธ์๋ฅผ ์ด์ฉํด ๊ฐ๋ก์ ๊ธธ์ด๊ฐ n, ์ธ๋ก์ ๊ธธ์ด๊ฐ m์ธ ์ง์ฌ๊ฐํ ํํ๋ฅผ ์ถ๋ ฅํด๋ณด์ธ์.
์ ํ ์กฐ๊ฑด : n๊ณผ m์ ๊ฐ๊ฐ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค
class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
for (int i = 0; a < 3; i++) {
for (int i = 0; b < 5; i++) {
}
System.out.print("*");
}
System.out.println();
}
}
- Output size differs = ์คํํ ๊ฒฐ๊ณผ๊ฐ์ด ***์ด ๊ธฐ๋๊ฐ๊ณผ ๋ค๋ฅด๋ค.
- ์ถ๋ ฅ์ ๋ฐ๋๋ก ํด์ผ ํ ๊ฒ ๊ฐ๋ค. ์คํํ ๊ฒฐ๊ณผ๊ฐ์ด ***์ด ๊ธฐ๋๊ฐ *****๊ณผ ๋ค๋ฅด๋ค.
- ์.. ๊ทธ๋ผ ๋ณ์๋ฅผ ๋ด์ผํ ๊ฒ ๊ฐ๋ค ์ฒซ for๋ฌธ์ i -> a, ๋์งธ for๋ฌธ์ i->b๋ก ๋ณ๊ฒฝํ์ ๋ '์ถ๋ ฅํ ๋ด์ฉ์ด ๋๋ฌด ๊ธธ๋ค' ์๋ฌ ๋ฐ์.
- ๊ทธ๋ ๋ค๋ฉด... for๋ฌธ์ int๋ฅผ ๋ค์๋ณด์ -> ๋๋ฒ์งธ for๋ฌธ๋ int i๋ก ์ค์ j๋ก ๋ณ๊ฒฝํ์ผ๋ ์คํ์๊ฐ์ด 10.0์ด ์ด๊ณผํด์ ์ค๋จ๋จ.
- i < a;, j < b;๋ก แแ งแซ๊ฒฝ์ แแ ขแป๋ค. แแ งแซ๊ฒฝ๋ ๋ถ๋ถ์์ แแ งแซ์ i์ ๊ดํด แแ ฅแซแแ ณแธ์ด แแ ฌแป๋ค. ๊ณ ์น แแ งแซ์์์ ๋ฌธ์ ๊ฐ ์แแ งแป๋ค๋ แแ กแฏแแ ตแซ๋ฐ,,์ ....
- ๋๋ฒ์งธ for๋ฌธ์ แแ งแซ์๋ฅผ j๋ก ์คฌแแ ณแซ๋ฐ แแ งแซ์ ํ๋๋ฅผ i์์ j๋ก ์๋ฐแแ ฏแป๋ค. ์คํํ ๊ฒฐ๊ณผ๊ฐ์ด ๊ธฐ๋๊ฐ๊ณผ ๋ค๋ฅด๋ค.. ์ด๊ฒ์ ๋ฐ๋แแ ฅแป๋ค๋ ๋ง!!!
- ์๋... ' Output size differs' ๊ฑฐ์ ๋คแแ ชแป๋ค. ๊ธฐ๋ค๋ ค ์กฑ์ ๊ณง แแ ฎแฏ์ด์ค๊ฒ.
- ์ด์ฏค ๋๋ฉด ์ แแ ณแซ๊ฑฐ ๊ฐแแ ณแซ๋ฐ ๊ฒฐ๊ณผ ๊ธฐ๋๊ฐ์ด ๋ค๋ฅด๋ค๊ณ ?
- ์๊ฐ๋ แแ ฉแบแแ กแซ๊ฒ ์์แแ ณแซ๋ฐ ...แแ ฎแฏ๋ ฅ๋ฌธ์ด ์ด๋์ ์๋ ๊ดํธ ์ด๊ณ แแ กแฎ๊ณ ๊ฐ ์ด๋์ ์๋๋์ ๋ฌธ์ แแ งแป๋ค.. for๋ฌธ์ด๋ แแ งแซ์๊ฐ ์๋ฌด๋ฆฌ ๊ณ ์น ๋ถ๋ถ์ด ์แแ ฅแป๋ค.
- ๊ทธแ แ ขแป๊ธฐ ๋๋ฌธ์ แแ ณแฏ์ฌ์ฐ๊ธฐ๋ฅผ ์ ๋ง ๋ง์ด ๊ณ แแ งแป๋ค. ์ด๋์ง๋ฅผ ๋ชจ๋ฅด๊ฒ ์ด์ ๋ค ์ง์ฐ๊ณ ์๋ก ์ฒแแ ณแท๋ถํฐ แแ ฅแป๋๋ แแ ณแฏ์ฌ์ฐ๊ธฐ์ ๋ฌธ์ ์แแ ฅแป๋ค.. ์ต์ข ..
- ์ ๋ง ๋ง์ ์๊ฐ์ ํตํด ํด๊ฒฐํ๋ ํฌแแ งแฏ๋์นจ. ๋ฐ์ แแ ชแซ์ฑ๋ณธ์ด๋ค.
class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
for (int i = 0; i < b; i++) {
for (int j = 0; j < a; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
0๋ถํฐ 9๊น์ง์ ์ซ์ ์ค ์ผ๋ถ๊ฐ ๋ค์ด์๋ ์ ์ ๋ฐฐ์ด numbers๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. numbers์์ ์ฐพ์ ์ ์๋ 0๋ถํฐ 9๊น์ง์ ์ซ์๋ฅผ ๋ชจ๋ ์ฐพ์ ๋ํ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ : 1 โค numbers์ ๊ธธ์ด โค 9 0 โค numbers์ ๋ชจ๋ ์์ โค 9 numbers์ ๋ชจ๋ ์์๋ ์๋ก ๋ค๋ฆ ๋๋ค.
class Solution {
public int solution(int[] numbers) {
int answer = 45;
for (int i = 0; i < numbers.length; i++) {
answer -= numbers[i];
}
return answer;
}
}
- ์๊น แแ ฎแฏ์ด๋ณด๊ณ ํ์ฐธ ๋ค์ แแ ฎแฏ์ด๋ดคแแ ณแซ๋ฐ,, ๊ธฐ์ต์ แแ กแท๋ ์ด์ ๊ฐ แแ ตแป๋ค. ํ์คํ ๊ณต๋ถ๋ฒ!!
- ๋ฌธ์ ๋ฅผ ํ๊ณ , แแ ตแทแแ ฏแซแแ ณแฏ์๊ฒ ๋ฌธ์ แแ ฎแฏ์ด๋ฅผ ํด์ฃผ๊ธฐ๋ก ํแแ ณแซ๋ฐ ๋ด๊ฐ ์ดํด๊ฐ แแ กแซ๋๋ ์ค๋ช ๋ แแ กแซ๋๋ ๋ฒ.
- ๋ด๊ฐ ์ดํด๋ฅผ ํ๋ฉด ์ค๋ช ์ แแ ตแฏ์ด ๋ค๋ฅธ ๊ฒ ๊ฐ๋ค.. ํ๋ฒ์ แแ ณแฏ๋ฆฌ์ดํด์ ์์ํ๋ค ์กฑ์์ฌ
2016๋
1์ 1์ผ์ ๊ธ์์ผ์
๋๋ค. 2016๋
a์ b์ผ์ ๋ฌด์จ ์์ผ์ผ๊น์?
๋ ์ a ,b๋ฅผ ์
๋ ฅ๋ฐ์ 2016๋
a์ b์ผ์ด ๋ฌด์จ ์์ผ์ธ์ง ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์์ผ์ ์ด๋ฆ์ ์ผ์์ผ๋ถํฐ ํ ์์ผ๊น์ง ๊ฐ๊ฐ SUN,MON,TUE,WED,THU,FRI,SAT ์
๋๋ค.
์๋ฅผ ๋ค์ด a=5, b=24๋ผ๋ฉด 5์ 24์ผ์ ํ์์ผ์ด๋ฏ๋ก ๋ฌธ์์ด "TUE"๋ฅผ ๋ฐํํ์ธ์.
์ ํ ์กฐ๊ฑด
2016๋
์ ์ค๋
์
๋๋ค.
2016๋
a์ b์ผ์ ์ค์ ๋ก ์๋ ๋ ์
๋๋ค. (13์ 26์ผ์ด๋ 2์ 45์ผ๊ฐ์ ๋ ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค)
import java.time.LocalDate;
import java.time.DayOfWeek;
import java.time.format.TextStyle;
import java.util.Locale;
class Solution {
public String solution(int a, int b) {
LocalDate date = LocalDate.of(2016, a,b);
DayOfWeek dayOfWeek = date.getDayOfWeek();
return dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.US).toUpperCase();
}
}
- ๋ฐ๋ณต๋ฌธ, ์กฐ๊ฑด๋ฌธ ์๋๋๋ก ์ ์๊ณ , ๋ฌธ์ ํ ๋ฐฉ๋ฒ์ ๋ถ์ํด๋ณด์๋๋ฐ....? ๋ถ์์ด ์๋๋ค?
- ๋ฌธ์ ๋ฅผ ๊ฒ์ํ๊ณ , ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ๋ถ์์ ํ๋์ง... ์กฐ๊ธํ ๋ง์์ผ๋ก ์ฐพ์๋ณด์๋ค.
- ๊ฐ์ด ์ผ์ ,, ์์ ์ด๋์ ์ด๋ป๊ฒ...? ๋์ผํ๋์ง 1๋ ๋ชจ๋ฅด๊ฒ ๋ค.
- ํ์ด๋ฅผ ๋ณด๊ณ ํ์ด๋ฅผ ํด์ํ๋ คํ๋ค. ํ์๋ค์๊ฒ ๋ฌธ์ ํ์ด๋ฅผ ํด์ผํ๋,, ์์ฐธ!
- ๋ด๊ฐ ์์์ผ ์ค๋ช ๋ ํด์ค ์ ์๊ฒ ๊ตฌ๋ ๋ฌธ์ ํ์ด ๊ณต๋ถ๋จผ์ ํด ๋ณด์ ์ถ์ด ๋ฌธ์ ํ์ด๋ณธ์ ๋ณด๊ณ ํด์์ ํ๋ค.
LocalDate : ๋ ์ง ์ ๋ณด ์ถ๋ ฅ
ex) LocalDate currentDate = LocalDate.now(); 2022-07-16
DayOfWeek : ์์์ผ, ํ์์ผ, ์์์ผ, ๋ชฉ์์ผ, ๊ธ์์ผ, ํ ์์ผ ๋ฐ ์ผ์์ผ์ 7 ์ผ์ ๋ํ๋ด๋ ์ด๊ฑฐ ํ.
1 2 3 4 5 6 7
date.getDayOfWeek();
์์ผ์ ํํํ๋ DayOfWeek Enum์ ๊ฐ์ ธ์ด
DayOfWeek Enum ์ผ๋ก ์์ผ์ ๊ตฌํจ.
Enum : ์ด๊ฑฐํ = ๊ด๋ จ์ด ์๋ ์์๋ค์ ์งํฉ(ex. Day, Month)
dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.US).toUpperCase();
DayOfWeek ํด๋์ค์ getDisplayName() ๋ฉ์๋๋ ์์ผ์ ํ
์คํธ๋ก ๋ฆฌํด.
TextStyle = ๋ณด์ฌ์ค ์์ผ์ ๋ํ ํ์
TextStyle.Full ์์ผ์ ํ๋ค์ ex. Sunday -> Sunday
TextStyle.NARROW ์์ผ ์๊ธ์ ํ๋ Sunday -> S
TextStyle.SHORT ์์ผ ์ค์๋ง Sunday -> Sun
Locale.US -> ๊ตญ๊ฐ์ธ์ด์ค์ ์ US (United State) ์์ด๋ก ์ถ๋ ฅ๋ฐ๊ฒ ๋ค.
toUpperCase(); -> ๋์ํ์ผ๋ก ํด์ํ์๋ฉด ๋๊ฒ ๋๋ฐ ์๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ณํ.
ex) toRowerCase -> ๋ฎ์ถคํ์ผ๋ก,, ๋๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ณํ.
์๋จ์ด ๋๋์ผ๋ก ์ชผ๊ฐ์ ์๋ฏธ๋ฅผ ์ฐพ์๋ณด์๋๋ฐ ์ฝ๋์ ๋ด์ฉ์ด ๋ณด์ด๊ณ ๋ฌธ์ ๊ฐ ๋ณด์๋ค.
์ด๊ฒ ๋ต์ ์๋์ง๋ง ์ด๋ ๊ฒ ํ๋ฒ์ฏค ํด๋ณด๋ ๊ฒ๋ ๋๋ก ๊ณต๋ถํ๋ ๋ฐฉ๋ฒ์ด ๋ ์๋ ์๊ฒ ๊ตฌ๋.์๊ฒ๋ฌ๊ณ
๋ฌธ์ ๋ฅผ ์๊ณ ํด์๋ณธ์ ํด์ํ๋ ์ดํด๊ฐ ์ ๋์ง ์๋๊ฐ? ์์ฝ๋ฉ 3๋ฒ ๋์ด์ผ ๋ณด์๋ค.
๋ค์ ๋ฒ ๋น์ทํ ๋ฌธ์ ๊ฐ ๋์จ๋ค๋ฉด ์ค๋์ ๊ธฐ์ตํ๊ณ ํ์ด๋ณผ ์ ์์ ๊ฒ ๊ฐ๋ค. ํ์ง ๋ชปํ๋๋,
๊ตฌ๊ธ๋ง์ผ๋ก ์ถฉ๋ถํ ํ์ด๋ณผ ์ ์์ง ์์๊น ์๊ฐํ๋ค.
๋ฌธ์์ด s์ ๊ธธ์ด๊ฐ 4 ํน์ 6์ด๊ณ , ์ซ์๋ก๋ง ๊ตฌ์ฑ๋ผ์๋์ง ํ์ธํด์ฃผ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด s๊ฐ "a234"์ด๋ฉด False๋ฅผ ๋ฆฌํดํ๊ณ "1234"๋ผ๋ฉด True๋ฅผ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์ฌํญ: s๋ ๊ธธ์ด 1 ์ด์, ๊ธธ์ด 8 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
public boolean solution(String s) {
boolean answer = true;
String a = "a234";
String b = "1234";
String s = "1234";
for (int i = 0; i < length; i++) {
if (s.equals(a)) {
System.out.println("False");
} else (s.equals(b));
{
System.out.println(answer);
{
}
}
return answer;
}
}
}
public class Solution {
public boolean solution(String s) {
String s = "1234";
boolean isNumeric = StringUtils.isNumeric(s);
System.out.println(isNumeric);
s = "a234";
isNumeric = StringUtils.isNumeric(s);
System.out.println(isNumeric);
}
}
- ์ซ์์ ๋ฌธ์๊ฐ ์์ฌ ์๋ ๋ฉ์๋๋ฅผ ์ฐพ์๋ณด์๋ค matches()๋ก ํ์๋๋ฐ 2๊ฐ ์ค ํ๋๊ฐ ์๊พธ ์คํจ๋ก ๋ฌ๋ค.
- ๋ฌด์์ด ๋ฌธ์ ์ธ๊ณ ,,, ์ปดํ์ผ์ ๋ฌธ์ ๋ผ๊ณ ๋ง ๋์จ๋ค.. ์ด๊ฒ๋ง ํด๊ฒฐํ๋ฉด ํต๊ณผ๊ฐ ๋ ๊ฒ ๊ฐ์๋ฐ,,
- ์์ ํ๊ณ ์์ ํ๋ค ์ฝ๋๊ฐ ์๋ง์ด ๋์๊ณ ์ด๊ธฐํํ๋ค...ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ
- ๊ทธ๋ ์ ๋ฌ๋ค ์๋ก ์ฝ๋ ์ง๋ณด์ ์ถ์ด ํด๋์ค, ๋ฉ์๋๋ฅผ ์๋ก ์ฐพ์๋ณด์๊ณ ๊ตฌ๊ธ์์ ๊ฐ์ ธ๋ค๊ฐ
- ์ผ๋จ ์ ์ด๋ณด์๋๋ฐ ์๊ฐ ์ธ๋ก ๋ฌธ๋ฒ์ด ์ ์์ฑ์ด ๋์๋ค. ๊ฐ์ด ์ข ์จ๊ฑด๊ฐ?ใ ใ ใ ใ ใ ใ
- ์์ฝ๋ฉ์ ์ฃ์ผํ๋ ๋จธ๋ฆฌ๊ฐ ๋ฉํด์ง๋ค....
- ์๋ฌ๋ง ๋๊ณ ๋ด์ผ ๋ง์ ํด๊ฒฐํด์ผ๊ฒ ๋ค.
Solution.java:6: error: variable s is already defined in method solution(String)
String s = "1234";
^
/Solution.java:7: error: cannot find symbol
boolean isNumeric = StringUtils.isNumeric(s);
^
symbol: variable StringUtils
location: class Solution
/Solution.java:10: error: cannot find symbol
isNumeric = StringUtils.isNumeric(s);
^
symbol: variable StringUtils
location: class Solution
4 errors
๋ฌธ์ ์ค๋ช ๋ฌธ์์ด s๋ ํ ๊ฐ ์ด์์ ๋จ์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด๋ ํ๋ ์ด์์ ๊ณต๋ฐฑ๋ฌธ์๋ก ๊ตฌ๋ถ๋์ด ์์ต๋๋ค. ๊ฐ ๋จ์ด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก, ํ์๋ฒ์งธ ์ํ๋ฒณ์ ์๋ฌธ์๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์ ํ ์ฌํญ ๋ฌธ์์ด ์ ์ฒด์ ์ง/ํ์ ์ธ๋ฑ์ค๊ฐ ์๋๋ผ, ๋จ์ด(๊ณต๋ฐฑ์ ๊ธฐ์ค)๋ณ๋ก ์ง/ํ์ ์ธ๋ฑ์ค๋ฅผ ํ๋จํด์ผํฉ๋๋ค. ์ฒซ ๋ฒ์งธ ๊ธ์๋ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ก ๋ณด์ ์ง์๋ฒ์งธ ์ํ๋ฒณ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค.
import java.util.Arrays; class Solution { public String solution(String s) { String answer = "";
String[] str = s.split(""); // s๋ฅผ ํ๋์ฉ ์ฝ์ด์ค๊ธฐ ์ํด ๋ฐฐ์ด์ s๋ฅผ ๋ฃ์.
int idx = 0; //index๋ฒํธ ์ด๊ธฐํ(๋์ด์ฐ๊ธฐ๋ง๋ค ์ธ๋ฑ์ค๋ฅผ ์ด๊ธฐํํด์ผํด์ idx๋ณ์ ๋ง๋ฆ.)
}
for (int i = 0; i < str.length; i++) {
if (str.equals(" ")) { //String์ == ์ฌ์ฉ์ null ์ฐธ์กฐ์ค๋ฅ ๋ฐ์ํ ์ ์์ด์ equals๋ก ๋น๊ตํด์ ๊ณต๋ฐฑ์ ์ฐพ๊ณ ๊ณต๋ฐฑ์ idx = 0 ์ด๊ธฐํํ๋ค.
idx = 0;
else if (idx % 2 == 0) {
str[i] = str[i].toUpperCase(); //๋๋จธ์ง๊ฐ 0์ด๋ฉด ๋๋ฌธ์๋ก ๋ฐ๊ฟ์ฃผ๊ณ ์ฆ๊ฐ์์ผ
idx++;
}
else if(idx % 2 != 0) {
str[i] = str[i].toLowerCase(); //๋๋จธ์ง๊ฐ 0์ด ์๋๋ผ๋ฉด ์๋ฌธ์๋ก ๋ฐ๊ฟ์ฃผ๊ณ ์ฆ๊ฐ์์ผ
idx++;
}
// idx๊ฐ ์ง์์ด๋ฉด toUpperCase(); ํจ์๋ก ๋๋ฌธ์๋ก ๋ณ๊ฒฝํ๊ณ // idx๊ฐ ํ์์ด๋ฉด toLowerCase(); ํจ์๋ก ์๋ฌธ์๋ก ๋ณ๊ฒฝ์์ผ์ค. // ์ดํ idx๋ฅผ ์ฆ๊ฐ์์ผ ๋์ด์ฐ๊ธฐ ์ดํ ํ, ์ง์ ๋น๊ต.
answer += str[i];
} // for๋ฌธ ๋ฃจํ๊ฐ ํ๋ฒ์ ๋๊ธฐ ์ ๋ง๋ค str[i]๋ฅผ answer ์ ์ ์ฉ.
return answer;
}
// ์ด๋ฐ์์ผ๋ก ๊ณ์ ๋ฃจํ๊ฐ ๋๋ฉด ๋ฌธ์ ์์ ๋ฌธ์๊ฐ answer์ ์ ์ฅ๋๊ณ answer์ return. }
๋ฌธ์ ์ค๋ช ํจ์ solution์ ์ ์ n์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค. n์ ๊ฐ ์๋ฆฟ์๋ฅผ ํฐ๊ฒ๋ถํฐ ์์ ์์ผ๋ก ์ ๋ ฌํ ์๋ก์ด ์ ์๋ฅผ ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 118372๋ฉด 873211์ ๋ฆฌํดํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์กฐ๊ฑด n์ 1์ด์ 8000000000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
import java.util.*;
class Solution { public long solution(long n) { long answer = 0;
String[] arrStr = Long.toString(n).split("");
//๋ด๋ฆผ์ฐจ์ํ๊ธฐ์ํด์๋ ๋ฐฐ์ด์ ์ด์ฉํฉ๋๋ค. //๋ฐฐ์ด์ ์ด์ฉํ๊ธฐ ์ํด์๋ ์ ์์ long type->String(๋ฌธ์์ด)->String[] ๋ฌธ์๋ฐฐ์ด => Long->String->String[] // [1,1,8,3,7,2]
Arrays.sort(arrStr, Collections.reverseOrder());
//๋ฐฐ์ด๋ก ๋ด๋ฆผ์ฐจ์์ ๋ง๋ค์ด์ค๋ค ์ด ๋จ๊ณ๋ [8,7,3,2,1,1] ๊ฒ์:Arrays ๋ฉ์๋ ->Arrays.sort(a, Collections.reverseOrder());
return Long.parseLong(String.join("", arrStr));
// String์ ๋ฐฐ์ด์ด์๋ ๊ฒ์ ์๋๋๋ก์ Long type๋ก ๋ณต๊ตฌ์ํค๋ ์์ . -> Long.parseLong() // String.join("", arrStr)์ String = ๋ฐฐ์ด๋ก ๋ง๋๋๋ผ ๋ฒ๋ ค๋์ ๋ฌธ์์ด<=>split
}
}
//220716SAT-------------------------------------------------------------------------------------------------------------------------- //Arrays.sort() ์ฝํ ์ ์์ฃผ ๋์ค๋ ์ ํ!!!!
๋ฌธ์ ์ค๋ช 2016๋ 1์ 1์ผ์ ๊ธ์์ผ์ ๋๋ค. 2016๋ a์ b์ผ์ ๋ฌด์จ ์์ผ์ผ๊น์? ๋ ์ a ,b๋ฅผ ์ ๋ ฅ๋ฐ์ 2016๋ a์ b์ผ์ด ๋ฌด์จ ์์ผ์ธ์ง ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์์ผ์ ์ด๋ฆ์ ์ผ์์ผ๋ถํฐ ํ ์์ผ๊น์ง ๊ฐ๊ฐ SUN,MON,TUE,WED,THU,FRI,SAT ์ ๋๋ค. ์๋ฅผ ๋ค์ด a=5, b=24๋ผ๋ฉด 5์ 24์ผ์ ํ์์ผ์ด๋ฏ๋ก ๋ฌธ์์ด "TUE"๋ฅผ ๋ฐํํ์ธ์.
์ ํ ์กฐ๊ฑด 2016๋ ์ ์ค๋ ์ ๋๋ค. 2016๋ a์ b์ผ์ ์ค์ ๋ก ์๋ ๋ ์ ๋๋ค. (13์ 26์ผ์ด๋ 2์ 45์ผ๊ฐ์ ๋ ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค)
import java.time.LocalDate; import java.time.DayOfWeek; import java.time.format.TextStyle; import java.util.Locale;
class Solution { public String solution(int a, int b) { LocalDate date = LocalDate.of(2016, a,b); DayOfWeek dayOfWeek = date.getDayOfWeek(); return dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.US).toUpperCase(); } }
//๋ฐ๋ณต๋ฌธ, ์กฐ๊ฑด๋ฌธ ์๋๋๋ก ์ ์๊ณ , ๋ฌธ์ ํ ๋ฐฉ๋ฒ์ ๋ถ์ํด๋ณด์๋๋ฐ....? ๋ถ์์ด ์๋๋ค? //๋ฌธ์ ๋ฅผ ๊ฒ์ํ๊ณ , ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ๋ถ์์ ํ๋์ง... ์กฐ๊ธํ ๋ง์์ผ๋ก ์ฐพ์๋ณด์๋ค. //๊ฐ์ด ์ผ์ ,, ์์ ์ด๋์ ์ด๋ป๊ฒ...? ๋์ผํ๋์ง 1๋ ๋ชจ๋ฅด๊ฒ ๋ค. //ํ์ด๋ฅผ ๋ณด๊ณ ํ์ด๋ฅผ ํด์ํ๋ คํ๋ค. ํ์๋ค์๊ฒ ๋ฌธ์ ํ์ด๋ฅผ ํด์ผํ๋,, ์์ฐธ! //๋ด๊ฐ ์์์ผ ์ค๋ช ๋ ํด์ค ์ ์๊ฒ ๊ตฌ๋ ๋ฌธ์ ํ์ด ๊ณต๋ถ๋จผ์ ํด ๋ณด์ ์ถ์ด ๋ฌธ์ ํ์ด๋ณธ์ ๋ณด๊ณ ํด์์ ํ๋ค.
// LocalDate : ๋ ์ง ์ ๋ณด ์ถ๋ ฅ // ex) LocalDate currentDate = LocalDate.now(); 2022-07-16 // // DayOfWeek : ์์์ผ, ํ์์ผ, ์์์ผ, ๋ชฉ์์ผ, ๊ธ์์ผ, ํ ์์ผ ๋ฐ ์ผ์์ผ์ 7 ์ผ์ ๋ํ๋ด๋ ์ด๊ฑฐ ํ. // 1 2 3 4 5 6 7 // // date.getDayOfWeek(); // ์์ผ์ ํํํ๋ DayOfWeek Enum์ ๊ฐ์ ธ์ด // DayOfWeek Enum ์ผ๋ก ์์ผ์ ๊ตฌํจ. // Enum : ์ด๊ฑฐํ = ๊ด๋ จ์ด ์๋ ์์๋ค์ ์งํฉ(ex. Day, Month) // // dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.US).toUpperCase(); // // DayOfWeek ํด๋์ค์ getDisplayName() ๋ฉ์๋๋ ์์ผ์ ํ ์คํธ๋ก ๋ฆฌํด. // // TextStyle = ๋ณด์ฌ์ค ์์ผ์ ๋ํ ํ์ // TextStyle.Full ์์ผ์ ํ๋ค์ ex. Sunday -> Sunday // TextStyle.NARROW ์์ผ ์๊ธ์ ํ๋ Sunday -> S // TextStyle.SHORT ์์ผ ์ค์๋ง Sunday -> Sun // // Locale.US -> ๊ตญ๊ฐ์ธ์ด์ค์ ์ US (United State) ์์ด๋ก ์ถ๋ ฅ๋ฐ๊ฒ ๋ค. // // toUpperCase(); -> ๋์ํ์ผ๋ก ํด์ํ์๋ฉด ๋๊ฒ ๋๋ฐ ์๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ณํ. // ex) toRowerCase -> ๋ฎ์ถคํ์ผ๋ก,, ๋๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ณํ.
// ์๋จ์ด ๋๋์ผ๋ก ์ชผ๊ฐ์ ์๋ฏธ๋ฅผ ์ฐพ์๋ณด์๋๋ฐ ์ฝ๋์ ๋ด์ฉ์ด ๋ณด์ด๊ณ ๋ฌธ์ ๊ฐ ๋ณด์๋ค. // ์ด๊ฒ ๋ต์ ์๋์ง๋ง ์ด๋ ๊ฒ ํ๋ฒ์ฏค ํด๋ณด๋ ๊ฒ๋ ๋๋ก ๊ณต๋ถํ๋ ๋ฐฉ๋ฒ์ด ๋ ์๋ ์๊ฒ ๊ตฌ๋.์๊ฒ๋ฌ๊ณ // ๋ฌธ์ ๋ฅผ ์๊ณ ํด์๋ณธ์ ํด์ํ๋ ์ดํด๊ฐ ์ ๋์ง ์๋๊ฐ? ์์ฝ๋ฉ 3๋ฒ ๋์ด์ผ ๋ณด์๋ค. // ๋ค์ ๋ฒ ๋น์ทํ ๋ฌธ์ ๊ฐ ๋์จ๋ค๋ฉด ์ค๋์ ๊ธฐ์ตํ๊ณ ํ์ด๋ณผ ์ ์์ ๊ฒ ๊ฐ๋ค. ํ์ง ๋ชปํ๋๋, // ๊ตฌ๊ธ๋ง์ผ๋ก ์ถฉ๋ถํ ํ์ด๋ณผ ์ ์์ง ์์๊น ์๊ฐํ๋ค.
class Solution {
public boolean solution(String s) {
boolean answer = true;
String a = "a234";
String b = "1234";
String s = "1234";
for (int i = 0; i < length; i++) {
if (s.equals(a)) {
System.out.println("False");
} else (s.equals(b));
{
System.out.println(answer);
{
}
}
return answer;
}
}
}
------์์ ํ ์ฝ๋ฉ------- public class Solution { public boolean solution(String s) {
String s = "1234";
boolean isNumeric = StringUtils.isNumeric(s);
System.out.println(isNumeric);
s = "a234";
isNumeric = StringUtils.isNumeric(s);
System.out.println(isNumeric);
}
}
// ์ซ์์ ๋ฌธ์๊ฐ ์์ฌ ์๋ ๋ฉ์๋๋ฅผ ์ฐพ์๋ณด์๋ค matches()๋ก ํ์๋๋ฐ 2๊ฐ ์ค ํ๋๊ฐ ์๊พธ ์คํจ๋ก ๋ฌ๋ค. // ๋ฌด์์ด ๋ฌธ์ ์ธ๊ณ ,,, ์ปดํ์ผ์ ๋ฌธ์ ๋ผ๊ณ ๋ง ๋์จ๋ค.. ์ด๊ฒ๋ง ํด๊ฒฐํ๋ฉด ํต๊ณผ๊ฐ ๋ ๊ฒ ๊ฐ์๋ฐ,, // ์์ ํ๊ณ ์์ ํ๋ค ์ฝ๋๊ฐ ์๋ง์ด ๋์๊ณ ์ด๊ธฐํํ๋ค...ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ ใ // ๊ทธ๋ ์ ๋ฌ๋ค ์๋ก ์ฝ๋ ์ง๋ณด์ ์ถ์ด ํด๋์ค, ๋ฉ์๋๋ฅผ ์๋ก ์ฐพ์๋ณด์๊ณ ๊ตฌ๊ธ์์ ๊ฐ์ ธ๋ค๊ฐ // ์ผ๋จ ์ ์ด๋ณด์๋๋ฐ ์๊ฐ ์ธ๋ก ๋ฌธ๋ฒ์ด ์ ์์ฑ์ด ๋์๋ค. ๊ฐ์ด ์ข ์จ๊ฑด๊ฐ?ใ ใ ใ ใ ใ ใ // ์์ฝ๋ฉ์ ์ฃ์ผํ๋ ๋จธ๋ฆฌ๊ฐ ๋ฉํด์ง๋ค.... // ์๋ฌ๋ง ๋๊ณ ๋ด์ผ ๋ง์ ํด๊ฒฐํด์ผ๊ฒ ๋ค.
//Solution.java:6: error: variable s is already defined in method solution(String) // String s = "1234"; // ^ // /Solution.java:7: error: cannot find symbol // boolean isNumeric = StringUtils.isNumeric(s); // ^ // symbol: variable StringUtils // location: class Solution ///Solution.java:10: error: cannot find symbol // isNumeric = StringUtils.isNumeric(s); // ^ // symbol: variable StringUtils // location: class Solution //4 errors // //4๊ฐ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค. ๋จธ๋ฆฌ๊ฐ ๋ฉ์ถ์ด์ ๋ด์ผ ํด๊ฒฐํด์ผํ ๊ฒ ๊ฐ๋ค. //๋ํต์ด ์ด์ง ์จ๋ค.
// ใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ ก์ฌ์์ CODEใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ ก import org.apache.commons.lang3.StringUtils;
public class Solution {
public boolean solution(String s) {
boolean answer = true;
if (s.length() == 4 && s.length() == 6) {
answer = false;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) >= 'a') {
answer = false;
}
}
}
return answer;
}
}
// ์ฌ์์ CODE.. ///Solution.java:1: error: package org.apache.commons.lang3 does not exist // import org.apache.commons.lang3.StringUtils; // not solution !!!
// 220719 2์ฃผ์ฐจ //
// ํ๋ก๊ทธ๋๋จธ์ค ๋ชจ๋ฐ์ผ์ ๊ฐ์ธ์ ๋ณด ๋ณดํธ๋ฅผ ์ํด ๊ณ ์ง์๋ฅผ ๋ณด๋ผ ๋ ๊ณ ๊ฐ๋ค์ ์ ํ๋ฒํธ์ ์ผ๋ถ๋ฅผ ๊ฐ๋ฆฝ๋๋ค. // ์ ํ๋ฒํธ๊ฐ ๋ฌธ์์ด phone_number๋ก ์ฃผ์ด์ก์ ๋, // ์ ํ๋ฒํธ์ ๋ท 4์๋ฆฌ๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ซ์๋ฅผ ์ ๋ถ *์ผ๋ก ๊ฐ๋ฆฐ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. // // ์ ํ ์กฐ๊ฑด // phone_number๋ ๊ธธ์ด 4 ์ด์, 20์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
class Solution {
public String solution(String phone_number) {
String answer = "";
for (int i = 0; i < phone_number.length() -4; i++) {
answer += "*";
}
answer += phone_number.substring(phone_number.length() -4, phone_number.length());
return answer;
}
}
// for๋ฌธ์ ํตํด์ ๋ท 4์๋ฆฌ๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ฒํธ๋ฅผ answer์ *๋ก ๋ง๋ค์ด์ฃผ๊ณ
//substring() ๋ฉ์๋๋ก ๋ท 4์๋ฆฌ ๋ฒํธ๋ฅผ ๋ถ์๋ค. substring(a,b) : a~b๋ฒ์งธ ์ ๊น์ง ์๋ผ์ค / a=๋ ์์๊ฐ, b=์ข ๋ฃ๊ฐ //ใ กใ กใ กใ กใ ก๋ค ๋ฅธ ํ ์ดใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ กใ ก class Solution { public String solution(String phone_number) { return "*".repeat(phone_number.length() - 4) + phone_number.substring(phone_number.length() - 4); } } //repeat() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฐ๋ณต์ํ๋ค. // ๋ค์์ ๋ค์๋ฆฌ ์ซ์์ *์ ๋ํ๋ค.
//์ด๋ฐ๊ฒ๋ ์๊ตฌ๋ ๊ฐ์ ธ์ ๋ดค๋ค.
class Solution {
public String solution(String phone_number) {
return phone_number.replaceAll(".(?=.{4})", "*");
}
}
// ์์์ ์์ ์ ์ n์ ๋ํด, n์ด ์ด๋ค ์์ ์ ์ x์ ์ ๊ณฑ์ธ์ง ์๋์ง ํ๋จํ๋ ค ํฉ๋๋ค. // n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด๋ผ๋ฉด x+1์ ์ ๊ณฑ์ ๋ฆฌํดํ๊ณ , n์ด ์์ ์ ์ x์ ์ ๊ณฑ์ด ์๋๋ผ๋ฉด -1์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์์ฑํ์ธ์. // // ์ ํ ์ฌํญ // n์ 1์ด์, 50000000000000 ์ดํ์ธ ์์ ์ ์์ ๋๋ค.
class Solution { public long solution(long n) { long sqrRt = (long)Math.sqrt(n);
if (sqrRt * sqrRt == n) {
return (sqrRt + 1) * (sqrRt + 1);
}
else {
return -1;
}
}
}
// ๊ตฌ๊ธ๋ง์ ํตํด ์ ๊ณฑ๊ทผ pow(), sqrt()๋ฉ์๋๋ฅผ ์๊ฒ ๋ฌ๊ณ sqrt()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. // doubleํ ๊ฐ์ ์ ๊ณฑ๊ทผ ๊ฐ์ ๋ฐํํจ. // ex) System.out.println((int)Math.pow(5, 2)); -> 25 // System.out.println((int)Math.sqrt(25)); -> 5 // ๋ฌธ์ ์ค๋ช ์ ๋ถ์, ํด์, ์ชผ๊ฐ๊ณ ๋๋๋๊ฒ ์ค๋ ฅ ์ฐจ์ด์ธ ๊ฒ ๊ฐ๋ค. // ๋ฌธ์ ๋ฅผ ๋ถ์ํ๊ณ ์ชผ๊ฐ ๋๋๋ ๊ฒ ์์ง๋ ์ด๋ ต๋ค. // ํ์๋ค๊ณผ ์ํตํ๋ฉด์ ๋ฌธ์ ๋ฅผ ํด์ํ๊ณ ์ชผ๊ฐ ํ๋์ฉ ์์ฑํด๋๊ฐ๊ธฐ ์์ํ๊ณ , // ์๊ฐ๋ณด๋ค ์ฌ๋ฐ๊ณ ๋น ๋ฅด๊ฒ ํด๊ฒฐํด๋ณธ ๊ฒ ๊ฐ๋ค. // ๋ฌธ์ ๋ฅผ ๋ถ์ํ๋ ์ฐ์ต์ ๋ง์ด ํ๊ณ ๋ณด๋ ๊ฒ์ด ํ์ฌ ๋ฐฉ๋ฒ์ธ ๊ฒ ๊ฐ๋ค..!!!!
// ์ ์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด, arr ์์ ๊ฐ์ฅ ์์ ์๋ฅผ ์ ๊ฑฐํ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ๋จ, ๋ฆฌํดํ๋ ค๋ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ์ ๋ฐฐ์ด์ -1์ ์ฑ์ ๋ฆฌํดํ์ธ์. ์๋ฅผ๋ค์ด arr์ด [4,3,2,1]์ธ ๊ฒฝ์ฐ๋ [4,3,2]๋ฅผ ๋ฆฌํด ํ๊ณ , [10]๋ฉด [-1]์ ๋ฆฌํด ํฉ๋๋ค. // // ์ ํ ์กฐ๊ฑด // arr์ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค. // ์ธ๋ฑ์ค i, j์ ๋ํด i โ j์ด๋ฉด arr[i] โ arr[j] ์ ๋๋ค.
import java.util.ArrayList;
class Solution { public int[] solution(int[] arr) { int[] answer = {}; int[] arr = {4,3,2,1}; int min = arr[0]; for (int num : arr) if(max > min) {
min = num;
}
return answer;
}
}
์๋ฐํ ํ์ด์ฌ ๋๋์ ๊ฐ๊ฒฐํ ๋ฐ๋ณตํ๋ ๋ฉ์๋๊ฐ ํ์๊ถ๊ธํด์ก๋ค. ๋ค์ํ ํ์ด๋ฅผ ๋ณด๋ฉฐ, ๋ฐฐ์๋ณด๊ณ ์ถ๊ณ , ์๊ณ ์ถ๊ณ , ๊ถ๊ธํด์ก๋ค. ์ด๋ ๊ฒ ๋ฐ๋ณตํ๋ ๋ฐฉ๋ฒ๋ ์์์ ์ข ๋ฅ๋ฅผ ๋์๊ฒ ๋จผ์ ๊ณต์ ํ๋ค.
String str = "abc";
String repeated = str.repeat(3);
repeated.equals("abcabcabc");
String str = "Hello";
System.out.println("repeat๋ฌธ : " + str.repeat(3));
String.prototype.repeat()
//repeat() ๋ฉ์๋๋ ๋ฌธ์์ด์ ์ฃผ์ด์ง ํ์๋งํผ ๋ฐ๋ณตํด ๋ถ์ธ ์๋ก์ด ๋ฌธ์์ด์ ๋ฐํ.
str.repeat(count);
//๊ตฌ๋ฌธ
String str = "abc";
String repeated = StringUtils.repeat(str, 3);
repeated.equals("abcabcabc");
// Commons Lang StringUtils.repeat ()
repeated = new String(new char[n]).replace("\0", s);
// n๋ฌธ์์ด์ ๋ฐ๋ณตํ๋ ค๋ ํ์๋ ์ด๋ ์ด๋ฉฐ ๋ฐ๋ณต ํ ๋ฌธ์์ด s์ ๋๋ค. // ๊ฐ์ ธ ์ค๊ธฐ ๋๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ํ์ํ์ง ์์ต๋๋ค.
String.format("%0" + n + "d", 0).replace("0", s);
// Java <= 7์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
String.join("", Collections.nCopies(n, s));
// java 8
"abc".repeat(12);
// Java 11 ์ด์์์๋ repeatโ(int count)this
StringUtils.repeat("abc", 12);
// ์ํ์น ์ฝ ๋ชฌ์ฆ
Strings.repeat("abc", 12);
// ๊ตฌ๊ธ ๊ตฌ์๋ฐ
System.out.println(String.join("", Collections.nCopies(100, "hello")));
// Java 8 String.join์ ๋ค์๊ณผ ๊ด๋ จํ์ฌ ๊น๋ํ ๋ฐฉ๋ฒ์ ์ ๊ณตํจ. Collections.nCopies.
repeated = String.format(String.format("%%%ds", n), " ").replace(" ",s);
// ํ์ค String ํจ์ ๋ง ์ฌ์ฉํ๊ณ ๋ช ์์ ์ธ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ง ์๋ ๋ฐฉ๋ฒ์ ์์ ๊ฐ๋ค.
Strings.repeat("-", 60);
// Apache Commons๊ฐ ์๋ Google Guava๋ฅผ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด, // Guava Strings ํด๋์ค์์ repeat ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
'abc'.repeat(-1); // RangeError
'abc'.repeat(0); // ''
'abc'.repeat(1); // 'abc'
'abc'.repeat(2); // 'abcabc'
'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)
'abc'.repeat(1/0); // RangeError
({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2);
// 'abcabc' (repeat() is a generic method)
// RangeError: ๋ฐ๋ณต ํ์๋ ์์ ์ ์์ฌ์ผ ํจ. // RangeError: ๋ฐ๋ณต ํ์๋ ๋ฌดํ๋๋ณด๋ค ์์์ผ ํ๋ฉฐ, ์ต๋ ๋ฌธ์์ด ํฌ๊ธฐ๋ฅผ ๋์ด์ ์๋จ.