반복문

for문과 while문

• for문을 사용하는 경우
  • 반복 횟수가 비교적 명확할 때
  • 배열, 문자열 내부를 순회할 때
  • 반복문의 중첩이 필요할 때
• while문을 사용하는 경우
  • 반복 횟수가 명확하지 않을 때

---

• 실습 (조건문 + 반복문)

/* 
주어진 문자열의 문자열의 길이가 10 이상이라면,
해당 문자열의 모든 문자를 대문자로 변경하여 하나씩 문자를 출력하도록 코드를 구현하세요.
*/
let str = 'javascriptjavaspring';

if(str.length >= 10) {
    // str = str.toUpperCase();
    for (i=0;i<str.length;i++) {
        console.log(str[i].toUpperCase()); 
    }
}

• str = str.toUpperCase(); ->console.log(str[i].toUpperCase()); 로 toUpperCase()를 console.log에 한 번에 적용시켜 코드를 줄일 수 있었음!

• 구구단

for (let i = 2; i < 10; i++) {
    console.log(`${i}단 시작합니다.`);
    for (let j = 1; j < 10; j++) {
        console.log(`${i} X ${j} = ${i*j}`);
    }
    console.log(`${i}단 끝났습니다.\n`);
}

-> 시작할 때 ㅁ단 시작합니다. , 끝날 때 ㅁ단 끝났습니다. + 공백을 넣어줌으로 깔끔한 구구단.

---

함수

// 함수선언문
function declared() {
    console.log('함수선언문');
}

// 함수표현식
let declared = function() {
    console.log('함수표현식');
}
declared();
// 함수를 declared 변수에 '할당', 기능은 동일

• 함수표현식 : 변수에 함수를 저장하여 함수를 사용할 때나 불러올 때 용이함 (함수선언문 보다 多 사용)

• 구구단 (함수)

// 구구단 n단을 출력하는 함수를 정의하고 호출
let multiplication = function(n) {
    if(n >= 2 && n < 10) {
        for(i = 1; i < 10; i++) {
            console.log(`${n} X ${i} = ${n*i}`);
        }
    } else {
        console.log("2부터 9까지의 숫자만 입력 가능");
    }
}
multiplication(7)

• 구구단 (변형)

// 1 ~ count 사이의 구구단을 출력하는 함수를 정의하고 호출

function multiplication(n, count) {
    if(n >= 2 && n < 10) {
        for(let i = 1; i < count + 1; i++) {
            console.log(`${n} X ${i} = ${n*i}`);
        }
    } else {
        console.log("2부터 9까지의 숫자만 입력 가능");
    }
}
multiplication(2,5);

---

실습

• 1번

let result = 0;

function sumTo(num) {
    for(let i = 0; i < num + 1; i++) {
        result += i;
    }
    return result;
} 
console.log(sumTo(10));

• 2번

// 수(num)를 입력받아 1부터 num까지의 정수로 구성된 문자열을 리턴

let str = "";

function makeDigits(num) {
    for(i=1; i<num+1; i++) {
        str += i;
    }
    return str;
  }
console.log(makeDigits(5));

• 3번

// 수(num)를 입력받아 1부터 num까지의 정수로 구성된 문자열을 리턴
// "1-2-3-4-5" , "1-2-3-4-5-6-7"처럼 출력
// "1"을 고정 -> `-숫자`가 추가되게 진행

let str = "1";
let count = 2;

function makeDigits2(num) {
    while(count < num + 1) {
        str += `-${count}`; // `-숫자` 추가
        count++;
    }
    return str;
}
console.log(makeDigits2(5));

// function makeDigit2(num) {

//     let result = "";
//     let count = 1;
//     while(count <= num) {
//         if(count === num) {
//             result += count;
//         } else {
//             result += count + "-";
//         }
//         count++;
//     }

//     return result;
// }

// console.log(makeDigit2(5)); // "1-2-3-4-5"

• 4번

// 수를 입력받아 1부터 해당 수까지의 수 중에서 3의 배수로만 구성된 문자열을 리턴

let result = "";
function makeMultiplesOfDigit(num) {
    for(i=1; i<num+1; i++) {
        if(i % 3 === 0) {
            result += i;
        }
    }
    return result;
}
let output = makeMultiplesOfDigit(9);
console.log(output);

• 5번

// 문자열과 문자를 입력받아 문자열에서 문자(letter)가 등장하는 횟수를 리턴

let result = 0;

function countCharacter(str, letter) {
    for (let i = 0; i < str.length; i++) {
        if (str[i] === letter) { // str[i]가 letter와 일치 여부
            result++; //result += 1;
        } else if (str === "") { // str이 빈 문자열일 때
            return 0;
        }
    }
    return result;
}
let output = countCharacter('I am a hacker', 'a');
console.log(output);

• 6번

// 숫자 문자열을 입력받아 문자열을 구성하는 각 숫자 중 가장 큰 수를 나타내는 숫자를 리턴

// 가장 큰 수가 들어가는 변수 maxnum을 만들고
// str[i] > maxnum 이면 maxnum에 str[i]를 넣어서 가장 큰 수로 만드는 것을 반복

function getMaxNumberFromString(str) {
    let maxnum = 0;

    for(i = 0; i<str.length; i++) {
        if(str[i] > maxnum) {
            maxnum = Number(str[i]);
        } else if(str === "") {
            return '0';
        }
    }
    return maxnum;
}
console.log(getMaxNumberFromString('123'));

• 7번

// 문자열과 두 개의 문자(from, to)를 입력받아
// 문자열에 등장하는 특정 문자(from)가 다른 문자(to)로 바뀐 문자열을 리턴


// str을 for문으로 반복
// 반복하면서 replaceAll() 메서드를 통해 단어 변환

// function replaceAll(str, from, to) {
//     str = str.replaceAll(from, to)
//     return str;
// }
// console.log(replaceAll('loop', 'o', 'e'));

function replaceAll(str, from, to) {
	let result = '';
  	
  	for(i = 0; i < str.length; i++) {
    	if(str[i] === from) {
        	result += to;
        } else {
        	result += str[i];
        }
    }
    return result;
}
console.log(replaceAll('loop', 'o', 'e'));

• 8번

// 수를 입력받아 약수(factor)의 합을 리턴

let result = 0;

function getSumOfFactors(num) {
  for(i = 1; i < num + 1; i++) {
    if(num % i === 0) {
      result += i;
    }
  }
  return result;
}

console.log(getSumOfFactors(12));

• 9번 (소수)
  • 소수 : 나머지가 1과 자신

// 1 이상의 자연수를 입력받아 소수(prime number)인지 여부를 리턴

function isPrime(num) {
  
  if(num === 1) return false;

  for(i = 2; i < num; i++) { // num이 3이상 일때 
    if(num % i === 0) {
      return false; // num이 2이상의 수로 나누어 떨어지는게 하나라도 있으면 소수 x
    } 
  }
  return true;
}
console.log(isPrime(15));
}
console.log(isPrime(15));

• 10번 (hard)

// 2 이상의 자연수를 입력받아 2부터 해당 수까지의 소수(prime number)들을 리턴
// 이중 반복문(double for loop)을 사용

function listPrimes(num) {
    let result = '2';

    for(let i = 3; i < num; i+=2) {
        // 각각 i의 값이 소수인지 판별
        // 반복문 사용
        let check = false;
        let sqrt = parseInt(Math.sqrt(i));
        for(let j = 2; j <= sqrt; j++) {
            if(i % j === 0) {
                // 소수라면
                check = true;
            }
        }
        if(!check) {
            result += "-" + i; 
        }
    }
return result;
}

• 11번 (slice 활용!)

// 문자열을 입력받아 해당 문자열에 등장하는
// 각 문자(letter)를 가지고 만들 수 있는 길이 2의 문자열들을 리턴
// 빈 문자열을 입력받은 경우에는 빈 문자열을 리턴
// 이중 반복문을 사용
// 'ab'; --> 'aa,ab,ba,bb'
// '123'; --> '11,12,13,21,22,23,31,32,33'

// [0],[0] ->  [0],[1] -> [1],[0] -> [1], [1] ...
// 1. i=0일때 j=0,1,2 ...에서 str.length만큼 반복해서 result에 대입
// 2. i=1일때 j=0,1,2 ...에서 str.length만큼 반복해서 result에 대입
// 3. 앞의 과정 반복
// 4. slice로 마지막 , 없애주기!
function makePermutations(str) {
  let result = "";

  for (i = 0; i < str.length; i++) {
    for (j = 0; j < str.length; j++) {
      if (str == "") {
        return "";
      }
      result += `${str[i]}${str[j]},`; // result에 결과물들을 문자열로 넣음
    }
  }
  return result.slice(0, result.length - 1);
}
console.log(makePermutations("abc"));

• 12번
  • 같은 index와의 비교를 제외하기위해 두번째 for문은 j = i + 1로 설정

// 문자열을 입력받아 해당 문자열에 중복된 문자(letter)가 존재하는지 여부를 리턴

// * 같은 index와의 비교는 제외 *
// 1. for1에 있는 문자가 for2에 있는지 돌면서 확인, 있으면 true, 없으면 false
// 2. 끝까지 돌면서 확인
// 3. 빈 문자열 입력받으면 fasle
function hasRepeatedCharacter(str) {
  for (i = 0; i < str.length; i++) {
    for (j = i + 1; j < str.length; j++) {
      if (str[i] === str[j]) {
        return true;
      } else if (str === "") {
        return false;
      }
    }
  }
  return false;
}
console.log(hasRepeatedCharacter("asdrty"));

• 13번

// 문자열을 입력받아 해당 문자열을 처음부터 한 글자(letter)씩 다시 작성하려고 합니다.
// 이 때, 한 글자를 추가할 때마다 부분적으로 완성된 문자열을 전부 이어붙인 문자열을 리턴
// 빈 문자열을 입력받은 경우에는 빈 문자열을 리턴
// `flower' -> 'fflfloflowfloweflower'
// 4자리면 -> [0], [0] [1], [0] [1] [2], [0] [1] [2] [3]
// (for1은 큰 틀: 4번 반복, for2는 작은 틀: 반복시 +1씩)

// 1. for1은 0 ~ length
// 2. for2는 length-1 부터 --로
function makeMarginalString(str) {
  let result = "";
  for (i = 0; i < str.length; i++) {
    for (j = 0; j < i + 1; j++) {
      result += str[j];
    }
  }
  return result;
}
console.log(makeMarginalString("flower"));

---

정리

• for문과 while문은 서로 바꿔서 쓸 수 있다.
• 함수선언문보다 함수표현식을 더 많이 쓴다.