with JavaScripts Study Days 12-13

210519 토요일 12~13일차

# 9~11일차 복습

CH5 큐

• 큐는 리스트의 일종으로 끝부분으로 데이터가 삽입되고 앞부분에서 데이터가 삭제되는 구조이다. 일어난 순서대로 데이터를 저장하지만 스택과 반대로 먼저 들어온 순서대로 처리한다. 선입선출.

• enqueue는 큐의 끝부분에 요소 추가, dequeue는 큐의 앞부분에 요소 삭제, 큐의 앞부분 요소를 확인하는 peek, 요소 개수를 확인하는 length, 전체 요소를 삭제하는 length, front()는 맨 앞의 요소, back()은 맨 뒤의 요소를 보여준다.

function Queue() {
    this.dataStore = [];
    this.enqueue = enqueue;
    this.dequeue = dequeue;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
}

function enqueue(element) {
    this.dataStore.push(element);
}

function dequeue() {
    return this.dataStore.shift();// 배열 앞부분에 저장된 요소를 삭제
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length - 1];
}
// 모든 요소 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}
// 큐가 비었는지 확인function empty() {
    if (this.dataStore.length === 0) {
        return true;
    } else {
        return false;
    }
}

let q = new Queue();
q.enqueue("M");
q.enqueue("C");
q.enqueue("J");
console.log(q.toString());
q.dequeue();
console.log(q.toString());
console.log("Front of queue: " + q.front());
console.log("Back of queue: " + q.back());

• 큐로 데이터 정렬하기

function Queue() {
    this.dataStore = [];
    this.enqueue = enqueue;
    this.dequeue = dequeue;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
    this.count = count;
}

function enqueue(element) {
    this.dataStore.push(element);
}

function dequeue() {
    return this.dataStore.shift();// 배열 앞부분에 저장된 요소를 삭제
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length - 1];
}
// 모든 요소 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}
// 큐가 비었는지 확인function empty() {
    if (this.dataStore.length === 0) {
        return true;
    } else {
        return false;
    }
}

function count() {
    return this.dataStore.length;
}

// @ : 큐로 데이터 정렬하기, 기수 정렬, 1의 자리 기준으로 숫자 정렬 후 10의 자리 기준으로 숫자 정렬.// @ : 각 숫자당 1개의 큐이므로 9개의 큐가 필요하다.function distribute(nums, queues, n, digit) {
    for (let i = 0; i < n; ++i) {
        if (digit === 1) {
// @ : nums[i]%10이면 해당 숫자의 일의 자리 숫자를 기준으로 queues[일의자리숫자]에 enqueue된다.console.log(nums[i] % 10);
            queues[nums[i] % 10].enqueue(nums[i]);
        } else {
// @ : Math.floor(nums[i]/10)로 십의 자리 숫자를 구한 뒤 queues[십의자리숫자]에 enqueue한다.console.log(Math.floor(nums[i] / 10));
            queues[Math.floor(nums[i] / 10)].enqueue(nums[i]);
        }
    }
}
// @ : 큐에 저장된 숫자를 수집하는 함수function collect(queues, nums) {
    let i = 0;
    for (let digit = 0; digit < 10; ++digit) {
        while (!queues[digit].empty()) {
// @ : nums[0~10]에 queues에 기수 정렬한 숫자들을 차례대로 넣어줌, 일의자리숫자 정렬 > 십의자리숫자 정렬시 기수정렬됨
            nums[i++] = queues[digit].dequeue();
        }
    }
}

function dispArray(arr) {
    for (let i = 0; i < arr.length; ++i) {
        console.log(arr[i] + " ");
    }
}

let queues = [];
// # : 각 숫자당 한 개씩 9개의 큐가 필요하다.for (let i = 0; i < 10; ++i) {
    queues[i] = new Queue();
}
let nums = [];
// # : 랜덤한 숫자 0~99를 만들어 nums에 할당한다.for (let i = 0; i < 10; ++i) {
    nums[i] = Math.floor(Math.floor(Math.random() * 101));
}
console.log("Before radix sort: ");
dispArray(nums);
distribute(nums, queues, 10, 1);
console.log();
collect(queues, nums);
distribute(nums, queues, 10, 10);
collect(queues, nums);
console.log("\n\nAfter radix sort: ");
dispArray(nums);

• 우선순위 큐

function Queue() {
    this.dataStore = [];
    this.enqueue = enqueue;
    this.dequeue = dequeue;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
    this.count = count;
}

function enqueue(element) {
    this.dataStore.push(element);
}

function dequeue() {
    return this.dataStore.shift();// 배열 앞부분에 저장된 요소를 삭제
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length - 1];
}
// 모든 요소 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}
// 큐가 비었는지 확인function empty() {
    if (this.dataStore.length === 0) {
        return true;
    } else {
        return false;
    }
}

function count() {
    return this.dataStore.length;
}

// # : 우선순위 큐// # : 예진 간호사가 환자 검사 >> 환자상태평가로 우선순위 코드 부여 >> 우선순위 높으면 먼저 진료받음(우선순위 코드가 같으면 선입선출)function Patient(name, code) {
    this.name = name;
    this.code = code;// 우선순위 or 심각성
}
// # : 가장 높은 우선순위(1 > 2 > 3 > 4 > ,,,) 삭제function dequeue() {
    let entry = 0;
    for (let i = 0; i < this.dataStore.length; ++i) {
// @ : this.dataStore[entry].code는 가장 작은 code(가장 높은 우선순위)로 유지되어야 한다.// @ : 따라서 인덱스 i일 때 더 작으면 entry=i로 할당한다.if (this.dataStore[i].code < this.dataStore[entry].code) {
            console.log(
                "deq",
                this.dataStore[i].code,
                this.dataStore[entry].code
            );

            entry = i;
            console.log("ent: ", entry);
        }
    }
    return this.dataStore.splice(entry, 1);
}
// # : 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr +=
            this.dataStore[i].name + " code: " + this.dataStore[i].code + "\n";
    }
    return retStr;
}
// # : worklet p = new Patient("Smith", 5);
let ed = new Queue();
ed.enqueue(p);
p = new Patient("Jones", 4);
ed.enqueue(p);
p = new Patient("Fehrenbach", 6);
ed.enqueue(p);
p = new Patient("Brown", 1);
ed.enqueue(p);
p = new Patient("Ingram", 1);
ed.enqueue(p);
console.log(ed.toString());
let seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());
// 다음 환자 치료
seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());
seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());

function Deque() {
    this.dataStore = [];
    this.push_front = push_front;
    this.push_back = push_back;
    this.pop_front = pop_front;
    this.pop_back = pop_back;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
}
// # :  push_front() : 맨 앞에 새로운 요소를 삽입한다.// # :  push_back() : 맨 뒤에 새로운 요소를 삽입한다.// # :  pop_front() : 맨 앞에 요소를 제거한다.// # :  pop_back() : 맨 뒤에 요소를 제거한다.// ! : splice(맨 앞 인덱스, 0, 추가하려는 요소)를 이용한다. 두 번째 인자의 길이만큼 삭제하지만 0이면 추가.function push_front(element) {
    this.dataStore.splice(0, 0, element);
}
function push_back(element) {
    this.dataStore.push(element);
}
function pop_front() {
    return this.dataStore.shift();// 배열 앞부분에 저장된 요소를 삭제
}
// ! : back함수에서 length-1을 사용하듯 맨 뒤의 요소에 대한 인덱스를 가져와서 해당 인덱스를 splice로 삭제한다.function pop_back() {
    return this.dataStore.splice(this.dataStore.length - 1, 1);// 배열 앞부분에 저장된 요소를 1개 삭제
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length - 1];
}
// 모든 요소 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}
// 큐가 비었는지 확인function empty() {
    if (this.dataStore.length === 0) {
        return true;
    } else {
        return false;
    }
}

let dq = new Deque();
dq.push_front("M");
dq.push_front("C");
dq.push_front("J");
console.log(dq.toString());
dq.pop_front();
console.log(dq.toString());
dq.pop_back();
console.log(dq.toString());
dq.push_back("A");
dq.push_back("B");
console.log(dq.toString());
console.log("Front of dequeue: " + dq.front());
console.log("Back of dequeue: " + dq.back());

• 우선순위 큐를 낮은 수가 아니라 높은 숫자를 높은 우선순위로 갖도록 구현하시오.

function Queue() {
    this.dataStore = [];
    this.enqueue = enqueue;
    this.dequeue = dequeue;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
    this.count = count;
}

function enqueue(element) {
    this.dataStore.push(element);
}

function dequeue() {
    return this.dataStore.shift();// 배열 앞부분에 저장된 요소를 삭제
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length - 1];
}
// 모든 요소 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}
// 큐가 비었는지 확인function empty() {
    if (this.dataStore.length === 0) {
        return true;
    } else {
        return false;
    }
}

function count() {
    return this.dataStore.length;
}

// # : 우선순위 큐// # : 예진 간호사가 환자 검사 >> 환자상태평가로 우선순위 코드 부여 >> 우선순위 높으면 먼저 진료받음(우선순위 코드가 같으면 선입선출)function Patient(name, code) {
    this.name = name;
    this.code = code;// 우선순위 or 심각성
}
// ! : 가장 높은 우선순위(,,, > 4 > 3 > 2 > 1) 삭제function dequeue() {
    let entry = 0;
    for (let i = 0; i < this.dataStore.length; ++i) {
        if (this.dataStore[i].code > this.dataStore[entry].code) {
            console.log(
                "deq",
                this.dataStore[i].code,
                this.dataStore[entry].code
            );

            entry = i;
            console.log("ent: ", entry);
        }
    }
    return this.dataStore.splice(entry, 1);
}
// # : 출력function toString() {
    let retStr = "";
    for (let i = 0; i < this.dataStore.length; ++i) {
        retStr +=
            this.dataStore[i].name + " code: " + this.dataStore[i].code + "\n";
    }
    return retStr;
}
// # : worklet p = new Patient("Smith", 5);
let ed = new Queue();
ed.enqueue(p);
p = new Patient("Jones", 4);
ed.enqueue(p);
p = new Patient("Fehrenbach", 6);
ed.enqueue(p);
p = new Patient("Brown", 1);
ed.enqueue(p);
p = new Patient("Ingram", 1);
ed.enqueue(p);
console.log(ed.toString());
let seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());
// 다음 환자 치료
seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());
seen = ed.dequeue();
console.log("Patient being treated: " + seen[0].name);
console.log("Patients waiting to be seen: ");
console.log(ed.toString());

# 12~13일차 학습

CH6 연결 리스트

6.1 배열의 단점

6.2 연결 리스트 정의

6.3 객체 기반 연결 리스트 설계

6.3.1 Node 클래스

// # : 노드 클래스function Node(element) {
    this.element = element;
    this.next = null;
}

6.3.2 연결 리스트 클래스

// # : 연결 리스트 클래스function LList() {
    this.head = new Node("head");
    this.find = find;
    this.insert = insert;
    this.findPrevious = findPrevious;
    this.remove = remove;
    this.display = display;
}

6.3.3 새로운 노드 삽입하기

// # : 새로운 노드 추가하기 : 기존 노드 뒤라고 가정, 기존 노드를 찾아야 한다.(find) 찾으면 해당 노드를 반환한다.function find(item) {
    let currNode = this.head;
// ! : 우선 새 노드를 만들고 head 노드로 설정while (currNode.element !== item) {
// ! : 다음 노드로 반복 이동하면서 현재 노드의 element 프로퍼티가 탐색하려는 값과 같은 값을 포함하는지 확인한다.// ! : 기존 노드를 찾으면 새 노드의 next 프로퍼티를 기존 노드의 next 프로퍼티의 값으로 설정한다.
        currNode = currNode.next;
    }
    return currNode;
}

function insert(newElement, item) {
    let newNode = new Node(newElement);
    let current = this.find(item);
    newNode.next = current.next;
    newNode.previous = current;
    current.next = newNode;
}

function display() {
    let currNode = this.head;
    while (!(currNode.next === null)) {
        console.log(currNode.next.element);
        currNode = currNode.next;
    }
}

6.3.4 연결 리스트에서 노드 삭제하기

// # : 연결리스트에서 노드 삭제하려면 삭제하려는 바로 이전 노드를 찾아야 한다. 이전 노드를 찾았으면 이전 노드의 next를 삭제하려는 노드의 다음 노드로 설정해야 한다.function findPrevious(item) {
    let currNode = this.head;
    while (!(currNode.next === null) && currNode.next.element !== item) {
        currNode = currNode.next;
    }
    return currNode;
}

function remove(item) {
    let prevNode = this.findPrevious(item);
    if (!(prevNode.next === null)) {
        prevNode.next = prevNode.next.next;
    }
}

6.4 양방향 연결 리스트

 function Node(element) {
    this.element = element;
    this.next = null;
    this.previous = null;
}

function insert(newElement, item) {
    let newNode = new Node(newElement);
    let current = this.find(item);
    newNode.next = current.next;
    newNode.previous = current;
    current.next = newNode;
}

function remove(item) {
    let currNode = this.find(item);
    if (!(currNode.next === null)) {
        currNode.previous.next = currNode.next;
        currNode.next.previous = currNode.previous;
        currNode.next = null;
        currNode.previous = null;
    }
}

// # : 양방향 연결 리스트의 "마지막 노드로 이동하는 유틸리티 함수"를 이용해 역순으로 연결 리스트를 출력하는 동작을 수행할 수 있다.function findLast() {
    let currNode = this.head;
    while (!(currNode.next === null)) {
        currNode = currNode.next;
    }
    return currNode;
}

// # : 역순으로 양방향 연결리스트의 요소 출력function dispReverse() {
    let currNode = this.findLast();
    while (!(currNode.previous === null)) {
        console.log(currNode.element);
        currNode = currNode.previous;
    }
}

6.5 순환형 연결 리스트

function LList() {
    this.head = new Node("head");
    this.head.next = this.head;
    this.find = find;
    this.insert = insert;
    this.display = display;
    this.findPrevious = findPrevious;
    this.remove = remove;
}

function display() {
    let currNode = this.head;
    while (!(currNode.next === null) && !(currNode.next.element == "head")) {
        console.log(currNode.next.element);
        currNode = currNode.next;
    }
}

6.6 기타 연결 리스트 함수

• advance(n) : 연결 리스트에서 n 노드만큼 전진

• back(n) : 양방향 연결 리스트에서 n 노드만큼 뒤로 후진

• show() : 현재 노드만 출력

6.7 연습문제

// # : 1. advance(n) 함수를 구현하시오. advance(n) 함수를 호출하면 현재 노드가 n 노드만큼 전진한다.function Node(element) {
    this.element = element;
    this.next = null;
}
function LList() {
    this.head = new Node("head");
    this.find = find;
    this.insert = insert;
    this.findPrevious = findPrevious;
    this.remove = remove;
    this.advance = advance;
    this.display = display;
}
function find(item) {
    let currNode = this.head;
    while (currNode.element !== item) {
        currNode = currNode.next;
    }
    return currNode;
}
function insert(newElement, item) {
    let newNode = new Node(newElement);
    let current = this.find(item);
    newNode.next = current.next;
    current.next = newNode;
}
function display() {
    let currNode = this.head;
    while (!(currNode.next === null)) {
        console.log(currNode.next.element);
        currNode = currNode.next;
    }
}
function findPrevious(item) {
    let currNode = this.head;
    while (!(currNode.next === null) && currNode.next.element !== item) {
        currNode = currNode.next;
    }
    return currNode;
}
function remove(item) {
    let prevNode = this.findPrevious(item);
    if (!(prevNode.next === null)) {
        prevNode.next = prevNode.next.next;
    }
}
function advance(n) {
    let currNode = this.head;
    for (let i = 0; i < n; ++i) {
        if (!(currNode.next === null)) {
            console.log("if O , next 요소", currNode.next.element);
            currNode = currNode.next;
        }
    }
    return currNode;
}

let cities = new LList();
cities.insert("Con", "head");
cities.insert("Rus", "Con");
cities.insert("Car", "Rus");
cities.insert("Alm", "Car");
cities.display();
console.log();
console.log("adv 3 : ", cities.advance(3));
console.log();
cities.display();

function Node(element) {
    this.element = element;
    this.next = null;
    this.previous = null;
}

function LList() {
    this.head = new Node("head");
    this.find = find;
    this.insert = insert;
    this.display = display;
    this.remove = remove;
    this.findLast = findLast;
    this.dispReverse = dispReverse;
    this.back = back;
}

function insert(newElement, item) {
    let newNode = new Node(newElement);
    let current = this.find(item);
    newNode.next = current.next;
    newNode.previous = current;
    current.next = newNode;
}

function remove(item) {
    let currNode = this.find(item);
    if (!(currNode.next === null)) {
        currNode.previous.next = currNode.next;
        currNode.next.previous = currNode.previous;
        currNode.next = null;
        currNode.previous = null;
    }
}
// # : 양방향 연결 리스트의 "마지막 노드로 이동하는 유틸리티 함수"를 이용해 역순으로 연결 리스트를 출력하는 동작을 수행할 수 있다.function findLast() {
    let currNode = this.head;
    while (!(currNode.next === null)) {
        currNode = currNode.next;
    }
    return currNode;
}
// # : 역순으로 양방향 연결리스트의 요소 출력function dispReverse() {
    let currNode = this.findLast();
    while (!(currNode.previous === null)) {
        console.log(currNode.element);
        currNode = currNode.previous;
    }
}

function display() {
    let currNode = this.head;
    while (!(currNode.next === null)) {
        console.log(currNode.next.element);
        currNode = currNode.next;
    }
}

function find(item) {
    let currNode = this.head;
    while (currNode.element != item) {
        currNode = currNode.next;
    }
    return currNode;
}

function back(n) {
    let currNode = this.findLast();
    console.log("맨뒤요소:", currNode);

    for (let i = 0; i < n; ++i) {
        if (!(currNode.previous === null)) {
            currNode = currNode.previous;
        }
    }
    return currNode;
}

let cities = new LList();
cities.insert("Con", "head");
cities.insert("Run", "Con");
cities.insert("Car", "Run");
cities.insert("Alm", "Car");
console.log("역순 출력");
cities.dispReverse();
console.log();
console.log("맨 뒤의 요소부터 back 2 : ", cities.back(2));

function show() {
  let currNode = this.head;
  return currNode.element
}

let cities = new LList();
cities.insert("Con", "head");
cities.insert("Run", "Con");
cities.insert("Car", "Run");
cities.insert("Alm", "Car");
cities.display();
console.log();
console.log("현재 노드 : ",cities.show());

// # : 4. 대화형으로 입력된 테스트 점수를 단방향 연결 리스트로 저장하는 프로그램을 구현하시오.function Node(element) {
  this.element = element;
  this.next = null;
}
function LList() {
  this.head = new Node("head");
  this.find = find;
  this.insert = insert;
  this.findPrevious = findPrevious;
  this.remove = remove;
  this.display = display;
  this.lastElement = lastElement;
}
function find(item) {
  let currNode = this.head;
  while (currNode.element !== item) {
      currNode = currNode.next;
  }
  return currNode;
}
function insert(newElement, item) {
  let newNode = new Node(newElement);
  let current = this.find(item);
  newNode.next = current.next;
  current.next = newNode;
}
function display() {
  let currNode = this.head;
  while (!(currNode.next === null)) {
      console.log(currNode.next.element);
      currNode = currNode.next;
  }
}
function findPrevious(item) {
  let currNode = this.head;
  while (!(currNode.next === null) && currNode.next.element !== item) {
      currNode = currNode.next;
  }
  return currNode;
}
function remove(item) {
  let prevNode = this.findPrevious(item);
  if (!(prevNode.next === null)) {
      prevNode.next = prevNode.next.next;
  }
}
function lastElement() {
  let currNode = this.head;
  while (!(currNode.next === null)) {
      currNode = currNode.next;
  }
  return currNode;
}

scores =  new LList();

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});

rl.on("line", function (score) {
  scores.insert(score,"head")
  rl.close();
});

rl.on("line", function (score) {
  const lastEl = scores.lastElement()
  if(lastEl === null){
    scores.insert(score,"head")
  }else{
    scores.insert(score,lastEl)
  }
  rl.close();
});

• generateRandomName : 성과 이름을 Math.random()함수와 Math.floor를 이용해서 만들고 합쳐서 한 명의 병사를 만들었다.

// 한글 이름 생성기const generateRandomName = () => {
    const lastName = "김이박";
    const firstName =
        "피어나는 끝까지 대한 청춘을 위하여서. 밝은 불어 청춘을 보이는 풍부하게 이것이다. 몸이 물방아 품에 공자는 인생에 가진 풀이 이것이다. 이는 창공에 피어나기 피다. 풀이 자신과 하여도 것이다. 풍부하게 인도하겠다는 얼마나 그들의 청춘은 긴지라 물방아 약동하다. 노년에게서 대한 힘차게 있는 그들을 할지니, 때까지 스며들어 열락의 운다. 바이며, 인생에 크고 이상 산야에 것이다. 이상이 방황하였으며, 봄바람을 말이다. 무엇이 찬미를 뭇 이상의 보는 방지하는 없으면, 청춘의 새가 위하여서. 밥을 얼음에 꽃이 열락의 듣는다.        별과 그들은 맺어, 이는 품에 이것이야말로 원대하고, 스며들어 철환하였는가? 그러므로 노래하며 품에 커다란 위하여, 방황하여도, 것은 그것을 이것이다. 간에 하는 역사를 피어나기 만천하의 행복스럽고 스며들어 바이며, 사막이다. 낙원을 거선의 무엇을 청춘은 위하여 시들어 거친 것이다. 가치를 동력은 새 유소년에게서 없는 천고에 위하여, 귀는 것이다. 인도하겠다는 어디 보이는 심장의 무엇을 시들어 얼마나 과실이 보라. 그것을 많이 날카로우나 끓는 옷을 바이며, 가는 있음으로써 약동하다. 청춘의 이것이야말로 귀는 놀이 능히 따뜻한 것이다. 품었기 같이, 보이는 자신과 것이다. 피고, 방황하였으며, 바이며, 피다. 피어나기 가치를 꽃 행복스럽고 같이, 그들을 무엇을 이상은 사막이다.있는 끓는 만물은 밥을 봄바람이다. 같이, 꽃이 풍부하게 더운지라 뭇 것은 용감하고 타오르고 위하여서. 가는 우리는 때까지 못할 그들은 하였으며, 싶이 동산에는 그러므로 보라. 목숨을 천하를 장식하는 공자는 피가 이것은 약동하다. 능히 우리는 것은 사는가 것이다. 미묘한 끓는 평화스러운 하여도 이상, 할지라도 것이다. 풍부하게 구하지 끓는 찾아다녀도, 않는 우리 그들의 천자만홍이 있으랴? 스며들어 품고 원대하고, 끓는다. 위하여, 같지 타오르고 청춘은 할지라도 목숨을 그들의 얼마나 쓸쓸하랴? 눈이 청춘을 무엇을 봄바람이다.";

    let name =
        lastName.charAt(Math.floor(Math.random() * lastName.length)) +
        firstName.substr(Math.floor(Math.random() * firstName.length), 2);
//Math.random().toString(36).substring(0, num);return name;
};

• generateSoldier(n) : n개의 사람 수를 받아서 그만큼 병사 이름을 생성한 뒤 순환형 연결 리스트에 연결한다. (병사들로 원을 만든다.)

function generateSoldier(n) {
    let createdEl = "";
    let createdPrevEl = "";

    for (let i = 0; i < n; ++i) {
        if (i === 0) {
            createdEl = generateRandomName();
            this.insert(createdEl, "head");
        } else {
            createdEl = generateRandomName();
            this.insert(createdEl, createdPrevEl);// 저장해두었던 이전 병사를 이용해 요소를 추가함
        }
// 이전 병사를 저장하고 다음 루프에서 새로운 병사를 추가하기 위한 기존 병사로 씀
        createdPrevEl = createdEl;
    }
}

• killSoldier(m) : 매 m 번째의 병사를 죽이는 메서드로 연결 리스트의 처음부터 끝까지 탐색하는 display() 메서드를 참고하여 구현하였다. 그래서 currNode의 초깃값은 head로 똑같이 두었다.

function killSoldier(m) {
    let currNode = this.head;
    let i = 1;
    let match = -1;

    while (!(currNode.next === null)) {
 	if (i === m) {
            console.log("i=m", currNode);
            console.log();
            let temp = currNode.element;
            currNode = currNode.next;
            this.remove(temp);//this.remove(currNode.element);
            match = 1;
        } else {
            console.log("i!=m", currNode);
            console.log();
            currNode = currNode.next;
            if (match !== 1) {
                i++;
            }
        }
        console.log(
            "while종료",
            currNode.next === null,
            currNode.next.element == "head"// 이 값이 true가 되어 마지막 m번째 병사가 죽지 않는 상황임
        );
        if (currNode.next.element == "head") {
            console.log(
                "다음이 head입니다. 그럼 마지막으로 죽일 병사는",
                currNode.element
            );
            this.remove(currNode.element);
            return;
        }
    }
}

let soldiers = new LList();
soldiers.generateSoldier(10);// n명의 병사를 만듦
soldiers.display();
console.log();
soldiers.killSoldier(5);// m명의 병사를 죽임console.log("생존자는 : ");
soldiers.display();