Pourquoi utiliser && 75 fois plus rapidement que si… fi et comment rendre le code plus clair

J'ai le code de travail suivant:

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"

Ce code court vite est de 0.194 secondes. Cependant, j’ai trouvé le && is_prime= falselecteur un peu difficile à lire et il pourrait sembler (à l’œil non averti) qu’il était en train d’être testé, plutôt que réglé, ce qui est le cas. Alors j'ai essayé de changer le &&en un if...thenet cela fonctionne - mais est 75 fois plus lent à 14,48 secondes. C'est surtout visible sur les nombres les plus élevés.

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"

Y at-il était d'avoir la clarté du bloc sans la lenteur?

Mise à jour (1/4/2015 10:40 am EST)

Excellent retour J'utilise maintenant ce qui suit. Pas d'autres commentaires ?

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"

C'est parce que vous créez un sous-shell à chaque fois:

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

Il suffit d'enlever les parenthèses

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

Si vous souhaitez grouper des commandes, il existe une syntaxe pour le faire dans le shell actuel :

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

(le point-virgule final est obligatoire, voir le manuel )

Notez que ce [ is_prime ]n'est pas la même chose que [ $is_prime == true ]: vous pourriez écrire cela simplement $is_prime(sans crochets) ce qui invoquerait la commande trueou falsecommande intégrée bash .
[ is_prime ]est un test avec un seul argument, la chaîne "is_prime" - lorsqu'un [seul argument est attribué, le résultat est successif si l'argument n'est pas vide et cette chaîne littérale est toujours non vide, d'où toujours "true".

Pour la lisibilité, je changerais la très longue ligne

[ $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

Ne sous-estimez pas les espaces pour améliorer la clarté.

Je pense que vous travaillez trop dur sur votre fonction. Considérer:

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

L'arithmétique Shell est assez capable d'évaluer des conditions entières par elle-même. Il a rarement besoin de trop de tests et / ou de missions externes. Cette whileboucle duplique assez bien vos boucles imbriquées:

Bien sûr, ça n'imprime pas beaucoup, je n'ai pas écrit beaucoup, mais, par exemple, le plafond est fixé à 16 plutôt qu'à 101 comme il est écrit ci-dessus et ...

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

C'est vraiment faire le travail. Et il en faut très peu pour se rapprocher de votre sortie:

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

Je fais juste ça plutôt que le echoet ...

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

Cela fonctionne dans busybox. Il est très portable, rapide et facile à utiliser.

Votre problème de sous-coquille va se produire dans la plupart des coquilles, mais il est de loin le plus grave dans une bashcoquille. J'ai alterné entre faire

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

... et la façon dont je l'ai écrit ci-dessus dans plusieurs obus pour un plafond de 101. Je l' dashai fait sans sous-shell en 0,017 seconde et avec le sous-shell en 1,8 seconde. busybox.149 et 2, zsh. 149 et 4,bash 0,35 et 6, et ksh93en 0,149 et 0,60. ksh93ne fourche pas pour les sous-coquilles comme les autres coquilles doivent. Alors peut-être que le problème n'est pas tant le sous-shell que le shell .