1    #----------------------------------------------------------------------------------------
2    # 1. Olvassa be a telkek.txt állományban található adatokat, s annak felhasználásával
3    #    oldja meg a következő feladatokat!
4    #----------------------------------------------------------------------------------------
5    def F1():
6        fbe=open('telkek.txt','r')
7    
8        N=int(fbe.readline().strip())   # első sor a telkek száma, külön olvassuk be
9    
10       for sor in fbe:
11           sor=sor.strip().split()
12           sor=list(map(int,sor))    # minden eleme int típusú lesz
13           telkek[sor[0]]=sor[1:]    # a sor, mint lista 0. eleme a szótár kulcsa,
14                                     # a "maradék" lista a kulcshoz tartozó érték (bejegyzés)
15       fbe.close()
16   #----------------------------------------------------------------------------------------
17   # 2. Hány métert kell annak gyalogolnia, aki körbe akarja járni a két utcát?
18   #    A kiszámított távolságot írassa ki a képernyőre!
19   #----------------------------------------------------------------------------------------
20   def F2():
21       print('2. feladat')
22       global utcahossz    # 7. feladathoz felhasználjuk
23       utcahossz=0    # méterben a Gazdagsor utca hossza - itt páratlan házszámok vannak
24       for kulcs in telkek:
25           if kulcs%2==1:      # Gazdagsoron vagyunk, páratlan házszám
26               utcahossz+=telkek[kulcs][0]     # kulcshoz egy lista tartozik, első eleme
27                                               # a szélesség
28       seta=2*utcahossz+160
29       print(f'A körbejárás {seta} méter sétát jelent!\n')
30   #----------------------------------------------------------------------------------------
31   # 3. Az önkormányzat előírásai szerint a 20 m széles vagy annál keskenyebb telkek esetén
32   #    teljes utcafront beépítést kell alkalmazni. Határozza meg és a képernyőre írassa ki,
33   #    hogy ez hány telekre vonatkozik a Jólétsoron!
34   #----------------------------------------------------------------------------------------
35   def F3():
36       print('3. feladat')
37       telek_db=0
38       for kulcs,bejegyzes in telkek.items():
39           # páros házszámok, azaz Jólétsoron vagyunk és telek szélessége <= 20 méter...
40           if kulcs%2==0 and bejegyzes[0]<=20:
41               telek_db+=1
42       print(f'Jólétsoron {telek_db} telken kötelesek teljes utcafrontot beépíteni!\n')
43   #----------------------------------------------------------------------------------------    
44   # 4. Hány háznyira van egymástól a legnagyobb és a legkisebb területű telek Gazdagsoron?
45   #    A két telek között elhelyezkedő telkek számát, valamint a legnagyobb és legkisebb
46   #    telek házszámát, illetve területét írassa ki a képernyőre!
47   #----------------------------------------------------------------------------------------
48   def F4():
49       # itt sokféle megoldás lehet...
50       print('4. feladat')
51   
52       # válogassuk ki egy új szótárba a Gazdagsor telkeit (páratlan házszám, azaz kulcs)
53       global gazdagsor    # 7. feladathoz
54       gazdagsor={}
55       for kulcs,bejegyzes in telkek.items():
56           if kulcs%2==1:
57               gazdagsor[kulcs]=bejegyzes
58   
59       # rendezzük be ezt a szótárt telekterület szerint (szélesség*hosszúság)
60       # a lambda kifejezésben x a teljes szótár-elemet jelenti:
61       # így a 0. indexű maga a kulcs, az 1. indexű a kulcshoz tartozó kételemű lista,
62       # ezért van ilyen sok index... :)
63       
64       global rendezett    # 5. feladathoz is kell majd ez...
65       rendezett=sorted(gazdagsor.items(),key=lambda x:x[1][0]*x[1][1])  # ez itt egy lista
66   
67       # a rendezett ilyen elemek listája: (házszám, [szélesség, hosszúság])
68       # pl.: (15, [20, 30])
69   
70       min_hsz=rendezett[0][0]
71       min_ter=rendezett[0][1][0]*rendezett[0][1][1]
72       max_hsz=rendezett[-1][0]                            # -1 az utolsó elem indexe, ugye
73       max_ter=rendezett[-1][1][0]*rendezett[-1][1][1]
74       tav=((max_hsz-2)-min_hsz)//2
75       print(f'A legkisebb telek házszáma: {min_hsz}. Területe: {min_ter} négyzetméter')
76       print(f'A legnagyobb telek házszáma: {max_hsz}. Területe: {max_ter} négyzetméter')
77       print(f'A kettő között {tav} telek van.\n')
78   #----------------------------------------------------------------------------------------
79   # 5. Az önkormányzat telekadót fog kivetni. Az adót Fabatkában számolják. A 700
80   #    négyzetméteres és annál kisebb telkek esetén ez 51 Fabatka négyzetméterenként, az
81   #    ennél nagyobb telkeknél az első 700 négyzetméterre vonatkozóan szintén 51 Fabatka,
82   #    700 négyzetméter felett egészen 1000 négyzetméterig 39 Fabatka a négyzetméterenkénti
83   #    adó. Az 1000 négyzetméter feletti részért négyzetméter árat nem, csak 200 Fabatka
84   #    egyösszegű általányt kell fizetni. A 15 m vagy annál keskenyebb, illetve a 25 m vagy
85   #    annál rövidebb telkek tulajdonosai 20% adókedvezményben részesülnek. Az adó meghatá-
86   #    rozásánál 100 Fabatkás kerekítést kell használni (pl. 6238 esetén 6200, 6586 esetén
87   #    6600). Határozza meg, mekkora adóbevételre számíthat Gazdagsor után az önkormányzat!
88   #----------------------------------------------------------------------------------------
89   def F5():
90       print('5. feladat')
91       # használjuk fel a 4. feladat rendezett listáját, ezért az legyen globális!
92   
93       # 700 és alatt: 51/nm
94       # 700 felett 1000-ig +39/nm
95       # 1000 felett +200
96       # kedvezmény: 20% szélesség<=15, illetve hosszúság<=25
97       bevetel=0                   # összbevétel a telekadóból Gazdagsoron
98       for telek in rendezett:     # telek pl.: (15, [20, 30])
99           fizet=0                 # egy telek után fizetendő adó
100          szelesseg=telek[1][0]
101          hosszusag=telek[1][1]
102          terulet=szelesseg*hosszusag
103          if terulet<=700:
104              fizet+=terulet*51
105          elif 700<terulet<=1000:
106              fizet+=(700*51)+(terulet-700)*39
107          else:
108              fizet+=(700*51)+(1000-700)*39+200
109          # kedvezmény
110          if szelesseg<=15 or hosszusag<=25:
111              fizet-=fizet*0.2
112  
113          fizet=round(fizet,-2)       # lásd Érettségi Kézikönyv 2.0:
114                                      # https://odorpeter.hu/python-vs-c-adattipusok.html
115          bevetel+=fizet
116      print(f'Gazdagsor után a telekadóból származó bevétel: {bevetel:.0f} Fabatka!\n')
117  #----------------------------------------------------------------------------------------
118  # 6. Melyik a 3 utolsó telek a Jólétsoron? A házszámokat és a telkeknek a Jólétsor elejé-
119  #    től mért távolságát írja ki a képernyőre a házszámok szerint csökkenő sorrendben!            
120  #----------------------------------------------------------------------------------------
121  def F6():
122      print('6. feladat:')
123      # válogassuk ki egy új szótárba a Jólétsor telkeit (páros házszám, azaz kulcs)
124      joletsor={}
125      for kulcs,bejegyzes in telkek.items():
126          if kulcs%2==0:
127              joletsor[kulcs]=bejegyzes
128      # rendezés házszám szerint csökkenő sorrendbe
129      global rendJS       # 7. feladathoz
130      rendJS=sorted(joletsor.items(),key=lambda x:x[0])
131      # rend egy eleme pl.: (32, [20, 0]) - rend 1. indexű eleme tehát egy lista!!
132      tav=sum([rendJS[i][1][0] for i in range(len(rendJS)-3)])
133      print('Az utolsó három telek a Jólétsoron:')
134      print(f'Házszám: {rendJS[-1][0]}. Távolság az utca elejétől: {tav+rendJS[-2][1][0]+rendJS[-3][1][0]} méter.')
135      print(f'Házszám: {rendJS[-2][0]}. Távolság az utca elejétől: {tav+rendJS[-3][1][0]} méter.')
136      print(f'Házszám: {rendJS[-3][0]}. Távolság az utca elejétől: {tav} méter.\n')
137  #----------------------------------------------------------------------------------------
138  # 7. Határozza meg Jólétsor telkeinek hosszúságát! Vegye figyelembe, hogy a szemben fekvő
139  #    telkek patak felőli határvonalait az utcafrontra merőleges irányban legalább 10
140  #    méternek kell elválasztania egymástól! Szemben fekvőnek számítanak a telkek akkor is,
141  #    ha csak a telkek valamelyik széle van egymással szemben. (Például a 10-es számú
142  #    telekkel csak a 9-es és 11-es számú telek van szemben.) A számításnál a feltételnek
143  #    megfelelő legnagyobb telkeket kell kialakítani! Jólétsor adatait írja ki a
144  #    joletsor.csv fájlba! Az egyes sorokban a házszám, a szélesség és a hosszúság szere-
145  #    peljen! Az adatokat pontosan egy pontosvessző válassza el egymástól!
146  #----------------------------------------------------------------------------------------
147  def F7():
148      fki=open('joletsor.csv','w')
149  
150      # rendGS - Gazdagsor listája, elemei például ilyenek: (15, [20, 30])
151      rendGS=sorted(gazdagsor.items(),key=lambda x:x[0])
152      # rendJS - Jólétsor listája, elemei például ilyenek:  (32, [20, 0])
153      meterenkent=[]      # telkek lehetséges hosszúsága a Jólétsoron
154      for telek in rendGS:
155          for i in range(telek[1][0]):    # telek szélessége
156              meterenkent.append(80-(telek[1][1]+10))     # telek hosszúsága
157      
158      start=0
159      for telek in rendJS:
160          szel=telek[1][0]
161          # minimumot kell választani a lehetséges hosszúságokból (lásd adatok értelmezése)
162          hossz=min(meterenkent[start:start+szel])
163          start+=szel
164          print(str(telek[0])+';'+str(telek[1][0])+';'+str(hossz),file=fki)
165      fki.close()
166  #****************************************************************************************
167  telkek={}   # szótár adattípussal oldjuk meg a feladatot
168  F1()
169  F2()
170  F3()
171  F4()
172  F5()
173  F6()
174  F7()
175  
176