컨플릭트를두려워하지말자

function solution(begin, target, words) {

    if (!words.includes(target)) return 0;

  
    let queue = [[begin, 0]]; 
    let wordAll = new Set(words); 
    let now = begin;
    let answer = 0;
 
    function findSimilar(word1, word2) {
        let diff = 0;
        for (let i = 0; i < word1.length; i++) {
            if (word1[i] !== word2[i])
                diff++;
            if (diff > 1) return false; 
        }
        return diff === 1; 
    }

  
    while (queue.length > 0) {
        let [current, step] = queue.shift();

      
        if (current === target) return step;

     
        for (let word of wordAll) {
            if (findSimilar(current, word)) {
                queue.push([word, step + 1]); 
                wordAll.delete(word); // 방문한 단어는 Set에서 제거
            }
        }
    }

  
    return 0;
}

아직도 이해가 잘 안 된다.........................

https://school.programmers.co.kr/learn/courses/30/lessons/42747

function solution(citations) {
    let nth = Math.ceil(citations.length / 2);
    citations.sort((a,b)=>b-a);
    
    for(let i = 0; i<citations.length; i++){
        if(citations[i]<i+1)return i;
    }
    return citations.length;
}

테스트케이스 2번이 

입력값 [3,5,11,6,1,5,3,3,1,41]

기댓값 2 

인데여 아무리생각해도 답이 5인데 ........왜 2 라고나오는지 ? 

저 테스트케이스 틀려도 제출하니까 통과되더라구여 

내림차순으로 정렬했을때 

[41,11,6,5,5,3,3,3,1,1]

인덱스만큼 인용되지 못한 논문 > 6번째논문 

그럼 답은 5 아닌가요?

1. 배열과 해시의 차이 

배열은 인덱스를 통해 데이터에 접근, 해시는 키를 통해 접근

배열은 순차적으로 처리해야 하는 경우에 사용하는 것이 좋고, 해시는 키 기반으로 검색을 해야 할 때 유용하다. 

eg) 리스트 처리 > 배열 , db 검색 or 캐싱 > 해시 

2. http와 https의 차이 

http는 데이터 암호화 x https는 ssl/tls 핸드셰이크를 추가해서 데이터를 암호화함. 서버-클라이언트간의 안전한 통신 보장. 데이터 무결성 보장. 

seo면에서도 https 페이지가 높은 랭크를 받는다. 

3. 프론트엔드에서 웹 성능 최적화를 위해 할 수 있는 일 

- webpack이나 vite 등의 번들러를 사용한 코드 번들링. > 필요시에만 코드를 로딩함

- 리소스 캐싱 > 브라우저에 캐싱을 설정하면 사용자 재방문시 리소스를 재사용할 수 있어 로딩이 빨라짐(react-query)

-비동기 처리 > js의 비동기 처리 로직을 사용해서 ui가 멈추지 않고 반응하도록 함 

-지연 로딩 > 이미지나 비디오같은 용량이 큰 것들은 필요할때만 로드해서 로딩속도 줄이기 

+ sql과 nosql차이... 

+브라우저 랜더링 과정... 

나중에 더  써야지... 

https://school.programmers.co.kr/learn/courses/30/lessons/42586

function solution(progresses, speeds) {
    var answer = [];
  
    let day = 0;
    while(progresses.length>0){
        day++;
        progresses = progresses.map((p,idx)=>p+speeds[idx]);
        let all = 0;
        console.log(progresses)
        while(progresses.length>0&&progresses[0]>=100){
            if(progresses[0]>=100){
                progresses.shift();
                speeds.shift();
                all++;
            }
        }
        if(all>0)answer.push(all)
        
    }
      return answer;
}

선입선출의 원리를 가진 스택처럼 앞의것부터 순서대로 shirt 처리 해주면 되는 문제 

https://school.programmers.co.kr/learn/courses/30/lessons/42576

function solution(participant, completion) {
    var answer = '';
    var pmap = new Map();
    var cmap = new Map();
    
    participant.map((p)=>pmap.set(p,pmap.get(p)?pmap.get(p)+1:1));
    completion.map((c)=>cmap.set(c,cmap.get(c)?cmap.get(c)+1:1));
    for (p of participant){
          if(pmap.get(p)!==cmap.get(p)){
              answer = p;
              break;
                    }
    }
    
 
    return answer;
}

해시를 쓸 줄 안다면 간단히 풀 수 있는 문제 

https://school.programmers.co.kr/learn/courses/30/lessons/42840

function solution(answers) {
  var answer = [];
  var ansMap = new Map();
  ansMap.set(1, 0);
  ansMap.set(2, 0);
  ansMap.set(3, 0);

  var one = [1, 2, 3, 4, 5];
  var two = [2, 1, 2, 3, 2, 4, 2, 5];
  var three = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
  var myAnswer = [one, two, three];

  answers.forEach((a, idx) => {
    myAnswer.forEach((m, num) => {
      if (a === m[idx % m.length]) {
        ansMap.set(num + 1, ansMap.get(num + 1) + 1);
      }
    });
  });

  let res = [ansMap.get(1), ansMap.get(2), ansMap.get(3)];

  function findMaxIndices(arr) {
    if (arr.length === 0) {
      return [];
    }

    const maxValue = Math.max(...arr);

    const maxIndices = arr
      .map((value, index) => (value === maxValue ? index + 1 : -1))
      .filter(index => index !== -1);

    return maxIndices;
  }

  return findMaxIndices(res);
}

먼가 구질구질하게 푼 것 같지만...일단풀었다 ㅎㅎ 

https://school.programmers.co.kr/learn/courses/30/lessons/86491

function solution(sizes) {
    var answer = 0;
    var width = 0;
    var height = 0;
    var size = sizes.map((s)=>s[0]>s[1]?[s[1],s[0]]:s);
    size.forEach((s)=>{
            if(s[0]>width)
                width=s[0]
            if(s[1]>height)
                height=s[1]
          } 
        )
        
    return width*height;
}

width, height 비교해서 내부 정렬하고

다시 forEach 돌려서 비교하면 끝 ~ 

https://school.programmers.co.kr/learn/courses/30/lessons/1844

bfs로 문제를 구하는 방법은 정해져잇으니 외워두자 ~.~

function solution(maps) {
    var answer = 0;
    const n = maps.length;
    const m = maps[0].length;
    
    const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]; 
    const queue = [[0,0,1]]; //시작지점도 이동한걸로 보기 때문에 1 Q
    
    const visited = Array.from({length:n},()=>Array(m).fill(false));
    visited[0][0]=true;
    
    while(queue.length>0){
        let [x,y,dist]=queue.shift();
        
        if(x===n-1&&y===m-1)return dist;
        
        for(let [dx,dy] of directions){
            let nx = x+dx;
            let ny = y+dy;
            
            if(nx>=0 && nx<n && ny>=0 && ny<m && maps[nx][ny]!==0 && !visited[nx][ny]){
                  queue.push([nx,ny,dist+1]);//다시 이동한 위치 넣어줌 
                  visited[nx][ny]=true; //방문했으니 true로바꿈 
            }
              
        }
    }
    return -1;
}