3.22. 배열

#!/bin/bash


area[11]=23
area[13]=37
area[51]=UFOs

# 배열 멤버들은 꼭 연속적이지 않아도 되는 것에 주의하세요.

# 배열중 몇몇 멤버들을 초기화 시키지 않은채 비워 놔도 괜찮습니다.


echo -n "area[11] = "
echo ${area[11]}
echo -n "area[13] = "
echo ${area[13]}
# {중괄호} 가 필요합니다.
echo "area[51]의 값은 ${area[51]} 입니다."

# 초기화 안 된 배열 변수는 빈 칸을 찍을 것입니다.
echo -n "area[43] = "
echo ${area[43]}
echo "(area[43] 은 할당되지 않았습니다)"

echo

# 두 배열 변수의 합을 세 번째에 할당합니다.
area[5]=`expr ${area[11]} + ${area[13]}`
echo "area[5] = area[11] + area[13]"
echo -n "area[5] = "
echo ${area[5]}

area[6]=`expr ${area[11]} + ${area[51]}`
echo "area[6] = area[11] + area[51]"
echo -n "area[6] = "
echo ${area[6]}
# 문자열에 정수를 더하는 것은 허용되지 않기 때문에 동작하지 않습니다.

echo
echo
echo

# -----------------------------------------------------------------
# 다른 배열인 "area2"를 봅시다.
# 배열 변수에 값을 할당하는 다른 방법을 보여줍니다.
# array_name=( XXX YYY ZZZ ... )

area2=( zero one two three four)

echo -n "area2[0] = "
echo ${area2[0]}
# 아하, 배열 인덱스 값이 0부터 시작하는군요(배열의 첫번째 요소는 [0]이지 [1]이 아닙니다).

echo -n "area2[1] = "
echo ${area2[1]}  # [1]이 배열의 두번째 요소가 됩니다.
# -----------------------------------------------------------------


echo
echo
echo

# -----------------------------------------------
# 또 다른 배열 "area3".
# 배열 변수에 값을 할당하는 또 다른 방법.
# array_name=([xx]=XXX [yy]=YYY ...)

area3=([17]=seventeen [24]=twenty-four)

echo -n "area3[17] = "
echo ${area3[17]}

echo -n "area3[24] = "
echo ${area3[24]}
# -----------------------------------------------


exit 0

#!/bin/bash

declare -a colors
# 배열을 크기 지정없이 선언하게 해줍니다.

echo "좋아하는 색깔을 넣으세요(빈 칸으로 구분해 주세요)."

read -a colors
# 'read' 의 특별한 옵션으로 배열에 읽은 값을 넣어 줍니다.

echo

  element_count=${#colors[@]} # 배열의 총 갯수를 알아내기 위한 특별한 문법
# element_count=${#colors[*]} 도 같습니다.
index=0

# 배열의 모든 요소를 보여줍니다.
while [ $index -lt $element_count ]
do
  echo ${colors[$index]}
  let "index = $index + 1"
done
# 각 배열 요소는 한 줄에 하나씩 찍히는데
# 이렇게 하기 싫으면 echo -n "${colors[$index]} " 라고 하세요.

echo

# 배열의 모든 요소를 다시 보여주는데 이번에는 좀 더 우아한 방법을 씁니다.
  echo ${colors[@]}
# echo ${colors[*]} 도 똑같이 동작합니다.


echo

exit 0

#!/bin/bash

# 불완전한 버블 정렬

# 버블 정렬 알고리즘을 다시 생각해 보세요. 이 스크립트에서는...

# 정렬할 배열을 매번 탐색할 때 마다 인접한 두 원소를 비교해서 순서가 
# 다르면 두 개를 바꿉니다.
# 첫번째 탐색에서는 "가장 큰" 원소가 제일 끝으로 갑니다.
# 두번째 탐색에서는 두번째로 "가장 큰" 원소가 끝에서 두 번째로 갑니다.
# 이렇게 하면 각 탐색 단계는 배열보다 작은 수 만큼을 검색하게 되고,
# 뒤로 갈수록 탐색 속도가 빨라지는 것을 느낄 수 있을 겁니다.


exchange()
{
  # 배열의 두 멤버를 바꿔치기 합니다.
  local temp=${Countries[$1]} # 바꿔치기할 두 변수를 위한 임시 저장소
  Countries[$1]=${Countries[$2]}
  Countries[$2]=$temp
  
  return
}  

declare -a Countries  # 변수 정의, 밑에서 초기화 되기 때문에 여기서는 안 써도 됩니다.

Countries=(Netherlands Ukraine Zair Turkey Russia Yemen Syria Brazil Argentina Nicaragua Japan Mexico Venezuela Greece England Israel Peru Canada Oman Denmark Wales France Kashmir Qatar Liechtenstein Hungary)
# X로 시작하는 나라 이름은 생각이 안 나네요, 쩝...

clear  # 시작하기 전에 화면을 깨끗이 지우고...

echo "0: ${Countries[*]}"  # 0번째 탐색의 배열 전체를 보여줌.

number_of_elements=${#Countries[@]}
let "comparisons = $number_of_elements - 1"

count=1 # 탐색 횟수.

while [ $comparisons -gt 0 ]   # 바깥쪽 루프의 시작
do

  index=0  # 각 탐색 단계마다 배열의 시작 인덱스를 0으로 잡음

  while [ $index -lt $comparisons ] # 안쪽 루프의 시작
  do
    if [ ${Countries[$index]} \> ${Countries[`expr $index + 1`]} ]
    # 순서가 틀리면...
    # \> 가 아스키 비교 연산자였던거 기억나시죠?
    then
      exchange $index `expr $index + 1`  # 바꿉시다.
    fi  
    let "index += 1"
  done # 안쪽 루프의 끝
  

let "comparisons -= 1"
# "가장 큰" 원소가 제일 끝으로 갔기 때문에 비교횟수를 하나 줄일 필요가 있습니다.

echo
echo "$count: ${Countries[@]}"
# 각 탐색 단계가 끝나면 결과를 보여줍니다.
echo
let "count += 1"   # 탐색 횟수를 늘립니다.

done  # 바깥쪽 루프의 끝

# 끝!

exit 0

#!/bin/bash

# sieve.sh
# 에라토스테네스의 체(Sieve of Erastosthenes)
# 소수를 찾아주는 고대의 알고리즘

# 이 스크립트는 똑같은 C 프로그램보다 
# 두 세배는 느리게 동작합니다.

LOWER_LIMIT=1
# 1부터
UPPER_LIMIT=1000
# 1000까지
# (시간이 주체하지 못할 정도로 남아 돈다면 
# 이 값을 더 높게 잡아도 됩니다.)

PRIME=1
NON_PRIME=0

let SPLIT=UPPER_LIMIT/2
# 최적화:
# 오직 상한값의 반 만 확인해 보려고 할 경우


declare -a Primes
# Primes[] 은 배열입니다.


initialize ()
{
# 배열을 초기화

i=$LOWER_LIMIT
until [ $i -gt $UPPER_LIMIT ]
do
  Primes[i]=$PRIME
  let "i += 1"
done
# 무죄가 밝혀지기 전에는 배열의 모든 값이 유죄(소수)라고 가정
}

print_primes ()
{
# Primes[]의 원소중 소수라고 밝혀진 것들을 보여줍니다.

i=$LOWER_LIMIT

until [ $i -gt $UPPER_LIMIT ]
do

  if [ ${Primes[i]} -eq $PRIME ]
  then
    printf "%8d" $i
    # 숫자당 8칸을 주어 예쁘게 보여줍니다.
  fi
  
  let "i += 1"
  
done

}

sift ()
{
# 소수가 아닌 수를 걸러냅니다.

let i=$LOWER_LIMIT+1
# 1이 소수인것은 알고 있으니까 2부터 시작합니다.

until [ $i -gt $UPPER_LIMIT ]
do

if [ ${Primes[i]} -eq $PRIME ]
# 이미 걸러진 숫자(소수가 아닌 수)는 건너뜁니다.
then

  t=$i

  while [ $t -le $UPPER_LIMIT ]
  do
    let "t += $i "
    Primes[t]=$NON_PRIME
    # 모든 배수를 소수가 아니라고 표시합니다.
  done

fi  

  let "i += 1"
done  


}


# 함수들을 순서대로 부릅니다.
initialize
sift
print_primes
echo
# 이런것을 바로 구조적 프로그래밍이라고 한답니다.

exit 0