Den rekursiva tanken är ju
return 1 + addList([2,3,4,5])
om listan är tom ska du i stället returnera 0.

xam skrev:

Kod:

def addList(list):
    
    x = 0

    if sum(list) == list[0]:
        print list.pop()

    else:
        x = sum(list)
        list[:] = []
        list.append(x)
        addList(list)

Jag tror jag fick till det.

Visst är det en härlig känsla när koden ger det svar man vill ha? Dessvärre så är din funktion inte rekursiv... Det finns lite att tipsa om:

Har du tänkt på att du använder dig av den inbyggda funktionen sum()? Den gör exakt det som din addList() ska göra, alltså summera talen i en lista. Så du ska rimligtvis inte använda den färdiga funktionen utan låta addList() göra jobbet. Annars hade du ju bara kunnat göra detta, eller hur:

def addList(list):
   return sum(list)

Och faktiskt är det just detta du har gjort i din lösning, fast via en hel rad mellansteg (kanske för att övertala dig själv om att slutresultatet blev rekursivt eftersom det blev en komplicerad kod?). Du beräknar helt enkelt summan till 15 (via den inbyggda funktionen sum()) i din else-sats. Sen anropar du addList igen som då går in i din if-sats och printar ut 15 som du beräknade innan. Det är två steg och inte alls ett rekursiv tänk.

Det @Henrik E skriver är det rätta tillvägagånssättet:

Henrik E skrev:

Den rekursiva tanken är ju
return 1 + addList([2,3,4,5])
om listan är tom ska du i stället returnera 0.

Du ska alltså skriva en rekursiv funktion som förslagsvis adderar det första talet i listan med summan av resten av listan. Summan av resten av listan får du genom att skicka in den avkortade listan i addList igen. Ser du hur det blir rekursivt då? När listan är tom (helt avkortad) ska du bara returnera 0. Det är det såkallade basfallet, och det ska du sätta in i din if-sats.

Summan kommer då att räknas ut rekursivt på följande sätt:

1 + addList([2, 3, 4, 5])
1 + 2 + addList([3, 4, 5])
1 + 2 + 3 + addList([4, 5])
1 + 2 + 3 + 4 + addList([5])
1 + 2 + 3 + 4 + 5 + addList([])
1 + 2 + 3 + 4 + 5 + 0 --> 15

Koden blir väldigt få linjer:

def addList(list):
    #Här ska basfallet vara    
    return list[0] + addList(list[1:])

Är du med på hur du ska göra nu, eller känns det fortfarande bökigt med det rekursiva tänket och hur man implementerar det?



Edit:
----------------------------
Förresten, ser att du tenderar att printa ut resultatet direkt inifrån funktionen. Det vanligaste vad gäller funktioner är att man låter dem göra ett jobb, som i ditt fall räkna ut en summa, som de sedan returnerar så att den kod som anropar funktionen själv får bestämma vad som ska göras med resultatet.

Man kan då använda funktionen addList på följande sätt:

>> listan1 = [1, 2, 3, 4, 5]
>> listan2 = [5, 5]
>> summan1 = addList(listan1)  # Blir 15, men vi vill inte skriva ut det än
>> summan2 = addList(listan2)  # Blir ju 10, men vi vill inte skriva ut det än
>> print ”Summan av listorna blir”, summan1 + summan2
Summan av listorna blir 25

Senast redigerat av annlu (2016-12-09 02:33)