Fonction récursive en bash

Je veux faire une fonction qui retourne la factorielle d'un nombre en bash

Voici le code actuel qui ne fonctionne pas, quelqu'un peut me dire quel est le problème et comment le corriger? J'ai juste commencé à apprendre le bash et je ne sais pas très bien.

#!/bash/bin
factorial()
{
  let n=$1
  if (( "$n" <= "1" ))
  then return 1
  else
  factorial n-1
  return $n*$?
  fi
  return 0
}
factorial 5
echo "factorial 5 = $?"
InformationsquelleAutor FinalDestiny | 2012-03-13
  1. 32

    Il y a plusieurs syntaxe et une assez évident logique on (0)

    Une version de travail est ci-dessous:

    #!/bin/bash

factorial()
{
    if [[ $1 -le 1 ]]
    then
        echo 1
    else
        last=$(factorial $[$1-1])
        echo $(($1 * last))
    fi
}
factorial 5

    Manquante:

    1. si la syntaxe est mauvaise

    2. Appel récursif est mauvais

    3. rendement est mauvais (eval syntaxe de mauvaise qualité)

    4. shbang ligne (est /bin/bash pas /bash/bin)

    • Les codes de retour sont un seul octet, donc c'pauses pour n > 5. Pour résoudre ce problème, vous devez modifier la fonction d'écho conséquent, plutôt que de définir un code de retour.
    • +1, et +de 9000 à @tripleee. Fonctions bash devrait résonner les résultats, pas les retourner.
    • Le $[...] syntaxe est obsolète depuis des décennies. Arrêtez de l'utiliser.
    • vous ne devriez pas utiliser $[ ], il ne fonctionne que sur des nombres entiers positifs et négatifs des nombres entiers. Vous devez utiliser un utilitaire externe comme calc pour faire ce genre de travail, sauf si vous êtes positif, vous n'allez pas être en utilisant des décimales, ce qui n'est pas pris en charge. $[] n'est vraiment utile pour stocker des nombres de travailler avec les tableaux, les valeurs de retour, les boucles et les autres internes, pas pour les maths, et etc.. Esp. puisque aucune vérification de dépassement est fait (la division par zéro EST pris au piège). si vous devez l'utiliser ne pas utiliser $[] utiliser $(()) parce que $[] seront supprimés dans les futures versions de bash au total (probablement encore en mode posix)
    • En mathématiques, la factorielle d'un entier non négatif n, notée n!, est le produit de tous les positif les entiers inférieur ou égal à n. Vos commentaires sont valables bien qu'il est difficile de se débarrasser des idiomes j'ai été habitué dans les 20 dernières années...
    • un octet de 8 bits ou 2^8 chiffres. Donc bash return gamme est 0-255 (2^8 - 1). Mais je suis d'accord que le retour doit être évitée et remplacée par echo.
    • Oui. 5! == 125 <= 255; 6! = 720 >> 255
    • Oh désolé @tripleee, je n'étais pas prêter attention à un contexte de n, je pensais que vous parliez de retour numéros > 5. Je n'ai trouvé ce fil, car j'ai eu des problèmes avec l'exécution de code après l'appel de fonction récursive.

    InformationsquelleAutor Daniel Voina
  2. 17
    #!/bin/bash

function factorial() 
{ 
   if (( $1 < 2 ))
   then
     echo 1
   else
     echo $(( $1 * $(factorial $(( $1 - 1 ))) ))
   fi
}

    Cela fonctionnera mieux.

    (Il fonctionne jusqu'à 25, de toute façon, ce qui devrait être suffisant pour prouver le point sur la récursivité.)

    Pour les numéros les plus élevés, en colombie-britannique serait l'outil à utiliser, rendant la neuvième ligne du dessus:

    echo "$1 * $(factorial $(( $1 - 1 )))" | bc

    mais vous devez être un peu prudent avec la colombie-britannique --

    $ factorial 260
38301958608361692351174979856044918752795567523090969601913008174806\
51475135399533485285838275429773913773383359294010103333339344249624\
06009974551133984962615380298039823284896547262282019684886083204957\
95233137023276627601257325925519566220247124751398891221069403193240\
41688318583612166708334763727216738353107304842707002261430265483385\
20637683911007815690066342722080690052836580858013635214371395680329\
58941156051513954932674117091883540235576934400000000000000000000000\
00000000000000000000000000000000000000000

    était tout à fait une pression sur mon système pauvre!

    • Je trouve votre méthode évoquera de nombreux sous-coquille comme la somme de 1, et ce n'est pas nécessaire et très efficace. Comment éviter la création de sous-coquille?
    • Il est exact que cela peut être réécrite de façon à éviter shell interne est exécuté création, il y a une bonne réponse ici: stackoverflow.com/questions/33568055/... Merci pour ton commentaire, il m'a aidé à apprendre quelque chose de nouveau!
    InformationsquelleAutor user1070300
  3. 3

    echo-ing un résultat peut-être le seul moyen pour obtenir un résultat pour n > 5, mais la capture de l'echo ed résultat nécessite un shell interne est exécuté, ce qui signifie que la récursivité obtenez cher rapide. Une solution moins coûteuse consiste à utiliser une variable:

    factorial() {
    local -i val=${val:-($1)}
    if (( $1 <= 1 )); then
        echo $val
        return
    fi
    (( val *= $1 - 1 ))
    factorial $(( $1 - 1 ))
}

    Si vous voulez être certain que val n'est pas définie lorsque vous démarrez, utilisez un emballage de fonction:

    factorial() {
    local -i val=$1
    _fact() {
        if (( $1 <= 1 )); then
            echo $val
            return
        fi
        (( val *= $1 - 1 ))
        _fact $(( $1 - 1 ))
    }
    _fact $1
}

    Pour la comparaison:

    # My Method
$ time for i in {0..100}; do factorial $(( RANDOM % 21 )); done > /dev/null 

real    0m0.028s
user    0m0.026s
sys     0m0.001s

# A capturing-expression solution
$ time for i in {0..100}; do factorial $(( RANDOM % 21 )); done > /dev/null 

real    0m0.652s
user    0m0.221s
sys     0m0.400s
    • Des conseils judicieux. Encore votre mesure aurait été encore plus convaincante si vous n'aviez pas utilisé aléatoire d'entrée. Pour tout ce que nous savons, votre méthode a 100 chefs d'accusation de factorielle(1) tandis que l'autre a 100 chefs d'accusation de factorielle(20) 🙂
    InformationsquelleAutor kojiro
  4. 1

    Une autre mise en œuvre à l'aide de echo au lieu de return

    #!/bin/bash

factorial()
{
        if [ $1 -le 1 ]
        then
                echo 1
        else
                echo $[ $1 * `factorial $[$1-1]` ]
        fi
}
echo "factorial $1 = " `factorial $1`
    • -1: C'est juste une réécriture de @user1070300 de la réponse à l'aide de syntaxe obsolète.
    • pourquoi echo 1 en vertu de si n'est pas l'impression que l'un et à se comporter comme un type de retour ?
    InformationsquelleAutor Андрій Ковальчук
  5. 1
    clear cat

fact()

{

        i=$1
        if [ $i -eq 0 -o $i -eq 1 ]
        then
                echo 1
        else
                f=`expr $i \- 1`
                f=$(fact $f)
                f=`expr $i \* $f`
                echo $f
        fi
}

read -p "Enter the number : " n

if [ $n -lt 0 ]

then

        echo "ERROR"

else

        echo "THE FACTORIAL OF $n : $(fact $n) "
fi
    InformationsquelleAutor Sayan Roy Subho