El problema precisamente es la recursividad, no se en que página web o que profesor te ha mandado el ejercicio, pero es una metodología que se debe evitar sin excepción alguna, a menos que simplemente sea para aprender el concepto de recursividad y ya está (aunque en mi humilde opinión de nada sirve aprender eso).

En este caso en particular, la función Camion hace miles y miles de llamadas a si misma y cómo resultado da una sobrecarga en la pila, lanzando como consecuencia una esperada excepción de tipo StackOverflowException.

Ten en cuenta que son 5 paradas, sabiendo ese factor del problema entonces obviamente la función debería hacer solamente 5 llamadas a si misma, no miles .

Aparte de eso, cometes un fallo en el algoritmo el cual provoca una recursividad infinita (que es lo que provoca la excepción) y estás usando ifs anidados cuando puedes usar else if, o un switch.

Pero mi único consejo es ese, que no hagas ese tipo de funciones recursivas en la vida real, ya que son innecesarias en cualquier caso y solo conllevan problemas de este tipo, no se aprende nada de utilidad bajo mi punto de vista. Puedes convertir cualquier función recursiva en función iterativa con el uso de los búcles (for, while, etc dependiendo de las circunstancias)

En fin, aquí tienes el ejercicio funcional (con recursión):

VB.Net:

Module Module1
 
    Sub Main()
 
        Dim passengers As Integer = 50
        Dim result As KeyValuePair(Of Integer, Integer) = BusPassengers(passengers)
 
        Console.WriteLine()
        Console.WriteLine(String.Format("{0,-22} | {1,-22} | {2}",
                                        "Remaining passengers", "Pas. that left out", "Pas. that entered into"))
        Console.WriteLine()
 
        Console.WriteLine(String.Format("{0,-22}   {1,-22}   {2}",
                                        passengers.ToString("00"), result.Key.ToString("00"), result.Value.ToString("00")))
        Console.ReadKey()
 
    End Sub
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <param name="passengers">
    ''' The initial amount of passengers that are inside the bus.
    ''' </param>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <returns>
    ''' An <see cref="KeyValuePair(Of Integer, Integer)"/> instance where the
    ''' <see cref="KeyValuePair.Key"/> property contains the total amount of passengers that left out the bus, and the
    ''' <see cref="KeyValuePair.Value"/> property contains the total amount of passengers that entered into the bus.
    ''' </returns>
    ''' ----------------------------------------------------------------------------------------------------
    Private Function BusPassengers(ByRef passengers As Integer) As KeyValuePair(Of Integer, Integer)
 
        ' Bus-Stop count.
        Static stops As Integer = 0
        stops += 1
 
        ' Current amount of passengers that left out the bus in the current bus-stop.
        Static goOut As Integer
 
        ' Current amount of passengers that entered into the bus in the current bus-stop.
        Static goIn As Integer
 
        ' Total amount of passengers that left out the bus.
        Static goOutTotal As Integer
        goOutTotal += goOut
 
        ' Total amount of passengers that entered into the bus.
        Static goInTotal As Integer
        goInTotal += goIn
 
#If DEBUG Then
 
        If (stops = 1) Then
            Console.WriteLine(String.Format("{0,-16} | {1,-16} | {2,-16} | {3}",
                                            "Stop count", "Passengers Out", "Passengers In", "Total passengers"))
            Console.WriteLine()
        Else
 
 
            Console.WriteLine(String.Format("{0,-16}   {1,-16}   {2,-16}   {3}",
                                            (stops - 1).ToString("00"),
                                            goOut.ToString("00"),
                                            goIn.ToString("00"),
                                            passengers.ToString("00")))
        End If
 
#End If
 
        Select Case stops
 
            Case 1 ' Out:5, In:2, Current:47.
                goOut = 5
                goIn = 2
 
            Case 2 ' Out:3, In:4, Current:48.
                goOut = 3
                goIn = 4
 
            Case 3 ' Out:10, In:5, Current:43.
                goOut = 10
                goIn = 5
 
            Case 4 ' Out:8, In:5, Current:40.
                goOut = 8
                goIn = 5
 
            Case 5 ' Out:2, In:2, Current:40.
                goOut = 2
                goIn = 2
 
            Case Else
                Return New KeyValuePair(Of Integer, Integer)(goOutTotal, goInTotal)
 
        End Select
 
        ' Total amount of passengers that remains inside the bus.
        passengers = (passengers - goOut + goIn)
 
        BusPassengers = BusPassengers(passengers)
 
    End Function
 
End Module

C#:
En C#, al ser un lenguaje con la desventaja de no poder usar el keyword Static dentro de métodos para declarar variables estáticas cuyo valor modificado perdura en las siguientes llamadas al método, me ha costado un poquito la traducción manual de VB.Net C#, queda un poco feo por las variables pasadas por referencia goOutTotal y goInTotal y las demás, pero paso de complicarlo más o buscar la manera de simplificarlo, funciona, que es lo importante, aquí tienes:

using System.Collections.Generic;
using System.Collections;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System;
 
namespace ConsoleApplication2
{
    class Program
    {
 
        static void Main(string[] args)
        {
            int currentPassengers = 50;
            int goOutTotal = 0;
            int goInTotal = 0;
            KeyValuePair<int, int> result = BusPassengers(ref currentPassengers, ref goOutTotal, ref goInTotal);
 
            Console.WriteLine();
            Console.WriteLine(string.Format("Current Pas.: {0,2}, Pas. that left out: {1,2} | Pas. that entered into: {2,2}", 
                                            currentPassengers.ToString("00"), result.Key.ToString("00"), result.Value.ToString("00")));
            Console.ReadKey();
        }
 
        /// ----------------------------------------------------------------------------------------------------
        /// <summary>
        /// </summary>
        /// ----------------------------------------------------------------------------------------------------
        /// <param name="passengers">
        /// The current amount of passengers that are inside the bus.
        /// </param>
        /// ----------------------------------------------------------------------------------------------------
        /// <returns>
        /// An <see cref="KeyValuePair"/> instance where the
        /// <see cref="KeyValuePair.Key"/> property contains the total amount of passengers that left out the bus, and the
        /// <see cref="KeyValuePair.Value"/> property contains the total amount of passengers that entered into the bus.
        /// </returns>
        /// ----------------------------------------------------------------------------------------------------
        private static KeyValuePair<int, int> BusPassengers(ref int passengers,
                                                            ref int goOutTotal,
                                                            ref int goInTotal,
                                                            int stops = 0,
                                                            int goOut = 0,
                                                            int goIn = 0)
        {
 
            stops += 1; // Bus-Stop count.
            goOutTotal += goOut; // Total amount of passengers that left out the bus.
            goInTotal += goIn; // Total amount of passengers that entered into the bus.
 
#if DEBUG
    if (stops > 1)
    { 
        Console.WriteLine(string.Format("Stop: {0} | Pas. out: {1,2} | Pas. In: {2,2} | Total pas.: {3}",
                                        (stops - 1).ToString("00"), goOut.ToString("00"), goIn.ToString("00"), passengers.ToString("00")));
    }
#endif
 
            switch (stops)
            {
                case 1: // Out:5, In:2, Current:47.
                    goOut = 5;
                    goIn = 2;
                    break;
 
                case 2: // Out:3, In:4, Current:48.
                    goOut = 3;
                    goIn = 4;
                    break;
 
                case 3: // Out:10, In:5, Current:43.
                    goOut = 10;
                    goIn = 5;
                    break;
 
                case 4: // Out:8, In:5, Current:40.
                    goOut = 8;
                    goIn = 5;
                    break;
 
                case 5: // Out:2, In:2, Current:40.
                    goOut = 2;
                    goIn = 2;
                    break;
 
                default:
                    return new KeyValuePair<int, int>(goOutTotal, goInTotal);
            }
 
            passengers = (passengers - goOut + goIn);
            return BusPassengers(ref passengers, ref goOutTotal, ref goInTotal, stop, goOut, goIn);
 
        }
 
    }
}

Resultado de ejecución (versión VB.Net):



Saludos.

En verdad puede que tengas razón en cierta manera, pues quizás para este problema no sea necesario la recursividad para resolverlo, pero si que pienso yo que se debe aprender a pensar recursivamente.

Existen muchas cosas que se utilizan mucho que tienen implementaciones recursivas mucho más sencillas que iterativas.

Por ejemplo:

La implementación de árboles, si bien se puede hacer iterativamente, requeriría muchas lineas de código y un seguimiento del flujo del programa muy muy intenso para realizar operaciones que se expresan sencillamente utilizando la recursividad. Ejemplo de esto son las Estructuras de Datos: Árbol binario de busqueda (BST), HEAPS, AVL, RB Tree, B Tree, entre otras coas como algoritmos que trabajen sobre Grafos (BFS, DFS, PRIM, Kruskal, Bellman-Ford, Algoritmos para resolver problemas de flujo máximo).

Ah, el más sencillo ejemplo del poder de la recursividad es la solución del problema de las Torres de Hanoi. Hacerlo iterativamente es bastante tedioso

En fin, en mi opinión si bien no es recomendable usarlo para todo, un buen diseñado algoritmo recursivo es tán útil como un algoritmo iterativo.


No lo puedes declarar dentro del método, pero si lo puedes declarar en el ámbito del método, en este caso en la clase Program y perdurará en las llamadas recursivas del método, así eliminas el uso de las variables por referencia.

Salu2s