Portfolio

풀이

김영준


function solution(id_list, report, k) {
    const users = new Map();
    const mails = new Map();
    // 중복 제거 후 각각 배열로 만듦
    const reports = [...new Set(report)].map(report => report.split(" "));

    // Map 객체에 id별로 0으로 초기화
    for(const id of id_list){
        users.set(id, 0);
        mails.set(id, 0);
    }
 
    // reports를 순회하면서 신고 횟수를 증가
    for (const report of reports){
        users.set(report[1], users.get(report[1]) + 1);
    }
    
    // reports를 순회하면서 k 이상 신고한 사람을 신고했으면 mails의 count를 증가
    for (const report of reports){
        if(users.get(report[1]) >= k) {
            mails.set(report[0], mails.get(report[0]) + 1);
        }
    }

    return [...mails.values()];
}

이종현


function solution(id_list, report, k) {
    const answer = [];
    const map = new Map();
    
    for (let i = 0; i < id_list.length; i++) {
        map.set(id_list[i], new Set()); 
        answer.push(0);
    }
    
    for (let i = 0; i < report.length; i++) {
        const arr = report[i].split(' ');
        map.set(arr[0], map.get(arr[0]).add(arr[1]));
    }
    
    const people = [];
    
    for (const [key, value] of map) {
        people.push(...value);
    }
    
    const num = new Map();
    
    for (let i = 0; i < people.length; i++) {
        if (!num.has(people[i])) num.set(people[i], 1);
        else num.set(people[i], num.get(people[i]) + 1);
    }
    
    const arr1 = [];
    
    for (const [key, value] of num) {
        if (value >= k) arr1.push(key);
    }
    
    let idx = 0;
    
    for (const [key, value] of map) {
        const arr2 = [...value];
        for (let i = 0; i < arr2.length; i++) {
            if (arr1.includes(arr2[i])) answer[idx]++; 
        }
        idx++;
    }
    
    return answer;
}

박노철


function solution(id_list, report, k) {
   /*
   각 유저는 한번에 한명, 신고횟수제한x, 서로다른 유전 계속 신고가능, 한 유저를 여러번 신고가능 하지만 1회로 처리
   k번 이상 신고된 유저는 게시판 이용 정지, 해당유저를 신고한 유저에게 정지사실 메일 발송
   마지막 한번에 신고를 취합 후 메일 발송
    report는 '무지 프로도'이면 무지가 프로도를 신고하것이 된다.  각 유저가 받을 결과 메일의 횟수를 리턴 
    
   */
    
    // 각 유저가 누구에게 신고를 당했는지 체크를 하고  그 길이가 2 이상이면 그 유저들에게  메일을 봬준다. 
    //리스트를 0으로 초기화
    let reportedList = {};
    let mailCountList={}
    for(let a of id_list ){
        reportedList[a]=[];
        mailCountList[a]=0;
    }
    // 각 유저가 누구에게 신고를당했는지 이름을 넣우준다. 중복도 제거하며
    for(let a of report ){
        let[b,c] =a.split(" ");
        reportedList[c]=[...new Set([...reportedList[c], b])]
    }
    //신고당한 리스트에서 길이가 k 이상인 경우만 걸러서 메일을 발송해준다. 
    for( let a in reportedList){
        const l=reportedList[a];
        if(l.length>=k){
            for(let b of l){
                mailCountList[b]+=1;
            }
        }
    }
   
    return Object.values(mailCountList)
 
    
    
  
    
}

이민희


function solution(id_list, report, k) {
    const result = new Array(id_list.length).fill(0);

    // { 신고 당한 이용자: [신고한 이용자들] }
    const reportObject = report.reduce((accObject, curString) => {
        const [reporter, reportTarget] = curString.split(' ')

				// 아직 프로퍼티로 존재하지 않는 경우엔 undefined일 것이므로 이 경우에는 배열을 value로 새로 생성해줍니다.
        if (typeof accObject[reportTarget] !== 'object') {
            accObject[reportTarget] = [reporter];
        }
        // 이미 신고한 사람이 아니라면 (원소로 존재하지 않는다면)
        if (accObject[reportTarget].indexOf(reporter) === -1) {
            accObject[reportTarget].push(reporter)
        }
        
        return accObject;
    }, {})
    
    for (reportTarget in reportObject) {
        const reporters = reportObject[reportTarget]
        if (reporters.length >= k) {
            // 신고한 이용자들 각각의 결과 메일 수를 +1
            reporters.forEach(reporter => {
                const idIndex = id_list.indexOf(reporter)
                result[idIndex]++;
            })
        }
    }
    return result;
}


// reduce를 사용할 때 {}를 초기값으로 던져주지 않고 
// 처음부터 각 이용자를 key, 빈 배열을 value로 한 객체를 초기값으로 설정해줬을 때의 코드입니다.
// 이렇게 하면 reduce로 순회하면서 typeof를 통해 key로 존재하는지 아닌지를 확인해주지 않아도 됩니다.

const initialObject = {};
id_list.forEach(id => initialObject[id] = []);

const reportObject = report.reduce((accObject, curString) => {
    const [reporter, reportTarget] = curString.split(' ')
    
    // 이미 신고한 사람이 아니라면 (원소로 존재하지 않는다면)
    if (accObject[reportTarget].indexOf(reporter) === -1) {
        accObject[reportTarget].push(reporter)
    }

    return accObject;
}, initialObject)

박건우


// 신고 횟수 제한 X
// 한 유저 여러번 신고해봤자 신고 횟수는 1회
// k번 이상 신고되면 정지, 신고자에게 정지 사실 메일 발송
// 정지자는 정지 메일을 안받음

function solution(id_list, report, k) {
    report = report.map(v => v.split(" ")); // report 배열 구조 변경
    const answer = Array.from({length: id_list.length}, () => 0);
    const attackerMemory = {} // 특정 id가 누구한테 신고를 받았는지 저장하는 객체
    const indexMemory = {} // 특정 id의 index가 몇번인지 기억하는 객체
    
		// 객체 초기화
    id_list.forEach((name, index) => {
        attackerMemory[name] = new Set();
        indexMemory[name] = index;
    })
    
		// 신고 받은 사람에게 신고자의 이름을 추가합니다
    for(const [attacker, receiver] of report) {
        attackerMemory[receiver].add(attacker);
    }
    
    // 지금 신고자의 인덱스를 모르는 상태라 난관
    id_list.forEach((name, index) => {
        const length = attackerMemory[name].size; // 신고한 사람의 수
        if (length >= k) { // 만약 서로다른 신고자가 k명이 넘는다면
            attackerMemory[name].forEach(attacker => { // 정지메일 발송
                const attackerIndex = indexMemory[attacker];
                answer[attackerIndex]++;
            })
        }
    })
    
    return answer;
}

박주연


function solution(id_list, report, k) {
    // 신고 횟수 담는 Map  {'frodo': 2, 'neo': 2, 'muzi': 1}
    let reportInfo = new Map(); 
    
    // 처리 결과 횟수를 담는 Map {'muzi': 2, 'apeach': 1, 'frodo': 1}
    let mailInfo = new Map();
    
    // 중복 신고 방지 
    const reports = [...new Set(report)].map(v => v.split(' '));
    
    for( [user,reportedPerson] of reports){
        reportInfo.set(reportedPerson, reportInfo.get(reportedPerson)+1 || 1);
    }
    
    // 신고 횟수가 k이상인 경우만 mailInfo
    for([user,reportedPerson] of reports){
        reportInfo.get(reportedPerson) >= k ? mailInfo.set(user, mailInfo.get(user)+1 || 1) : null;
    }
    
    return id_list.map(id => mailInfo.get(id) || 0);
    
}

신고결과

풀이