본문으로 건너뛰기

· 약 3분
karais89

Instructions

링크

Your task is to Combine two Strings. But consider the rule...

By the way you don't have to check errors or incorrect input values, every thing is ok without bad tricks, only two input strings and as result one output string;-)...

And here's the rule: Input Strings 'a' and 'b': For every character in string 'a' swap the casing of every occurance of the same character in string 'b'. Then do the same casing swap with the inputs reversed. Return a single string consisting of the changed version of 'a' followed by the changed version of 'b'. A char of 'a' is in 'b' regardless if it's in upper or lower case - see the testcases too. I think that's all;-)...

Some easy examples:

Input: "abc" and "cde" => Output: "abCCde"
Input: "abab" and "bababa" => Output: "ABABbababa"
Input: "ab" and "aba" => Output: "aBABA"

There are some static tests at the beginning and many random tests if you submit your solution.

Hope you have fun:-)!

My Solution

namespace smile67Kata
{
using System;
using System.Text;

public class Kata
{
public string SwapUpperOrLower(string a, string b)
{
StringBuilder aBuilder = new StringBuilder();
for (int i = 0; i < a.Length; i++)
{
int equalCnt = 0;
for (int j = 0; j < b.Length; j++)
{
if (char.ToUpper(a[i]) == char.ToUpper(b[j]))
{
equalCnt++;
}
}

char inChar = a[i];
if (equalCnt % 2 != 0)
{
inChar = char.IsLower(inChar) ? char.ToUpper(inChar) : char.ToLower(inChar);
}
aBuilder.Append(inChar);
}
return aBuilder.ToString();
}

public string workOnStrings(string a, string b)
{
// a, b
string newA = SwapUpperOrLower(a, b);

// b, a
string newB = SwapUpperOrLower(b, a);

return newA+newB;
}
}
}
  • a와 b에 대해서 문자열 a의 모든 문자에 대해 문자열 b에 있는 동일한 문자가 있을때 대소 문자를 바꾼다 스위칭 하면서 바꿔준다.
  • b도 똑같은 작업을 진행한다.
  • a+b를 합친후 리턴

Best Practices

namespace smile67Kata
{
using System;
using System.Linq;
public class Kata
{
public char needswitch(string s,char c){
return !(s.ToLower().Contains(char.ToLower(c))&&s.ToLower().Count(y=>y==char.ToLower(c))%2==1)
? c : c>96 ? char.ToUpper(c) : char.ToLower(c);
}
public string workOnStrings(string a, string b){
return string.Join("",a.Select(x=>needswitch(b,x))) + string.Join("",b.Select(x=>needswitch(a,x)));
}
}
}
  • Linq 사용
  • 아스키 코드 97 부터 소문자 a

· 약 5분
karais89

Instructions

링크

Short Intro

Some of you might remember spending afternoons playing Street Fighter 2 in some Arcade back in the 90s or emulating it nowadays with the numerous emulators for retro consoles.

Can you solve this kata? Suuure-You-Can!

UPDATE: a new kata's harder version is available here.

The Kata

You'll have to simulate the video game's character selection screen behaviour, more specifically the selection grid. Such screen looks like this:

Selection Grid Layout in text:

| Ryu | E.Honda | Blanka | Guile | Balrog | Vega |
| Ken | Chun Li | Zangief | Dhalsim | Sagat | M.Bison |

Input

  • the list of game characters in a 2x6 grid;
  • the initial position of the selection cursor (top-left is (0,0));
  • a list of moves of the selection cursor (which are up, down, left, right);

Output

  • the list of characters who have been hovered by the selection cursor after all the moves (ordered and with repetition, all the ones after a move, wether successful or not, see tests);

Rules

Selection cursor is circular horizontally but not vertically!

As you might remember from the game, the selection cursor rotates horizontally but not vertically; that means that if I'm in the leftmost and I try to go left again I'll get to the rightmost (examples: from Ryu to Vega, from Ken to M.Bison) and vice versa from rightmost to leftmost.

Instead, if I try to go further up from the upmost or further down from the downmost, I'll just stay where I am located (examples: you can't go lower than lowest row: Ken, Chun Li, Zangief, Dhalsim, Sagat and M.Bison in the above image; you can't go upper than highest row: Ryu, E.Honda, Blanka, Guile, Balrog and Vega in the above image).

Test

For this easy version the fighters grid layout and the initial position will always be the same in all tests, only the list of moves change.

Notice : changing some of the input data might not help you.

Examples

fighters = [
["Ryu", "E.Honda", "Blanka", "Guile", "Balrog", "Vega"],
["Ken", "Chun Li", "Zangief", "Dhalsim", "Sagat", "M.Bison"]
]
initial_position = (0,0)
moves = ['up', 'left', 'right', 'left', 'left']

then I should get:

['Ryu', 'Vega', 'Ryu', 'Vega', 'Balrog']

as the characters I've been hovering with the selection cursor during my moves. Notice: Ryu is the first just because it "fails" the first up See test cases for more examples.

fighters = [
["Ryu", "E.Honda", "Blanka", "Guile", "Balrog", "Vega"],
["Ken", "Chun Li", "Zangief", "Dhalsim", "Sagat", "M.Bison"]
]
initial_position = (0,0)
moves = ['right', 'down', 'left', 'left', 'left', 'left', 'right']

Result:

['E.Honda', 'Chun Li', 'Ken', 'M.Bison', 'Sagat', 'Dhalsim', 'Sagat']

OFF-TOPIC

Some music to get in the mood for this kata :

Street Fighter 2 - selection theme

My Solution

using System;
using System.Collections.Generic;
using System.Linq;

public class Kata
{
public string[] StreetFighterSelection(string[][] fighters, int[] position, string[] moves)
{
int col = fighters.Length;
int row = fighters[0].Length;

int curCol = position[0];
int curRow = position[1];

List<string> charTracking = new List<string>();
for (int i = 0; i < moves.Length; i++)
{
int moveCol;
int moveRow;
switch (moves[i])
{
case "up":
moveCol = curCol - 1;
if (moveCol >= 0)
{
curCol = moveCol;
}
break;
case "down":
moveCol = curCol + 1;
if (moveCol < col)
{
curCol = moveCol;
}
break;
case "left":
moveRow = curRow - 1;
curRow = moveRow < 0 ? row - 1 : moveRow;
break;
case "right":
moveRow = curRow + 1;
curRow = moveRow > row - 1 ? 0 : moveRow;
break;
}
charTracking.Add(fighters[curCol][curRow]);
}
return charTracking.ToArray();
}
}
  • 게임 캐릭터의 리스트는 2x6 그리드 이다.
  • 선택 커서의 초기 위치는 0,0 이다.
  • 선택 커서는 위, 아래, 좌, 우로 이동할 수 있다.
  • 커서의 순환은 (양 옆 혹은 위) 수평으로만 가능 하다.

Best Practices

using System;
using System.Collections.Generic;
using System.Linq;

public class Kata
{
public string[] StreetFighterSelection(string[][] fighters, int[] position, string[] moves)
{
var results = new List<string>();
var row = 0;
var col = 0;

foreach (var s in moves) {
switch (s) {
case "up": row -= 1;
break;
case "down": row += 1;
break;
case "left": col -= 1;
break;
case "right": col += 1;
break;
}
if (row < 0) row = 0;
if (row == fighters.Length) row--;
if (col == fighters[0].Length) col = 0;
if (col == -1) col = fighters[0].Length - 1;

results.Add(fighters[row][col]);
}

return results.ToArray();
}
}

거의 유사하지만, 범위 체크를 맨 아래에서 해주었다. 범위체크를 움직일때마다 해주는 것보다 맨 마지막에 해주는게 깔끔한 느낌도 든다.

· 약 3분
karais89

Instructions

링크

The input is a string str of digits. Cut the string into chunks (a chunk here is a substring of the initial string) of size sz (ignore the last chunk if its size is less than sz).

If a chunk represents an integer such as the sum of the cubes of its digits is divisible by 2, reverse that chunk; otherwise rotate it to the left by one position. Put together these modified chunks and return the result as a string.

If

  • sz is <= 0 or if str is empty return ""
  • sz is greater (>) than the length of str it is impossible to take a chunk of size sz hence return "".

Examples:

revrot("123456987654", 6) --> "234561876549"
revrot("123456987653", 6) --> "234561356789"
revrot("66443875", 4) --> "44668753"
revrot("66443875", 8) --> "64438756"
revrot("664438769", 8) --> "67834466"
revrot("123456779", 8) --> "23456771"
revrot("", 8) --> ""
revrot("123456779", 0) --> ""
revrot("563000655734469485", 4) --> "0365065073456944"

My Solution

using System;
using System.Text;
using System.Linq;

public class Revrot
{
public static string InternalRevRot(string str)
{
if (String.IsNullOrEmpty(str))
{
return string.Empty;
}

int sum = 0;
for (int i = 0; i < str.Length; i++)
{
sum += int.Parse(str[i].ToString());
}

StringBuilder strBuilder = new StringBuilder();
if (sum % 2 == 0)
{
for (int i = str.Length - 1; i >= 0; i--)
{
strBuilder.Append(str[i]);
}
return strBuilder.ToString();
}

for (int i = 1; i < str.Length; i++)
{
strBuilder.Append(str[i]);
}
strBuilder.Append(str[0]);
return strBuilder.ToString();
}

public static string RevRot(string strng, int sz)
{
if (sz <= 0 || String.IsNullOrEmpty(strng) || strng.Length < sz)
{
return string.Empty;
}

StringBuilder strBuilder = new StringBuilder();
for (int i = 0; i < strng.Length; i += sz)
{
if (i + sz < strng.Length)
{
string str = strng.Substring(i, sz);
strBuilder.Append(InternalRevRot(str));
}
}
return strBuilder.ToString();
}
}

일단 영어 해석이 안되서 헤맸다. 천천히 문제를 다시 읽어 봤다.

주어진 sz 매개변수 만큼 substring으로 문자열을 가르고 각각의 문자열의 합을 기준으로 다음과 같은 기준으로 판단

  1. 문자열의 총 합이 짝수이면 숫자 뒤집기. (1->2->3 순서일때 3->2->1)
  2. 문자열의 합이 홀수이면 왼쪽으로 한칸 이동시키기. (1->2->3 순서일때 2->3->1)

Best Practices

using System;
using System.Linq;

public class Revrot
{
public static string RevRot(string strng, int sz)
{
if (String.IsNullOrEmpty(strng) || sz <= 0 || sz > strng.Length)
return String.Empty;

return
new String(
Enumerable.Range(0, strng.Length/sz)
.Select(i => strng.Substring(i*sz, sz))
.Select(
chunk =>
chunk.Sum(digit => (int) Math.Pow(int.Parse(digit.ToString()), 3))%2 == 0
? chunk.Reverse()
: chunk.Skip(1).Concat(chunk.Take(1)))
.SelectMany(x => x)
.ToArray());
}
}

chunk.Reverse() 이 부분에 해당

      StringBuilder strBuilder = new StringBuilder();
if (sum % 2 == 0)
{
for (int i = str.Length - 1; i >= 0; i--)
{
strBuilder.Append(str[i]);
}
return strBuilder.ToString();
}

chunk.Skip(1).Concat(chunk.Take(1)) 이 부분에 해당

      for (int i = 1; i < str.Length; i++)
{
strBuilder.Append(str[i]);
}
strBuilder.Append(str[0]);
return strBuilder.ToString();

· 약 3분
karais89

Instructions

링크

Task Write a function that accepts msg string and returns local tops of string from the highest to the lowest. The string's tops are from displaying the string in the below way:

When the msg string is empty, return an empty string. The input strings may be very long. Make sure your solution has good performance. Check the test cases for more samples.

Note for C++ Do not post an issue in my solution without checking if your returned string doesn't have some invisible characters. You read most probably outside of msg string.

My Solution

using System;
using System.Text;
using System.Collections.Generic;

public static class Kata
{
public static string Tops(string msg)
{
if (string.IsNullOrEmpty(msg))
{
return string.Empty;
}

int switchCount = 0;
int addNum = 0;
int goalNum = 0;
List<int> topIndexs = new List<int>();
for (int i = 0; i < msg.Length; i++)
{
if (i == goalNum)
{
// switchCount is odd top index
if (switchCount % 2 == 1)
{
topIndexs.Add(i);
}
switchCount++;
addNum++;
goalNum += addNum;
}
}

StringBuilder strBuilder = new StringBuilder();
for (int i = topIndexs.Count - 1; i >= 0; i--)
{
strBuilder.Append(msg[topIndexs[i]]);
}

return strBuilder.ToString();
}
}

공통적으로 증가하는 수가 존재할 것 같다는 생각을 했는데 (수열) 찾지를 못해서, 그냥 가장 큰 수의 인덱스를 저장한 후에 스트링을 뿌려주는 방식으로 처리 하였다.

수열을 찾지 못한 이유는 중간에 계산 실수가 있었다.

Best Practices 1

using System.Text;

public static class Kata
{
public static string Tops(string msg)
{
StringBuilder result = new StringBuilder();

for(int i = 1, x = 0; i < msg.Length; i += 5 + 4 * x, x++)
result.Insert(0, msg[i]);

return result.ToString();
}
}

큰 수의 인덱스 배열 : 1 -> 6 -> 15 -> 28

차이 5, 9, 13

차이 : 5+(4*x) -> 5 -> 9 -> 13

으로 수열이 존재한다.

Best Practices 2

using System;
using System.Linq;
using System.Collections.Generic;


public static class Kata
{
public static string Tops(string msg)
{
int jump = 1;
Stack<char> result = new Stack<char>() { };
for (int i = 1; i < msg.Length; i += jump)
{
if (jump % 2 != 0)
result.Push(msg[i]);
jump += 1;
}
return String.Join("", result);
}

}

나와 생각한 방식은 거의 똑같은데, 훨씬 깔끔하게 처리 하였다.

일단 스트링을 뒤로 뿌려주는 부분을 스택을 통해 처리 하였다. 그리고 추가적으로 내 해결책에서 사용 하던 쓸데없는 변수도 사용하지 않았다.

· 약 2분
karais89

Instructions

Your task is to construct a building which will be a pile of n cubes. The cube at the bottom will have a volume of n^3, the cube above will have volume of (n-1)^3 and so on until the top which will have a volume of 1^3.

You are given the total volume m of the building. Being given m can you find the number n of cubes you will have to build?

The parameter of the function findNb (find_nb, find-nb, findNb) will be an integer m and you have to return the integer n such as n^3 + (n-1)^3 + ... + 1^3 = m if such a n exists or -1 if there is no such n.

Examples:

findNb(1071225) --> 45
findNb(91716553919377) --> -1
mov rdi, 1071225
call find_nb ; rax <-- 45

mov rdi, 91716553919377
call find_nb ; rax <-- -1

My Solution

def find_nb(m):
# your code
sum = 0
count = 0
while True:
count += 1
sum += count**3

if sum == m:
return count

if sum > m:
return -1

c#으로 똑같은 방법으로 풀었는데 테스트 케이스 몇 군데서 계속 에러가 나옴.

codewars 자체가 유저들이 문제를 직접 내고, 테스트 케이스를 작성을 하는 방식이라, 이런식으로 아예 통과를 못하는 경우가 있음.

그냥 넘어가려다가 그냥 파이썬으로 똑같은 방식으로 풀자! 해서 풀었음.

하다 보니 알게 된건 파이썬에서는 증감연산자가 없다는 사실.. (++, --)등

Best Practices

def find_nb(m):
n = 1
volume = 0
while volume < m:
volume += n**3
if volume == m:
return n
n += 1
return -1

거의 비슷한 방식이다.

· 약 2분
karais89

Instructions

Write a function, persistence, that takes in a positive parameter num and returns its multiplicative persistence, which is the number of times you must multiply the digits in num until you reach a single digit.

For example:

 persistence(39) == 3 // because 3*9 = 27, 2*7 = 14, 1*4=4
// and 4 has only one digit

persistence(999) == 4 // because 9*9*9 = 729, 7*2*9 = 126,
// 1*2*6 = 12, and finally 1*2 = 2

persistence(4) == 0 // because 4 is already a one-digit number

My Solution

using System;
using System.Collections.Generic;

public class Persist
{
public static long SumList(List<int> list)
{
long sum = 1;
foreach (int num in list)
{
sum *= num;
}
return sum;
}

public static bool CheckPersistenceList(List<int> list)
{
if (list.Count <= 1)
{
return false;
}

return true;
}

public static int RecusviePersistence(long n, int count)
{
List<int> toInts = new List<int>();
string strNum = n.ToString();
for (int i = 0; i < strNum.Length; i++)
{
toInts.Add(int.Parse(strNum[i].ToString()));
}

long sum = SumList(toInts);
Console.WriteLine("n: " + n + ", sum: " + sum);
if (CheckPersistenceList(toInts))
{
count++;
return RecusviePersistence(sum, count);
}
else
{
return count;
}
}

public static int Persistence(long n)
{
return RecusviePersistence(n, 0);
}
}

뭔가 쓸데 없이 길어지는 느낌..

Best Practices

using System;
using System.Linq;

public class Persist
{
public static int Persistence(long n)
{
int count = 0;
while (n > 9)
{
count++;
n = n.ToString().Select(digit => int.Parse(digit.ToString())).Aggregate((x, y) => x * y);
}
return count;
}
}

Linq 사용

· 약 4분
karais89

Instructions

Given an array of integers of any length, return an array that has 1 added to the value represented by the array.

  • the array can't be empty
  • only non-negative, single digit integers are allowed

Return nil (or your language's equivalent) for invalid inputs.

Examples

For example the array [2, 3, 9] equals 239, adding one would return the array [2, 4, 0].

[4, 3, 2, 5] would return [4, 3, 2, 6]

My Solution

using System;

namespace Kata
{
public static class Kata
{
public static int[] UpArray(int[] num)
{
// invaild check
if (num == null || num.Length == 0)
{
return null;
}

// invalid check
for (int i = 0; i < num.Length; i++)
{
if (num[i] < 0 || num[i] >= 10)
{
return null;
}
}

// array init
int[] arrayOnePlus = new int[num.Length];
for (int i = 0; i < arrayOnePlus.Length; i++)
{
arrayOnePlus[i] = num[i];
}

// one plus array
for (int i = num.Length - 1; i >= 0; i--)
{
int n = num[i] + 1;
if (n != 10)
{
arrayOnePlus[i] = n;
break;
}
else
{
arrayOnePlus[i] = 0;

// array size up..
if (i == 0)
{
int[] newArr = new int[arrayOnePlus.Length + 1];
newArr[0] = 1;
for (int j = 0; j < arrayOnePlus.Length; j++)
{
newArr[j+1] = arrayOnePlus[j];
}

return newArr;
}
}
}

return arrayOnePlus;
}
}
}

원래는 int 배열을 숫자로 바꾼후에 +1을 해주고 int 배열로 다시 만드는 방식으로 구현하려다, 그냥 배열 자체에 값을 구하는 식으로 구현 하였다.

  1. invaild 체크
  2. 인자로 전달 받은 배열을 새 배열에 복사
  3. 각 배열의 인덱스에 +1을 해준다. 그리고 만약 그 합이 10이 넘지 않으면 바로 새 배열의 값을 리턴.
  4. 만약 그 합이 10이 넘는다면 루프를 돌면서 10이 넘지 않을때 까지 반복한다.
  5. 마지막 배열까지 검사를 한 경우에도 10이 넘는 경우면 배열의 길이를 1 증가시켜줘야 되는 경우이므로 1을 증가 시켜준 후에 해당 배열을 다시 만들어 준다음에 리턴 해준다.

Best Practices

using System.Linq;

namespace Kata
{
public static class Kata
{
public static int[] UpArray(int[] num)
{
if (num.Length == 0 || num.Any(a => a < 0 || a > 9))
return null;

for (var i = num.Length - 1; i >= 0; i--)
{
if (num[i] == 9)
{
num[i] = 0;
}
else
{
num[i]++;
return num;
}
}
return new []{ 1 }.Concat(num).ToArray();
}
}
}

구하는 공식은 거의 비슷하지만, 이 코드가 더 짧다. int형 배열의 경우 레퍼런스를 넘겨주기 때문에, 배열 값 자체가 변하는 문제가 있으므로, 배열 값 변경을 원치 않는다면 새로운 배열에 값을 복사해서 진행 하면 될것 같고..

여기서 참고할 부분은 배열의 길이를 1 증가시켜주기 위해 새로 생성해 주는 부분.

int[] newArr = new int[arrayOnePlus.Length + 1];
newArr[0] = 1;
for (int j = 0; j < arrayOnePlus.Length; j++)
{
newArr[j+1] = arrayOnePlus[j];
}
new []{ 1 }.Concat(num).ToArray();

Linq를 사용하면 Concat 메서드를 사용하여 이렇게 간단히 줄일 수 있다는 점은 참고할 만 한 사실이다.

· 약 2분
karais89

Instructions

Some numbers have funny properties. For example:

89 --> 8¹ + 9² = 89 * 1

695 --> 6² + 9³ + 5⁴= 1390 = 695 * 2

46288 --> 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51

Given a positive integer n written as abcd... (a, b, c, d... being digits) and a positive integer p we want to find a positive integer k, if it exists, such as the sum of the digits of n taken to the successive powers of p is equal to k * n. In other words:

Is there an integer k such as : (a ^ p + b ^ (p+1) + c ^(p+2) + d ^ (p+3) + ...) = n * k

If it is the case we will return k, if not return -1.

Note: n, p will always be given as strictly positive integers.

digPow(89, 1) should return 1 since 8¹ + 9² = 89 = 89 * 1
digPow(92, 1) should return -1 since there is no k such as 9¹ + 2² equals 92 * k
digPow(695, 2) should return 2 since 6² + 9³ + 5⁴= 1390 = 695 * 2
digPow(46288, 3) should return 51 since 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51

My Solution

using System;

public class DigPow {
public static long digPow(int n, int p) {
string strN = n.ToString();
long sum = 0;
for (int i = 0; i < strN.Length; i++)
{
int digit = int.Parse(strN[i].ToString());
long powVal = (long)Math.Pow(digit, p + i);
sum += powVal;
}

if (sum % n == 0)
{
return sum / n;
}

return -1;
}
}
  1. int형을 String으로 변환
  2. 각 자릿수 대로 제곱 해준후 더해준다.
  3. 더해준 값이 n으로 나누어지면 몫 반환. 아니면 -1 반환

Best Practices

using System.Linq;
using System;

public class DigPow {
public static long digPow(int n, int p) {
var sum = Convert.ToInt64(n.ToString().Select(s => Math.Pow(int.Parse(s.ToString()), p++)).Sum());
return sum % n == 0 ? sum / n : -1;
}
}

Linq는 2줄이면 해결

· 약 3분
karais89

Instructions

Write Number in Expanded Form You will be given a number and you will need to return it as a string in Expanded Form. For example:

Kata.ExpandedForm(12); # Should return "10 + 2"
Kata.ExpandedForm(42); # Should return "40 + 2"
Kata.ExpandedForm(70304); # Should return "70000 + 300 + 4"

NOTE: All numbers will be whole numbers greater than 0.

If you liked this kata, check out part 2!!

My Solution

using System;
using System.Text;

public static class Kata
{
public static string ExpandedForm(long num)
{
// long to string
string strNum = "" + num;
StringBuilder builder = new StringBuilder();
for (int i = 0; i < strNum.Length; i++)
{
if (strNum[i] > '0')
{
if (builder.Length != 0)
{
builder.Append(" + ");
}

// char to string to int
int n = int.Parse(strNum[i].ToString());
double digit = strNum.Length - i - 1;
digit = Math.Pow(10, digit);

string strResult = "" + (n * digit);
builder.Append(strResult);
}
}
return builder.ToString();
}
}

항상 이런 자릿수 문제가 나오면 long형을 string으로 바꾸어 준다음에 풀면 쉽게 풀 수 있다.

builder를 사용하여 풀었고, 저번에 문제를 풀다 보니 맨 처음에만 검사를 해서 기호를 넣어주면 쉽게 해결이 되는 부분이 있어서 그게 생각나서 그렇게 풀어 봤다.

[Codewars #13] Help the bookseller (6kyu) Best Practices 2에서 사용한 방식

Best Practices 1

using System;
using System.Linq;

public static class Kata
{
public static string ExpandedForm(long num)
{
var str = num.ToString();
return String.Join(" + ", str
.Select((x, i) => char.GetNumericValue(x) * Math.Pow(10, str.Length - i - 1))
.Where(x => x > 0));
}
}

Linq를 사용하여 간단히 해결!

string에 있는 0 보다 큰 모든 값을 전부 자릿수대로 곱해주고 그 값을 조인 시켜 구한다.

Best Practices 2

using System;
using System.Collections.Generic;

public static class Kata
{
public static string ExpandedForm(long num)
{
Stack<long> parts = new Stack<long>();

for (long m = 1, n = num; n > 0; n /= 10, m *= 10)
{
long digit = n % 10;
if (digit > 0)
{
parts.Push(m * digit);
}
}

return string.Join(" + ", parts);
}
}

이거는 표 자체는 많이 받지 못한 풀이 방식인데.

stack을 사용하여 일단 자리수를 전부 구한다음에, string join으로 " + "를 연결하는게 신박한 방식인 것 같아서 실어 봤다.

· 약 16분
karais89

한마디로 닷컴 내용 정리

INTRODUCTION

주어 만들기 서론 1

문장의 구조

  • 주어 + 동사 + 목적어 + 보어 + 부사
    • She bought a car (보어 X) yesterday
    • He is (목적어 X) ateacher now
    • Tom makes her angry all the time (5형식)
    • 영어는 이 순서에 맞게 단어를 배열한다고 봐도 좋다.
    • (주어)명사 + (동사)동사 + (목적어)명사 + (보어)명사/형용사 + (부사)전치사구 등
    • 문장에는 명사가 많다. 5개 주에 3개 정도가 명사로 이루어져 있다.

주어 만들기 서론 2

명사란 도대체 뭐야?

1) 대명사

  • He is right
    • 그는
    • He = the man 2단어 명사를 "딱 한마디로" 줄인 형태
    • 대명사는 "긴 명사를 딱 한 단어로 줄인 것"

2) 명사

  • God is almighty
    • 신은
    • 사물의 이름이나 명칭

3) 명사구

  • The title of this book is "도가니"
    • 이 책의 제목은
    • 여러 단어로 이루어진 하나의 명사 의미 단위

4) To V

  • To study English is hard
    • 영어 공부하는 건
    • 앞으로 ~하려고 하는 상황

5) V-ing

  • Watching TV is my hobby
    • TV 보는 건
    • 지금 ~하고 있는 장면

6) 명사절

  • Why you love me is a mystery.
    • 왜 니가 날 사랑하는 지

내용은 똑같지만 "어순" 혹은 "순서"만 다르다.

우리말에서도 다양한 명사가 있다. 국어를 잘하는 사람은 영어를 잘할 수 밖에 없다.

주어 만들기 서론 3

명사는 주어, 목적어, 보어, 전치사의 목적어 역할을 할 수 있다.

1) 대명사

  • it
  • It을 주어, 목적어, 보어, 전치사의 목적어로 응용하기
    • It is good. (주어)
    • I love it. (목적어)
    • This is it. (보어) be 동사 뒤는 보어로 많이 쓰인다.
    • Let me talk about it. (전치사 + 명사 (전명구))

2) 명사

  • Tom
  • Tom을 주어, 목적어, 보어, 전치사의 목적어로 응용하기
    • Tom is good. (주어)
    • I love Tom. (목적어)
    • This is Tom. (보어) be 동사 뒤는 보어로 많이 쓰인다.
    • Let me talk about Tom. (전치사 + 명사 (전명구))

3) 명사구

  • One of them
  • One of them을 주어, 목적어, 보어, 전치사의 목적어로 응용하기
    • One of them is good. (주어)
    • I love one of them. (목적어)
    • This is one of them. (보어) be 동사 뒤는 보어로 많이 쓰인다.
    • Let me talk about one of them. (전치사 + 명사 (전명구))

4) To V

  • To study English
  • To study English을 주어, 목적어, 보어, 전치사의 목적어(X)로 응용하기
    • To study English is good. (주어)
    • I love to study English. (목적어)
    • This is to study English. (보어 의미가 어색해서 X) -> 이 문장에서 X
    • Let me talk about to study English. (전치사의 목적어 X)
      • 전치사 다음에는 To 가 못온다 ING만 올 수 있다. 이건 외워야 됨!

5) V-ing

  • Studying English
  • Studying English을 주어, 목적어, 보어, 전치사의 목적어로 응용하기
    • Studying English is good. (주어)
    • I love studying English. (목적어)
    • This is studying English. (보어 의미가 어색해서 X) -> 이 문장에서 X
    • Let me talk about studying English. (전치사 + 명사 (전명구))

6) 명사절

  • Why you love me
  • Why you love me을 주어, 목적어, 보어, 전치사의 목적어로 응용하기
    • Why you love me is a non-sense. (주어)
    • I know why you love me. (목적어)
    • This is why you love me. (보어)
    • Let me talk about why you love me. (전치사 + 명사 (전명구))

주어 만들기 서론 4

"그녀의 고향"이라는 명사를 주어, 목적어, 보어, 전치사의 목적어로 활용 "her home town"

  • 그녀의 고향은 서울입니다.
    • 주어
    • Her home town is Seoul
  • 나는 그녀의 고향을 압니다.
    • 목적어
    • I know her home town
  • 여기가 그녀의 고향입니다.
    • 보어
    • Here(This) is her home town
  • 그녀의 고향에 대해 제가 질문해도 되나요?
    • 전치사의 목적어
    • Can I ask a question about her home town?

"영화보는 것"이라는 명사를 주어, 목적어, 보어, 전치사의 목적어로 활용 "watching a movie"

  • 영화보는 것은 그녀의 취미입니다
    • 주어
    • Watching a movie is her hobby.
  • 그녀는 나와 함께 영화보는 것을 좋아하니다.
    • 목적어
    • She likes watching a movie with me.
  • 나의 취미 역시 영화보는 것입니다.
    • My hobby is watching a movie too.
  • 우리는 영화보는 것을 위하여 많은 돈을 썻습니다.
    • We spent much money for watching a movie

CHAPTER 1 - UNIT 1

주어에는 6가지 종류가 있다.

대명사, 명사, 명사구의 주어는 생략한다 (쉽다)

TO부정사, ING, 명사절 복잡한 주어로 구성된 문장을 연습한다.

TO부정사 주어 1

  • 진지한 검토 없이 우리 마을에 새 공장을 세우는 것은 좋은 생각이 아니다
    • 진지한 검토 없이 우리 마을에 새 공장을 세우는 것은 (주어)
      • 세우는 것 / 새 공장을 / 우리 마을에 / 진지한 검토 없이
      • To build / a new factory / in our town / without serious consideration
    • 좋은 생각이 아니다 (서술어)
      • is not a good idea.
    • It is not a good idea to build a new factory in our town without serious consideration
      • 가주어/진주어
      • It은 뜻이 있다.

TO부정사 주어 2

  • 앞으로 3년안에 최대한 많은 나라를 방문하는 것이 내 꿈이다.
    • 앞으로 3년안에 최대한 많은 나라를 방문하는 것이 (주어)
    • It is my dream / to visit / as many countries / as possible / in 3 years / from now.

TO부정사 주어 3

  • 단지 당신이 가난하다고 해서 별다른 근거없이 자신을 쓸모없다고 여기는 것은 어리석은 짓이다
    • 단지 당신이 가난하다고 해서 별다른 근거없이 자신을 쓸모없다고 여기는 것(주어)
    • 어리석은 짓이다 (서술어)
    • It is stupid / to regard / yourself / as useless (one) / without specific ground / just because you are poor

TO부정사 주어 4

  • 풍부한 미네랄을 포함하는 물을 매일 5잔 이상 마시는 것은 당신의 건강을 위해 매우 좋다.
    • 풍부한 미네랄을 포함하는 물을 매일 5잔 이상 마시는 것은 (주어)
    • 당신의 건강을 위해 매우 좋다. (서술어)
    • It is very beneficial / for your health / to drink / everyday / more / than 5 glasses / of water / containing / abundant minerals.

TO부정사 주어 5

  • 모든 사람들이 수긍하는 적절한 근거없이 남들을 비난하는 것은 옳지 않다.
    • It is not right / to blame / others (other people) / without proper ground / (that) everyone agrees to.

TO부정사 주어 6

  • 나는 스터디그룹에서 다른 사람들과 함께 공부하는 것보다 도서관에서 혼자 공부하는걸 선호한다.
    • 나는 (주어)
    • 목적어 연습용 문장
    • I prefer / to study / alone (by myself) / in the library / than / to study / (together) / with others / in a study group.
    • A than B

CHAPTER 1 - UNIT 2

ING(동명사) 주어 1

동명사는 ing형의 여러가지 이름 중 하나 입니다.

  • 그 자동차는 / 새거다.

    • 명사 주어
    • The car is brandnew.
  • 커피 마시는 것은 / 건강에 좋다.

    • 동명사 주어
    • Drinking coffee is good for health.
  • Go

    • Going / to North Korea / with kim taehee / next year / is illegal.
      • 가는 것 / 북한으로 / 김태희랑 / 내년에 / 불법이다.
      • 주어 : Going / to North Korea / with kim taehee / next year
      • 서술어 : is illegal.
      • It is illegal
    • 주어
    • 목적어
      • I enjoyed / going to North Korea with kim taehee last year
    • 보어
      • My plan is / going to North Korea with kim taehee next year
        • 계획은 미래를 나타내기 때문에 going 보다는 to go가 더 낫긴 하다.
    • 전명구
      • I talked about / going to North Korea with kim taehee next year
  • Water

    • Water is important
    • I need water.
    • This is water.
    • I heard about water.

ING(동명사) 주어 2

  • 지금보다 훨씬 더 많은 직원들을 고용하는 것은 돈 낭비이다.
    • 주어 : 지금보다 훨씬 더 많은 직원들을 고용하는 것은
    • 서술어 : 돈 낭비이다.
    • 고용하는 것 / 훨씬 더 많은 직원들을 / 지금보다 / 돈 낭비이다
    • Hiring / much more employees / than now / is waste of money.
    • 지금보다 훨씬 더 많은 책을 읽는 것은 시간 낭비이다.
      • Reading much more books than now is waste of time.
  • 이 보고서를 다음주 월요일까지 완성하는 건 나에게 거의 불가능하다.
    • 주어 : 이 보고서를 다음주 월요일까지 완성하는 건
    • 서술어 : 나에게 거의 불가능하다.
    • Completing / this report / by next Monday(Monday next week) / is almost imposible for me
    • 이 책을 다음 주 월요일까지 끝내는 건 나에게 거의 불가능하다.
      • Finishing this book by next Monday is almost impossible for me
    • It is almost impossible for me completing this report by next Monday.

ING(동명사) 주어 3

  • 임시 직원에게 충분한 관심을 주는것은 고용주의 기본적인 의무이다.
    • part-time worker 임시직원, 아르바이트
    • pay attention 관심을 주다
    • employer 고용주
    • basic 기본적인
    • duty 의무
    • 주어 : 임시 직원에게 충분한 관심을 주는것은
    • 서술어 : 고용주의 기본적인 의무이다.
    • Paying / enough attention / to temporary employees / is a basic duty / of employers.
  • 이번에 이 광고를 선택하는것은 당신의 회사에 큰 혜택을 가져올 것이다.
    • 주어 : 이번에 이 광고를 선택하는것은
    • Choosing / this advertisement / this time / will bring a huge benefit / to your company

ING(동명사) 주어 4

  • 이 기계를 최적의 상태로 유지하는 것은 그 경쟁에서 승리하기 위해 매우 중요하다.
    • optimal : 최적의
    • maintain : 유지하다
    • competition : 경쟁
    • 주어 : 이 기계를 최적의 상태로 유지하는 것
    • 서술어 : 그 경쟁에서 승리하기 위해 매우 중요하다.
    • 서술어도 길기 때문에 가주어 진주어를 안해도 된다.
    • Maintaining / this machine / in optimal condition / is very important / for winning (in order to win) / in the competition
    • Maintaining is very important. 에서 시작 되었다.

ING(동명사) 주어 5

  • 당신의 인생을 그런 남자를 위해 낭비하는 것은 좋은 생각이 아니다.
    • 주어: 당신의 인생을 그런 남자를 위해 낭비하는 것은
    • such a 명사 : 그런(따위) ~
    • Wasting / your life / for such a man / is not a good idea.
    • It is not a good idea wasting your life for such a man.
  • 못생긴 남자와 지루한 영화를 보는 건 그녀에게 별난 일이 아니었다.
    • 주어 : 못생긴 남자와 지루한 영화를 보는 건
    • Watching / a boring movie / with an ugly man / was not uncommon / for her
    • bore : 지루하게 하다
    • boring : 지루하게 하는
    • common : 흔한
    • uncommon : 별난
  • 재미없는 책을 읽는 것이 재미없는 여자와 데이트하는 것보다 훨씬 낫다
    • 주어 : 재미없는 책을 읽는 것
    • Reading / a boring book / is much better / than dating / (with) a boring woman.
    • than : ~보다
    • A is better than B

ING(동명사) 주어 6

  • 오늘 당신의 아내를 화나게 만드는 건 내일 당신을 미치게 할 거다.
    • 주어 : 오늘 당신의 아내를 화나게 만드는 건
    • Making / your wife / angry / today / will make / you(yourself) / crazy / tomorrow.
  • 나쁜 아내와 한 집에 사는 건 황야에서 혼자 사는 것보다 훨씬 나쁘다.
    • 주어 : 나쁜 아내와 한 집에 사는 건
    • the same : 똑같은
    • bad - worse - worst
    • Living / with a bad wife / in the same house / is much worse than living alone in the wild.