์ฝ๋ฉ ๋ฌธ์ #2๐งฉ
18082 ๋จ์ด pythonchallengebeginnersjavascript
๋ด๊ฐ ์ด๋ฏธ ๋งํ ๋ฐ์ ๊ฐ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ ํ๋์ ๊ทผ์ก๊ณผ ๊ฐ์์ ๊ฐ๋ฐ์๋ก์ ์์ฃผ ์ฐ์ตํด์ผ ํฅ์์ํค๊ณ ์ฑ์ฅํ ์ ์๋ค.
2ํ์์ ๋๋ ๋ด๊ฐ ๊ฐ์ฅ ์ข์ํ๋ ์๊ณ ๋ฆฌ์ฆ ์ฌ์ดํธ์์ ํด๊ฒฐํ๊ธฐ ์ฌ์ด ๋ฌธ์ ๋ฅผ ๊ณจ๋๋ค.
์นดํ๋ก๊ทธ
๊ทธ ๊ณ ๋ฆฌ๋ฅผ ๊ตฌํ ์ ์๊ฒ ์?
๋ถํฐCodewars
๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ฒด์ธ ํ ์ด๋ธ๋ก ์์ํ๋ ๋ ธ๋๋ฅผ ์ป์ ์ ์์ต๋๋ค.์ด ๋ชฉ๋ก์ ํญ์ ๊ผฌ๋ฆฌ์ ์ํ์ ํฌํจํฉ๋๋ค.
๋์ ๋ชฉํ๋ ์ํ์ ๊ธธ์ด๋ฅผ ํ์ ํ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด ๋ค์ ๊ทธ๋ฆผ์์ ๊ผฌ๋ฆฌ์ ํฌ๊ธฐ๋ 3์ด๊ณ ๊ณ ๋ฆฌ์ ํฌ๊ธฐ๋ 11์ด๋ค.
"next"์์ฑ์ ์ฌ์ฉํ์ฌ ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
์ฃผ์: ๋ ธ๋๋ฅผ ๋ณ์ดํ์ง ๋ง์ธ์!
๋ด ์๋ฃจ์ :
function loop_size(node){
let turtle = node;
let rabbit = node;
/* We need the turtle and the rabbit to start at the same
place. (The rabbit being faster will catch up the turtle at
some point) */
do {
turtle = turtle.getNext();
rabbit = rabbit.getNext().getNext();
} while (turtle !== rabbit)
/* The rabbit goes for a run and we know that ends when he
reaches the turtle position again. */
let counter = 0;
do {
rabbit = rabbit.getNext();
counter++;
} while (turtle !== rabbit)
return counter;
}
๋ชจ์ค ๋ถํธ
๋ถํฐCodewars
๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ด ์นดํ์์, ๋๋ ๊ฐ๋จํ ๋ชจ์ค ๋์ฝ๋๋ฅผ ์์ฑํด์ผ ํ๋ค.๋ชจ์ค ์ฝ๋๋ ํ์ฌ ์ฃผ๋ก ์์ฑ๊ณผ ๋์งํธ ๋ฐ์ดํฐ ํต์ ์ฑ๋๋ก ๋์ฒด๋๊ณ ์์ง๋ง, ์ฌ์ ํ ์ธ๊ณ ๊ฐ์ง์ ์ผ๋ถ ์์ฉ์์ ์ฌ์ฉ๋๊ณ ์๋ค.
๋ชจ์ค ์ฝ๋๋ ๋ชจ๋ ๋ฌธ์๋ฅผ ์ผ๋ จ์ '์ ' ๊ณผ '๋์' ๋ก ์ธ์ฝ๋ฉํ๋ค.์๋ฅผ ๋ค์ด, ๋ฌธ์ A๋ ยท๋ก ์ธ์ฝ๋ฉ๋ฉ๋๋ค.โ, ๋ฌธ์ Q ์ธ์ฝ๋ฉโโยทโ, ์ซ์ 1์ด ยท๋ก ์ธ์ฝ๋ฉ๋จโโโโ. ๋ชจ์ค ์ฝ๋๋ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์๊ณ ์ ํต์ ์ผ๋ก ๋๋ฌธ์๋ฅผ ์ฌ์ฉํ๋ค.์ ๋ณด๋ฅผ ๋ชจ์ค ์ฝ๋๋ก ์ธ ๋, ํ ๊ฐ์ ๋น์นธ์ ๋ฌธ์ ์ฝ๋๋ฅผ ๊ตฌ๋ถํ๋ ๋ฐ ์ฌ์ฉ๋๊ณ , ์ธ ๊ฐ์ ๋น์นธ์ ๋จ์ด๋ฅผ ๊ตฌ๋ถํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
์ฃผ์: ์ฝ๋์ ์๋ค ์ถ๊ฐ ๋น์นธ์ ์๋ฏธ๊ฐ ์์ต๋๋ค. ๋ฌด์ํด์ผ ํฉ๋๋ค.
์ํ๋ฒณ, ์ซ์์ ์ผ๋ถ ๋ฌธ์ฅ๋ถํธ๋ฅผ ์ ์ธํ๊ณ ํน์ํ ์๋น์ค ์ฝ๋๋ ์๋ค. ๊ทธ ์ค์์ ๊ฐ์ฅ ์ ๋ช ๋์ ๊ฒ์ ๊ตญ์ ์กฐ๋ ์ ํธ SOS(์ต์ด๋ก ํ์ดํ๋ ํธ์ ์ํด ๋ฐํ), ์ฝ๋๋ ยทยทยทยทยทโโโยทยทยท. ์ด ํน์ ์ฝ๋๋ค์ ๋ณดํต ๋จ๋ ๋ฌธ์๋ก ์ ์ก๋๋ ๋จ์ผ ํน์ ๋ฌธ์๋ก ์ฌ๊ฒจ์ง๋ค.
๋ชจ์ด์ค ์ฝ๋๋ฅผ ์ ๋ ฅ์ผ๋ก ํ๊ณ ๋์ฝ๋ฉ๋ ์ธ๊ฐ์ด ์ฝ์ ์ ์๋ ๋ฌธ์์ด์ ๋๋๋ ค ์ฃผ๋ ํจ์๋ฅผ ์คํํ๋ ๊ฒ์ด ๋น์ ์ ์๋ฌด์ ๋๋ค.
์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
decodeMorse('.... . -.-- .--- ..- -.. .')
#should return "HEY JUDE"
์ฐธ๊ณ : ์ธ์ฝ๋ฉ์ ์ํด ASCII ๋ฌธ์๋ฅผ ์ฌ์ฉํด์ผ ํฉ๋๋ค.๋ฐ - ๋ ์ ๋์ฝ๋ ๋ฌธ์๊ฐ ์๋๋๋ค.๋ชจ์ค ์ฝ๋๋ ์ฌ์ ์ผ๋ก ๋ฏธ๋ฆฌ ๋ถ๋ฌ์ต๋๋ค. ๋ง์๋๋ก ์ฌ์ฉํ์ญ์์ค.
JavaScript/TypeScript: MORSE ์ฝ๋ ['--']
๋ด ์๋ฃจ์ :
const decodeMorse = (morseCode) => {
const response = [];
const words = morseCode.trim().split(' ');
for (const word of words) {
const wordArr = [];
for (const letter of word.split(' ')) {
wordArr.push(MORSE_CODE[letter]);
}
response.push(wordArr.join(''))
}
return response.join(' ');
}
์ง์ฌ๊ฐํ์ด ์ ์ฌ๊ฐํ์ผ๋ก ๋ณํ๋ค
๋ถํฐCodewars
๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ค์ ๊ทธ๋ฆผ์ ์ฃผ์ด์ง '์ง' ์ฌ๊ฐํ์ ์ด๋ป๊ฒ ์ ์ฌ๊ฐํ์ผ๋ก ์๋ฅด๋์ง ๋ณด์ฌ ์ค๋ค. ('์ง' ์ฌ๊ฐํ์ ๋ ์ฐจ์์ด ๋ค๋ฅด๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค.)
๋๋ ์ด ๊ทธ๋ฆผ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ฒ์ญํ ์ ์๋?
๋๋ ๋ ๊ฐ์ง ์ฐจ์์ ์ป๊ฒ ๋ ๊ฒ์ด๋ค
์:
sqInRect(5, 3) should return "3 2 1 1"
sqInRect(3, 5) should return "3 2 1 1"
๋ด ์๋ฃจ์
:function sqInRect(lng, wdth){
console.log(lng, wdth);
if (lng === wdth) { return null; }
let lngx = lng;
let wdthx = wdth;
let area = lng * wdth;
let result = [];
while (area > 0) {
if (lngx > wdthx) {
area -= Math.pow(wdthx, 2);
result.push(wdthx);
lngx = lngx - wdthx;
} else {
area -= Math.pow(lngx, 2);
result.push(lngx);
wdthx = wdthx - lngx;
}
}
return result;
}
๋ฉดํ
๋ถํฐCodewars
๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์กด์ ๋ช๋ช ์น๊ตฌ๋ค์ ์ด๋ํ๋ค.๊ทธ์ ๋ช ๋จ์:
s = "Fred:Corwill;Wilfred:Corwill;Barney:Tornbull;Betty:Tornbull;Bjon:Tornbull;Raphael:Corwill;Alfred:Corwill";
๋๋ ์ด๋ฐ ํ๋ก๊ทธ๋จ์ ๋ง๋ค ์ ์๋๋ฐ๋ผ์ ๊ธฐ๋ฅ ํ์์ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
"(CORWILL, ALFRED)(CORWILL, FRED)(CORWILL, RAPHAEL)(CORWILL, WILFRED)(TORNBULL, BARNEY)(TORNBULL, BETTY)(TORNBULL, BJON)"
๊ฐ์ ์ฑ์ ๊ฐ์ง ๋ ๊ฐ์กฑ ์ค ๋ ์ฌ๋์ ์ด๋ฆ๋ ๊ฐ์ ์ ์๋ค.๋ด ์๋ฃจ์ (Python):
def meeting(s):
result = ""
# Convert string to list
names_list = s.upper().split(";")
# Create a dictionnary and bind a list of first names to every last names
names_dic = {}
for name in names_list:
first_name = name.split(":")[0]
last_name = name.split(":")[1]
if last_name in names_dic: names_dic[last_name].append(first_name)
else: names_dic[last_name] = [first_name]
# Sort and add every entry to the result string
for key in sorted(names_dic):
for first_name in sorted(names_dic[key]):
result = result + f"({key}, {first_name})"
return result
๋์งํธ ๊ฒ์์ ํ๋ค
๋ถํฐCodewars
๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ด๋ค ์ซ์๋ค์ ์ฌ๋ฏธ์๋ ์ฑ์ง์ ๊ฐ์ง๊ณ ์๋ค.์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
89 --> 8ยน + 9ยฒ = 89 * 1
695 --> 6ยฒ + 9ยณ + 5โด= 1390 = 695 * 2
46288 --> 4ยณ + 6โด+ 2โต + 8โถ + 8โท = 2360688 = 46288 * 51
abcd๋ก ์ฐ์ธ ์ ์ n์ ์ง์ ํฉ๋๋ค.(a, b, c, d...๋ ์ซ์) ๋ฐ ์ ์ p
์ฐ๋ฆฌ๋ n์ ์ซ์์ p์ ์ฐ์ ๋ฉฑ์ ํฉ์ด k*n๊ณผ ๊ฐ์ ์ ์ k๋ฅผ ์ฐพ๊ณ ์ถ๋ค.
๋ค์ ๋งํ๋ฉด
์๋ฅผ ๋ค์ด (a^p+b^(p+1)+c^(p+2)+d^(p+3)+d^(p+3)+...) =n*k
๋ง์ฝ ๊ทธ๋ ๋ค๋ฉด, ์ฐ๋ฆฌ๋ k๋ก ๋์๊ฐ ๊ฒ์ด๋ค. ๋ง์ฝ -1๋ก ๋์๊ฐ์ง ์๋๋ค๋ฉด.
์ฃผ: n๊ณผ p๋ ์์ข ์๊ฒฉํ ์ ์๋ก ์ ์๋ ๊ฒ์ด๋ค.
dig_pow(89, 1) should return 1 since 8ยน + 9ยฒ = 89 = 89 * 1
dig_pow(92, 1) should return -1 since there is no k such as 9ยน + 2ยฒ equals 92 * k
dig_pow(695, 2) should return 2 since 6ยฒ + 9ยณ + 5โด= 1390 = 695 * 2
dig_pow(46288, 3) should return 51 since 4ยณ + 6โด+ 2โต + 8โถ + 8โท = 2360688 = 46288 * 51
๋ด ์๋ฃจ์
:function digPow(n, p){
if(!n || !p){
return -1;
}
let digitArray = n.toString().split("");
let sun = 0;
for(let i = 0; i<digitArray.length; i++){
sun += Math.pow(digitArray[i], p+i);
}
if(parseInt(sun/n) === sun/n){
return sun/n;
}
else{
return -1;
}
}
Reference
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(์ฝ๋ฉ ๋ฌธ์ #2๐งฉ), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://dev.to/killianfrappartdev/coding-challenges-2-1bmpํ ์คํธ๋ฅผ ์์ ๋กญ๊ฒ ๊ณต์ ํ๊ฑฐ๋ ๋ณต์ฌํ ์ ์์ต๋๋ค.ํ์ง๋ง ์ด ๋ฌธ์์ URL์ ์ฐธ์กฐ URL๋ก ๋จ๊ฒจ ๋์ญ์์ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค