국내주식 / 일본주식 / 개발자이야기

using System;

class Solution
{
    public int[] solution(int[,] v)
    {
        int[] answer={0,0};

        answer[0] = v[0,0] ^ v[1,0] ^ v[2,0];
        answer[1] = v[0,1] ^ v[1,1] ^ v[2,1];

        return answer;
    }
}

///////

    int[] answer = new int[2];

    for(int i=0; i<answer.Length;i++)

    {

        if(v[0][i] == v[1][i])

        {

             answer = v[2][i];

        }

        else if(v[0][i] == v[2][i])

        {

             answer = v[1][i];

        }

        else if(v[1][i] == v[2][i])

        {

             answer = v[0][i];

        }

   }

   return answer;

A XOR B = 0

A XOR A XOR B = B 

같은 값 두개와 다른 값 하나를 XOR하면 다른 값 한개가 나옴

using System;
using System.Collections.Generic;

public class Solution {
    public string solution(int[] numbers) {
        List<string> lstnumber=new List<string>();
        List<string> builder = new List<string>();
        
        for(int i=0; i<numbers.Length; i++)
        {
            lstnumber.Add(numbers[i].ToString());
        }
        lstnumber.Sort((a,b)=>(b+a).CompareTo(a+b));
        
        foreach(var str in lstnumber)
        {
            builder.Add(str);
        }
        
        string answer = string.Join("",builder);
        if(answer[0]=='0') return "0";
        return answer;
    }
}

////

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

public class Solution {
    public string solution(int[] numbers)
    {
        Array.Sort(numbers, (x, y) =>
        {
            string XY = x.ToString() + y.ToString();
            string YX = y.ToString() + x.ToString();
            return YX.CompareTo(XY);
        });
        if (numbers.Where(x => x == 0).Count() == numbers.Length) return "0";
        else return string.Join("", numbers);
    }
}

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

public class Solution {

    public class Job {
        public int requestedAt = -1;
        public int duration = -1;

        public int waited = -1;
    }

    public int solution(int[,] input) {
        var JOB_CNT = input.GetLength(0);
        var jobs = new List<Job>(JOB_CNT);

        for (int i = 0; i < JOB_CNT; i++) {
            jobs.Add(new Job() {
                requestedAt = input[i, 0],
                duration = input[i, 1],
            });
        }

        int time = 0, done = 0;
        while (done < JOB_CNT) {
            var job = jobs                          // 전체 작업 중에서
                .Where(j => j.waited < 0)           // 아직 waited 계산이 끝나지 않았고,
                .Where(j => j.requestedAt <= time)  // 현재 시간(time) 기준 요청이 들어와있으며
                .OrderBy(j => j.duration)           // 그 중에서 작업에 필요한 시간이
                .FirstOrDefault();                  // 가장 짧은 작업을 선정

            if (null == job) {
                time++; continue;   // 없으면 시간 경과만 하고 넘어감
            }

            time += job.duration;
            job.waited = time - job.requestedAt;
            done++;
        }

        return (int)jobs.Average(j => j.waited);
    }
}

using System;

public class Solution {
    string tar;
    int answer = 0;
    
    //dfs
    //비교 항목, 단계, 방문 여부, 비교 대상 배열
    public void dfs(string begin, int phase, bool[] visit, string[] words)
    {
        //비교 대상 길이만큼 반복
        for(int i=0; i<words.Length; i++)
        {
            //해당 visit 변수가 거짓이면
            if(!visit[i])
            {
                //비교 항목과 [i]번째 비교 대상 단어와 비교
                int n = 0;
                for(int j=0; j<words[i].Length; j++)
                {
                    //한 글자씩 비교하여 같으면 n변수 더하기
                    if(begin[j] == words[i][j])
                    {
                        n++;
                    }
                }
                //변수 n이 비교 항목 문자열 길이 - 1 과 같을 때
                if(n == begin.Length-1)
                {
                    //비교 항목을 새로운 비교 대상 단어로 치환
                    begin = words[i];
                    //해당 번째 방문 true
                    visit[i] = true;
                    
                    //치환된 비교 항목이 목표 타겟과 같으면 dfs 종료
                    if(begin == tar)
                    {
                        answer = phase + 1;
                    }
                    //아니면 dfs 실행
                    else
                    {
                        dfs(begin, phase + 1, visit, words);
                    }
                }
            }
        }
    }
    
    public int solution(string begin, string target, string[] words) {
        //목표 타겟 변수 저장
        tar = target;
        
        //방문 변수 선언
        bool[] visit = new bool[words.Length];
        
        //dfs 실행
        dfs(begin, 0, visit, words);
        
        return answer;
    }
}

// 몰라서 베꼈다.

C#

using System;

public class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        int answer = 0;
        int[] student = new int[n];
        int a = 0;
        
        for(int i=0;i<n;i++)
        {
            student[i] = i+1;
        }
        //학생 번호를 정의한다.
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<reserve.Length;j++)
            {
                if(student[i] == reserve[j])
                {
                    student[i] = 0;
                }
            }
            //reserve에 기록된 학생들은 0으로 바꿔서 0의 개수를 리턴하게
            
            if(i>=1 && student[i-1] != 0)
            {
                student[i-1] = 0;
            }
            
            if(i+1 < n && student[i+1] != 0 && i>=1 && student[i-1] != 0 && student[i] == 0)
            {
                student[i+1] = 0;
            }
        }
        
        for(int i=0;i<n;i++)
        {
            if(student[i] == 0)
            {
                answer++;
            }
        }
        
        return answer;
    }
}

// 이렇게 했는데 안돼서 걍 다른 사람 거를 봤다.

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

public class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        List<int> lostList = new List<int>(lost);
        List<int> reserveList = new List<int>(reserve);
        //소팅 안되어 있음
        lostList.Sort();
        reserveList.Sort();
        
        List<int> tempList = new List<int>(reserveList);
        // 소팅 되어 있음
        
        for (int i = 0; i < tempList.Count; i++)
        {
            if (lostList.Contains(tempList[i]))
            {
                lostList.Remove(tempList[i]);
                reserveList.Remove(tempList[i]);
            }
        }
        
        for (int i = 0; i < reserveList.Count; i++)
        {           
            if (lostList.Contains(reserveList[i] - 1))
            {
                lostList.Remove(reserveList[i] - 1);
                continue;
            }
            
            if (lostList.Contains(reserveList[i] + 1))
            {
                lostList.Remove(reserveList[i] + 1);
                continue;
            }
        }
        
        return n - lostList.Count;
    }
}

////

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

public class Solution {
    public int solution(int n, int[] lost, int[] reserve)
    {
        int answer = 0;
        Queue<int> que = new Queue<int>();

        for (int i = 1; i <= n; i++)
        {
            if (lost.Contains(i))
            {
                if (reserve.Contains(i))
                {
                    answer++;
                    que.Enqueue(i);
                }
                else if (reserve.Contains(i - 1) && lost.Contains(i - 1) == false && que.Contains(i - 1) == false)
                {
                    answer++;
                    que.Enqueue(i - 1);
                }
                else if (reserve.Contains(i + 1) && lost.Contains(i + 1) == false && que.Contains(i + 1) == false)
                {
                    answer++;
                    que.Enqueue(i + 1);
                }
            }
            else answer++;
        }

        return answer;
    }
}

using System;
using System.Collections.Generic;

public class Solution {
    public int[] solution(int[] array, int[,] commands) {
        int[] answer = new int[commands.GetLength(0)];
        List<int> list = new List<int>();
        int k = 0;
        
        for(int i=0;i<commands.GetLength(0);i++)
        {
            for(int j=commands[i,0]-1;j<commands[i,1];j++)
            {
                list.Add(array[j]);

                // 자르기
            }

            list.Sort(); // 소팅하기
            answer[i] = int.Parse(list[commands[i,2]-1+k].ToString());
            // i에서 부터 k번째 수를 집어넣는다.            

            for(int p = 0;p<list.Count;p++)
            {
                list[p] = 0;
            }

// 소팅한 게 반영이 안되게 하려면 / for문을 돌리기 위해서는 리스트를 다 0으로 초기화해야함. 이러면 마이너스가 있을 때 문제 생길 듯. Abs로하고 소팅하면 되려나
            k += commands[i,1]-commands[i,0]+1;
        }
        return answer;
    }
}

///

using System;
using System.Collections.Generic;
public class Solution {
    public int[] solution(int[] array, int[,] commands) {
        int a2 = commands.Length / 3;
        int[] answer = new int[a2];
        List<int> list = new List<int>();

            for (int b = 0; b < a2; b++)
            {
               list.Clear();
                int i = commands[b, 0];
                int j = commands[b, 1];
                int k = commands[b, 2];
                
                 for (int a = i - 1; a < j; a++)
                {
                    list.Add(array[a]);
                }
                
                list.Sort();
                answer[b] = list[k-1];
            }
        return answer;
    }
}

C#

using System;
using System.Text;

public class Solution {
    public string solution(string number, int k) {
        string answer = "";
        number = "9" + number;
        StringBuilder sb = new StringBuilder(number);
        int index = 0;
        
        for(int i = 0; i < k; i++)
        {
            while (true)
            {
                if(index + 1 == sb.Length)
                {
                    sb.Remove(index, 1);
                    index--;
                    break;
                }

                if(sb[index] < sb[index + 1])
                {
                    sb.Remove(index, 1);
                    index--;
                    break;
                }
                
                index++;
            }
        }

            return answer = sb.Remove(0,1).ToString();
    }
}

// 모르겠어서 다른 분의 코드를 참고했다. stringbuilder를 몰랐었다.

// stringbuilder는 string이긴 한데 string의 내용을 바꿀 수 있는 거. using System.Text;가 필요하다.

// stringbuilder의 Remove는 지정된 위치에서 지정된 길이 만큼을 지워주는 것.

https://developer-talk.tistory.com/342

using System;
using System.Text;

public class Solution {
    public string solution(string number, int k) {
        string answer = "";
        StringBuilder sb = new StringBuilder();
        int n=number.Length-k;
        
        //자리수 만큼 반복 
        for(int i=0, idx=-1; i<n; i++) 
        {
            char max = '0'; 
            // idx 다음 인덱스부터 k+i와 작거나 같을 때 까지 반복한다. 

			for(int j=idx+1; j<=k+i; j++)
            {
                //비교해서 max값 넣어주기
                if(max<number[j])
                {
                    max = number[j];
                    idx = j;
                }
            }
            sb.Append(max); //StringBuilder에 추가한다.
        }
        
        answer = sb.ToString();    
        return answer;
    }
}

using System;

class Solution
{
    public int solution(int[] nums)
    {
        int answer = 0;

        for(int i = 0; i < nums.Length - 2; ++i)
        {
            for(int j = i + 1; j < nums.Length - 1; ++j)
            {
                for(int k = j + 1; k < nums.Length; ++k)
                {
                    int sum = nums[i] + nums[j] + nums[k];
                    if (isPrime(sum))
                    {
                          answer++;
                    }
                }
            }
        }  
        
        return answer;
    }
    
    public bool isPrime(int num)
    {
        for(int i=2; i*i<=num; i++)
        {
            if(num%i == 0) return false;
        }
        return true;
    }
}