Fråga om Python uppgift

Du skall alltså skriva ett Python-program som består av:
En procedur dec2bin som tar ett tal som indata och skriver ut värdet i binär form. Proceduren kan, men behöver inte, ta andra värden som indata också.
Ett huvudprogram som läser in ett antal tal från användaren, och anropar proceduren dec2bin för varje.
Det räcker att koden kan hantera tal mellan 0 och 65535, och den skall kunna ange om talen ryms i en byte (8 bitar) eller om det krävs 16 bitar. Talen skall
skrivas ut med 8 bitar om de ryms i det, annars med 16 bitar om de ryms i det. Större tal får, men behöver inte, hanteras.

Uträkning och utskrivning av antal bitar som behövs kan göras antingen i huvudprogrammet eller i dec2bin proceduren. Den pseudo-kod ni fått gör det i huvudprogrammet och anropar dec2bin med antalet som en extra parameter.

Blev det något klarare av den omskrivningen av uppgiften?

Nej, men jag har löst en och annan programmeringsuppgift i diverse språk genom årens lopp så jag har fått viss vana på det.

När jag läst den här uppgiften slog det mig att jag antingen är dum i huvudet eller totalt iq-befriad. Ledsen att jag inte kan hjälpa till!

Jag kanske missar något, men på vilket sett har inte läraren koll på termer, och vad har detta med minneshantering att göra?

Uppgiften går ut på att konvertera ett heltal till binär form och även skriva ut om talet får plats i 8bit eller ej 🤷🏼‍♂️

@milkshake91

Vad gäller antalet bitar, när du konverterat det decimala talet till ett binärt, kolla längden på det binära talet (antar att du använder en string för att lagra det). Är talet 1-7 siffror långt, fyll ut med inledande nollor till det är 8 siffror långt. Är talet 9-15 siffror långt, fyll ut med inledande nollor till talet är 16 siffror långt. (Kolla talets längd och fyll ut med inledande nollor till närmaste större 8-tal.)

För positiva heltal kan du rent matematiskt kan du räkna ut detta genom att addera ett till talet, ta 2-logaritmen och avrunda uppåt till närmaste heltal. Gissar att den lösning är diskvalificerad här då den lämpligen löses genom att utnyttja math modulen i Python.

Annars kan du tänka så här: hur översätts en binärt tal till decimalt? Tar vi 1010 som exempel blir detta
Edit: notera att man tar bitarna höger till vänster då minst signifikanta biten (den som ska multipliceras med 2^0, då det är position 0) alltid är längst till höger.

0 * 2^0 + 1 * 2^1 + 0 * 2^2 + 1 * 2 ^ 3 =
0 * 1 + 1 * 2 + 0 * 4 + 1 * 8 =
0 + 2 + 0 + 8 = 
10

Omvänt, antal bitar som minst krävs för att representera talet 10 är positionen plus 1 (då datorvärlden börjar räkna positioner från noll...) på den bit vars vikt (2^pos = vikt) är lika med eller större än 10

I.e. något åt det här hållet om vi antar att värdet är ett positivt heltal (faktum är att det även fungerar med noll, d.v.s. alla tal i ℕ)

sätt antal_bitar till 0
gör följande till dess att loopen explicit avbryts
  addera ett till antal_bitar
  kolla om 2 upphöjt i värdet hos antal_bitar är större än ditt tal, om "ja" avbryt loopen
  annars kör loopen igen
antal_bitar har nu det värde du letar efter

Du behöver inte kolla om antal_bitar överstiger 16 i algoritmen ovan, Python kan hantera hur stora heltal som helst (givet att man har tillräckligt med RAM, det lär vara ett totalt icke-problem i praktiken).

I detta fall begränsas ändå antal bitar då uppgiften säger att dela in talet i en av fyra klasser

1. negativa tal, dessa förkastas

2. tal större än 65535, d.v.s. tal som behöver mer än 16 bitar för att representeras, dessa förkastas

3. tal som kan representeras med 8 eller färre bitar

4. tal som kräver 8 eller fler bitar, men kan representeras med 16 eller färre bitar

När du har det binära talet i en sträng, ta reda på hur många bytes som krävs för att rymma det.

Det kan göras genom att dividera längden på det binära talet med 8 (antalet bitar på en byte) och runda av resultatet till närmaste högre heltal. Två sätt att göra det på:

1. math.ceil(len(bin_tal) / 8) (kräver att math importeras)
2. (len(bin_tal) + 8 - 1) // 8

För att sedan få till inledande nollor kan strängfunktionen zfill användas. zfill fyller ut med inledande nollor tills strängen når den önskade längden. Den önskade längden är antalet bytes som krävs för att rymma talet multiplicerat med 8 (antalet bitar på en byte).

print("123".zfill(8)) ger alltså "00000123" medan print("123".zfill(16)) ger "0000000000000123".

Skicka med antalet bitar som krävs till proceduren (inte strikt nödvändigt, men gör saker enklare)
Ha en loop inne i proceduren som kör 8 eller 16 steg (beroende på hur många bitar som krävs för att rymma talet) och i varje steg så lägger du på antingen "0" eller "1" (beroende på vad det skall vara på den platsen) till resultatsträngen.
Gör du så kommer inledande nollor att komma med automatiskt.

Finns ju ett tips i beskrivningen av uppgiften: skicka med bitbredd till dec2bin(). Detta andra argument kommer i praktiken att vara 8 eller 16 i detta fall, men framförallt ger ett sådant argument en begränsning till hur många tecken du måste skriva ut -> utnyttja det!

Antag denna signatur

def dec2bin(value, bit_width):
    ....

du kan då lösa problem på detta sätt:

sätt bit_pos till bit_width minus ett
så länge som bit_pos är noll eller större
    kolla om biten "2 upphöjt till bit_pos" är satt, i så fall skriv ut '1' annars skriv ut '0'
    minska bit_pos med ett

Uppgiften säger att man ska skriva en funktion som skriver ut strängen och inte returnerar något.

Dessutom så borde du inte alls anropa dec2bin inifrån dec2bin.
Det går visserligen alldeles utmärkt att göra så och lösa uppgiften med hjälp av en rekursiv procedur, men dels tror jag inte att ni har gått igenom rekursion i kursen ännu, och dels så skulle proceduren behöva delvis andra argument då.