เหตุใดการใช้ && 75 ครั้งเร็วกว่าถ้า ... fi และวิธีทำให้โค้ดชัดเจนขึ้น

ฉันมีรหัสการทำงานต่อไปนี้:

largest_prime=1
for number_under_test in {1..100}
do
  is_prime=true
  factors=''
  for ((divider = 2; divider < number_under_test-1; divider++));
  do
    remainder=$(($number_under_test % $divider))
    [ $remainder == 0 ] && [ is_prime ] && is_prime=false && factors+=$divider' '
  done
  [ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test
done
printf "\nLargest Prime= $largest_prime\n"

รหัสนี้ทำงานอย่างรวดเร็วคือ 0.194 วินาที อย่างไรก็ตามฉันพบว่า&& is_prime= falseอ่านยากนิดหน่อยและมันอาจดู (กับตาที่ไม่ได้รับการฝึกฝน) ราวกับว่ามันถูกทดสอบมากกว่าที่จะถูกตั้งค่าซึ่งเป็นสิ่งที่มันทำ ดังนั้นฉันจึงลองเปลี่ยนค่า&&เป็น a if...thenและทำงานได้ - แต่ช้าลง 75 เท่าเวลา 14.48 วินาที มันเห็นได้ชัดเจนที่สุดในจำนวนที่สูงขึ้น

largest_prime=1
for number_under_test in {1..100}
do
  is_prime=true
  factors=''
  for ((divider = 2; divider < number_under_test-1; divider++));
  do  
    remainder=$(($number_under_test % $divider))
    if ([ $remainder == 0 ] && [ $is_prime == true ]); then
      is_prime=false
      factors+=$divider' '
    fi  
  done
  [ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test
done  
printf "\nLargest Prime= $largest_prime\n"

มีใครบ้างที่จะต้องมีความชัดเจนของบล็อกโดยไม่มีความช้า?

อัปเดต (1/4/2015 10:40 น. EST)

ข้อเสนอแนะที่ยอดเยี่ยม! ตอนนี้ฉันใช้สิ่งต่อไปนี้ ข้อเสนอแนะอื่น ๆ ?

largest_prime=1
separator=' '
for number_under_test in {1..100}; {
  is_prime=true
  factors=''
  for ((divider = 2; divider < (number_under_test/2)+1; divider++)) {
    remainder=$(($number_under_test % $divider))
    if [ $remainder == 0 ]; then
      is_prime=false
      factors+=$divider' '
    fi
  } 
  if $is_prime; then
    printf "\n${number_under_test} IS prime\n\n"
    largest_prime=$number_under_test
  else
    printf "${number_under_test} is NOT prime, factors are: "
    printf "$factors\n"
  fi
}
printf "\nLargest Prime= $largest_prime\n"

นั่นเป็นเพราะคุณวางไข่ sub-shell ทุกครั้ง:

if ([ $remainder == 0 ] && [ $is_prime == true ]); then

เพียงแค่ลบวงเล็บ

if [ $remainder == 0 ] && [ $is_prime == true ]; then

หากคุณต้องการจัดกลุ่มคำสั่งมีไวยากรณ์ที่ต้องทำในเชลล์ปัจจุบัน :

if { [ $remainder == 0 ] && [ $is_prime == true ]; }; then

(จำเป็นต้องใช้เครื่องหมายอัฒภาคต่อท้ายดูคู่มือ )

โปรดทราบว่า[ is_prime ]ไม่เหมือนกับ[ $is_prime == true ]: คุณสามารถเขียนเป็นเพียง$is_prime(โดยไม่ต้องวงเล็บ) ซึ่งจะเรียกใช้ในตัวtrueหรือfalseคำสั่งทุบตี
[ is_prime ]เป็นการทดสอบที่มีอาร์กิวเมนต์หนึ่งสตริง "is_prime" - เมื่อ[ได้รับอาร์กิวเมนต์เดี่ยวผลลัพธ์จะสำเร็จหากอาร์กิวเมนต์ไม่ว่างเปล่าและสตริงตัวอักษรนั้นจะไม่ว่างเสมอดังนั้นจึงเป็น "จริง" เสมอ

เพื่อความสะดวกในการอ่านฉันจะเปลี่ยนบรรทัดที่ยาวมาก

[ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test

ไปยัง

if [ $is_prime == true ]; then
  echo "${number_under_test} is prime!"
else 
  echo "${number_under_test} is NOT prime (factors= $factors)"
  # removed extraneous [ $is_prime == true ] test that you probably
  # didn't notice off the edge of the screen
  largest_prime=$number_under_test
fi

อย่าประมาทช่องว่างเพื่อดูความชัดเจน

ฉันคิดว่าคุณกำลังทำงานหนักเกินไปกับหน้าที่ของคุณ พิจารณา:

unset num div lprime; set -- "$((lprime=(num=(div=1))))"
while [     "$((     num += ! ( div *= ( div <= num   ) ) ))" -eq \
            "$((     num *=   ( div += 1 )   <= 101   ))" ]    && {
      set   "$(( ! ( num %      div )         * div   ))"     "$@"
      shift "$(( !    $1 +    ( $1 ==  1 )    *  $#   ))"
}; do [ "$div" -gt "$num" ] && echo "$*"      
done

การคำนวณทางคณิตศาสตร์ของเชลล์นั้นสามารถประเมินเงื่อนไขจำนวนเต็มได้ด้วยตัวของมันเอง มันไม่ค่อยต้องการการทดสอบมากเกินไปและ / หรือการมอบหมายภายนอก นี้เป็นหนึ่งในwhileห่วงซ้ำลูปซ้อนกันของคุณค่อนข้างดี:

แน่นอนว่ามันไม่ได้พิมพ์ออกมาเท่าไรนักฉันไม่ได้เขียนอะไรมากมายนัก แต่ยกตัวอย่างเช่นตั้งเพดานเป็น 16 แทนที่จะเป็น 101 เท่าที่เขียนไว้ด้านบนและ ...

2
3
4 2
5
6 3 2
7
8 4 2
9 3
10 5 2
11
12 6 4 3 2
13
14 7 2
15 5 3

มันทำงานได้แน่นอน และมันต้องการอย่างน้อยมากเพื่อประมาณผลลัพธ์ของคุณ:

...
do [ "$div" -eq "$num" ] && shift &&
   printf "$num ${1+!}= prime.${1+\t%s\t%s}\n" \
          "factors= $*"                        \
          "lprime=$(( lprime = $# ? lprime : num ))"
done

แค่ทำอย่างนั้นมากกว่าechoและ ...

1 = prime.
2 = prime.
3 = prime.
4 != prime.     factors= 2      lprime=3
5 = prime.
6 != prime.     factors= 3 2    lprime=5
7 = prime.
8 != prime.     factors= 4 2    lprime=7
9 != prime.     factors= 3      lprime=7
10 != prime.    factors= 5 2    lprime=7
11 = prime.
12 != prime.    factors= 6 4 3 2        lprime=11
13 = prime.
14 != prime.    factors= 7 2    lprime=13
15 != prime.    factors= 5 3    lprime=13

งานนี้busyboxมา มันพกพาได้รวดเร็วและใช้งานง่าย

ปัญหา subshell ของคุณจะเกิดขึ้นในเปลือกหอยมากที่สุด แต่มันคือโดยไกล , เฉียบพลันมากที่สุดในbashเปลือก ฉันสลับไปมาระหว่างทำ

( [ "$div" -gt "$num" ] ) && ...

... และวิธีที่ฉันเขียนไว้ข้างบนในหลาย ๆ shell สำหรับเพดาน 101 และdashทำได้โดยไม่ต้อง subshell ใน. 0.17 วินาทีและกับ subshell ใน 1.8 วินาที busybox.149 และ 2, zsh .149 และ 4, bash.35 และ 6 และksh93ใน. 149 และ. 160 ksh93ไม่แยกสำหรับ subshells ตามที่เชลล์อื่น ๆ ต้องทำ ดังนั้นอาจเป็นปัญหาไม่มาก subshell ในขณะที่มันเป็นเปลือก