Programozás 1, 2017/2018 II. félév
(Python)
Tárgyleírás:
1. Célok és követelmények ismertetése. Alapfogalmak
(forráskód, szintaktika, szemantika, linkelés stb.).
2. Programnyelvek kialakulása, csoportosítása. A modern
nyelvek előnyei, hátrányai, felhasználási területük. Ismertebb programozási
környezetek. Nyelvválasztás indoklása.
3. Karakterkészlet. Lexikális egységek. A forrásszöveg
összeállításának szabályai.
4. Adattípusok (és adatábrázolási kérdések
dióhéjban). Nevesített konstans.
Változó.
5. Kifejezések (operátorok, operandusok), precedenciatáblázat, kifejezések kiértékelése.
6. Deklarációs és végrehajtható utasítások. Értékadó és
üres utasítások. Elágaztató utasítások. Ciklusszervezés és vezérlő utasítások.
7. Alprogramok. Paraméterkiértékelés és paraméterátadás.
8. További programegységek. Hatáskörkezelés, láthatóság.
9. I/O, fájlkezelés, kivételkezelés.
10. Esettanulmányok: Általános problémák modellezése eljárásorientált szemlélet alapján.
11. Esettanulmányok: Gazdaságspecifikus
problémák modellezése eljárásorientált szemlélet
alapján. (BPMN diagram)
12. Programozásmódszertani kitekintés.
13. Funkcionális programozás eszközei, lambda
kifejezések.
14. Összefoglalás
Gyakorlati tematika:
1. Célok és követelmények ismertetése. Egy verziókövető
rendszer használata, alapvető programozási ismeretek ismétlése.
2. Szöveges állományok kezelése I. Kivétel kezelés
alapjai.
3. Szöveges állományok kezelése II. Parancssori
argumentum feldolgozás.
4. Egy dimenziós tömbök.
5. Bináris keresés, rendezés implementálása.
6. Több dimenziós tömbök.
7. Adatvizualizációs lehetőségek.
8. Zárhelyi dolgozat.
9. Halmaz adatszerkezet és műveletei.
10. Szótár adatszerkezet és műveletei.
11. Lambda kifejezések.
12. Példák. Adatszerkezet és algoritmus választásának jelentősége.
13. Beadandó feladatokkal kapcsolatos konzultáció.
14. Beadandó feladatok prezentálása.
Ajánlott irodalom:
· Nyékiné, G. Judit: Programozási nyelvek, Kiskapu
Kiadó, 2002. ISBN: 9789639301467
· Summerfield, Mark: Python 3 programozás, Kiskapu Kiadó, 2009,
ISBN: 9789639637641
· Downey, Allen B. Think Python - How to Think
Like a Computer Scientist, O’Reilly Media, 2012, ISBN: 9781449330729
· Swinnen, Gérard: Tanuljunk meg
programozni Python nyelven, 2002.
· Punch & Enbody: The Practice of Computing Using Python, Global Edition,
3/E,
ISBN-10: 1292166657 • ISBN-13: 9781292166650, ©2018
Magas szintű programozási nyelvek 1, 2018/2019 II. félév (C)
Letölthető előadásdiák:
Egyéb ajánlott irodalom:
Juhász
István: Magas szintű programozási nyelvek 1 (egyetemi jegyzet)
Követelmények:
-------------------------------------------------------------
1. Követelményrendszer
1.1. Két előadás ZH, és három
gyakorlati beszámoltatás lesz.
1.2. Az 1. előadás ZH
helyszíne és időpontja 2019. április 29 (hétfő), 10.00-12.00. (előadás helye és
időpontja).
1.3. A 2. előadás ZH
helyszíne és időpontja VÁRHATÓAN az utolsó oktatási hét előadása.
1.4. A gyakorlati beszámolók
a megfelelő gyakorlatokon, számítógép mellett történnek.
1.5. Vizsgajegy szerzéséhez
sikeres gyakorlati teljesítés és "beugró" (minimális követelmény)
feladat teljesítése szükséges.
-------------------------------------------------------------
2. ZH/gyakorlati beszámoló
tematikája
2.1. Az előadás ZH-k tematikája az előadásdiák tartalmára épül.
1. előadás ZH helye és időpontja:
2019.04.29 (hétfő, 10.00-12.00)
2. előadás ZH helye és időpontja: 2019.05.13 (hétfő, 10.00-12.00)
2.2. A gyakorlati beszámolók tematikája (mintafeladatok) a gyakorlatvezetők
honlapján található meg.
-------------------------------------------------------------
3. Értékelés módja
3.1. Gyakorlat
teljesítéséhez:
Egy gyakorlati beszámolón
maximum 5 pont szerezhető, a három gyakorlati beszámoló közül kettőn kell
legalább
3-3 pontot elérni, azaz, az
egyik beszámoló pótZH-nak is tekinthető (a legjobban
sikerült két beszámolót vesszük figyelembe).
3.2. Az előadás ZH-k eredménye nem számít bele a gyakorlat teljesítésébe.
3.3. Előadás ZH és gyakorlati
beszámolók eredményének beszámítása vizsgába:
Sikeres beugró teljesítése
után "megajánlott" jegyet tudok javasolni elsősorban az előadás ZH-n elért eredménynek
megfelelően kiegészítve a gyakorlati ZH-n
szerzett eredményekkel (lásd Eredmény
oszlop).
A kategóriák (VÉGLEGES):
90% <= eredmény,
vizsgajegy: jeles (5),
80% <= eredmény < 90%, vizsgajegy: jó (4),
70% <= eredmény < 80%, vizsgajegy: közepes (3),
60% <= eredmény < 70%, vizsgajegy: elégséges (2),
eredmény < 60%, vizsgajegy szerzéséhez vizsga kötelező,
szóbeli előtt is van beugró.
-------------------------------------------------------------
Eredmények (szakmai napos igazolás esetén max. 3%-kal nőhet az Eredmény, ilyen esetben van értelme
bemutatni; ajánlott jegy érvényesítéséhez vizsgára kell iratkozni, ekkor a
megjelenés nem kötelező, ha nincs javítási szándék, beírom az ajánlott jegyet):
Tételsor vizsgára:
1. Alapfogalmak (modellezés,
fordítóprogramok, programnyelvek csoportosítása)
2. Programozási alapok
(karakterkészlet, lexikális egység, szimbolikus név, címke, megjegyzés, literál)
3. Programozási alapok 2 (forrásszöveg,
adattípus, konstans, változó, alapelemek a C-ben)
4. Kifejezések (operandus,
kiértékelés, típusegyenértékűség, típuskényszerítés,
C operandusai és kifejezései)
5. Utasítások (deklaráció,
végrehajtás, ugrás, elágaztatás, ciklusok, megvalósítás C-ben)
6. Mutatók és adatszerkezetek
(mutatók, tömb, struktúra, lista)
7. Programok szerkezete
(programegységek, alprogramok, eljárás, függvény, paraméterátadás,
paraméterkiértékelés, hatáskörkezelés, megvalósítás C-ben)
8. Szabványos C könyvtárak (headerfájlok, ctype.h/math.h/string.h függvények)
9. Input/Output (állomány
funkciói, adatátvitel típusai, deklaráció, összerendelés, megnyitás,
feldolgozás, lezárás)
10. Input/Output C-ben
(állomány feldolgozásának lépései, implicit állományok, stdio.h)
11. Objektum Orientált
programozás (attribútum, módszer, objektum, öröklődés, kötés, absztrakt
osztály, OO nyelvek)
Gyakorló feladatok és
megoldások
Nagy
Brigitta: Magasszintű programozási nyelvek 1
feladatok
Kovács
György: Magasszintű programozási nyelvek 1 gyakorlat
Kósa
Márk – Pánovics János: Példatár a Programozás 1
tárgyhoz
További gyakorló feladatok
1/1
A vb hangja
„KO-RE-A, KO-RE-A”
– kiabálta 54 000 boldog futballszurkoló, miután csapatuk a hazai rendezésű
világbajnokságon bejutott az elődöntőbe. Izgatottságuk dacára azonban a koreai
emberek természetüknél fogva nagyon szervezettek. Például hatalmas, hajókürthöz
hasonló hangú trombitákkal szurkoltak a pályán játszó csapatuknak. A szurkolók
egy állandó zajszintet szeretnének fenntartani a meccs teljes ideje alatt.
A trombiták sűrített levegővel működnek,
azonban ha 2 másodpercig folyamatosan fújják őket, elromlanak. Ezért amikor a
trombita hangot ad, minden rendben van, de a trombitahangok szüneteiben a
szurkolóknak a „KO-RE-A” kiáltást kell harsogniuk.
A mérkőzés előtt egy szurkolócsoport
összegyűl és eldönti a kiáltás mintáját. A minta 0-k és 1-esek sorozata,
amelyet a következőképpen értelmezünk: ha a minta 1-es, akkor a trombita kerül
megfújásra, ha pedig 0, akkor a „KO-RE-A” kiáltás következik. Annak érdekében,
hogy a trombiták nehogy elromoljanak, a minta nem tartalmazhat két egymást
követő 1-est.
Ebben a feladatban tehát egy adott,
pozitív egész n-re meg kell határozni az ilyen hosszúságú kiáltási
mintákat, vagyis azon n bites sorozatok darabszámát, amelyek nem
tartalmaznak egymás melletti 1-eseket. Például n = 3 esetén a megoldás 5 (a
000, a 001, a 010, az 100 és az 101 sorozatok elfogadhatóak, míg a 011, az 110
és az 111 nem).
Input
Az első sor a tesztesetek számát
tartalmazza. Az első sort követő sorok mindegyike egy-egy tesztesetet ír le.
Minden teszteset egy olyan sor, amely egyetlen, 51-nél kisebb egész számot
tartalmaz.
Output
Minden teszteset kimenete egy olyan
sorral kezdődik, amely a „Scenario #i:”
szöveget tartalmazza, ahol i a teszteset sorszáma. A tesztesetek
sorszámozása 1-től indul. Ezt követően egy újabb sorba kell kiírni az egymás
melletti 1-eseket nem tartalmazó n bites sorozatok darabszámát. Minden
teszteset kiírását egy üres sorral kell lezárni.
Példa input
2
3
1
Példa output
Scenario #1:
5
Scenario #2:
2
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/2
Háromszöghullámok
A feladatban egy megadott
amplitúdójú és frekvenciájú háromszöghullám generálását kell elvégezni.
Input
A bemenet két pozitív egész számot
tartalmaz, mindegyiket külön sorban. Az első egész az amplitúdó, a második
pedig a frekvencia.
Output
A program kimenete üres sorokkal
elválasztott hullámalakok sorozata lesz. A hullámalakok darabszámát a
frekvencia, míg az egyes hullámok vízszintes „magasságát” az amplitúdó
határozza meg. Az amplitúdó sosem lesz nagyobb kilencnél.
Magát a hullámalakot olyan egész
számokkal kell kitölteni, amelyek minden sorban jelzik annak „magasságát”.
Példa input
3
2
Példa output
1
22
333
22
1
1
22
333
22
1
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/3
Nem egyértelmű permutációk
Néhány programozásiverseny-feladat
igazán trükkös: nemcsak másféle kimeneti formátumot követel meg, mint amire
számítottunk, hanem még a példa output sem láttatja a különbséget. Tekintsük
például a permutációkat. Az 1 és n közötti egész számok egy permutációja
alatt ezen számok valamilyen rendezettségét értjük,
vagyis egy ilyen permutáció megjelenítésének természetes módja a számok adott
rendezettség szerinti felsorolása. Az n = 5 esetben például egy
permutáció lehet a 2, 3, 4, 5, 1 számsorozat. Egy permutációt azonban más módon
is reprezentálhatunk: egy olyan számsorozatot hozunk létre, ahol az i-edik szám az i szám permutációban elfoglalt
helyét határozza meg. Ez utóbbit inverz permutációnak nevezzük. A fenti
számsorozat inverz permutációja az 5, 1, 2, 3, 4 sorozat.
Nem egyértelmű permutációnak (angolul ambiguous permutation) azokat a permutációkat nevezzük, amelyek
nem különböztethetők meg inverz permutációjuktól. Az 1, 4, 3, 2 permutáció
például nem egyértelmű, mert inverze megegyezik vele (vagyis az eredeti
permutáció nem különböztethető meg egyértelműen az inverzétől). Az ilyen
idegesítő tesztesetektől történő megszabadulás érdekében készítsünk programot,
amely egy adott permutációról eldönti, hogy az egyértelmű-e vagy sem.
Input
A bemenet tetszőleges számú
tesztesetet tartalmazhat. Minden teszteset két sorból áll, az utolsó teszteset
után egy 0 következik. Az egyes tesztesetek első sorában egy n egész (1 ≤
n ≤ 100000) szerepel. Minden teszteset második sora az 1 és n
közötti számok egy permutációját adja meg úgy, hogy az azt alkotó számok
egymástól pontosan egy szóközzel vannak elválasztva. Feltételezhető, hogy
minden 1 és n közötti egész szám pontosan egyszer fordul elő a
permutációban.
Output
A kimenet sorainak száma megegyezik
a tesztesetek darabszámával. A kimenet i-edik
sorában a bemenet i-edik tesztesetének
permutációjának egyértelműségéről szóló döntés (ambiguous
= nem egyértelmű, not ambiguous
= egyértelmű) olvasható, ahogyan azt a példa output mutatja.
Példa input
4
1 4 3 2
5
2 3 4 5 1
1
1
0
Példa output
ambiguous
not ambiguous
ambiguous
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/4
Polinomok megjelenítése
Egy adott, legfeljebb nyolcadfokú polinomot szeretnénk olyan olvasható
formátumban megjeleníteni, amely nem tartalmaz szükségtelen karaktereket.
Például a 0, 0, 0, 1, 22,
-333, 0, 1, -1 együtthatókkal rendelkező polinomot x^5 + 22x^4 - 333x^3 + x - 1 formában szeretnénk viszontlátni.
A formázást az alábbi szabályok
figyelembevételével kell elvégezni:
1. Az egyes tagok fokszám szerint csökkenő sorrendben követik
egymást.
2. A kitevők egy kalap karakter (^) mögött jelennek meg.
3. Egy konstans tag csak önmagában jelenik meg.
4. Csak a nemnulla együtthatójú tagok
jelennek meg, kivéve, ha az összes együttható nulla, amikor is csupán a
konstans tag jelenik meg.
5. Szóközök csak a bináris + és -
operátorok két oldalán jelenhetnek meg, ott viszont mindkét oldalon pontosan
egynek kell szerepelnie.
6. Ha az első tag pozitív, akkor nem teszünk elé előjelet, a negatív első
tagot viszont megelőzi egy mínuszjel, pl. -7x^2 + 30x + 66.
7. A negatív együtthatóval rendelkező tagoknak kivont nemnegatív együtthatójú tagokként kell megjelenniük (kivéve
az előző pontban leírt esetet, amikor a negatív együtthatójú tag az első),
vagyis x^2 + -3x
helyett x^2 - 3x-nek
kell szerepelnie.
8. Az 1 és -1 együtthatójú ill. kitevőjű
tagok esetén az egyest elhagyjuk, vagyis -1x^3 + 1x^2 + 3x^1 - 1 helyett a kimenetben -x^3 + x^2 + 3x - 1 szerepeljen.
Input
A bemenet tetszőleges számú (de
legalább egy!), egy vagy több szóközzel elválasztott
együtthatókból álló sort tartalmaz. Minden sorban pontosan kilenc, abszolút
értékben 1000 alatti egész együttható szerepel.
Output
A kimeneten a bemenettel megegyező
számú sornak kell megjelennie. A kimenet i-edik
sorában a bemenet i-edik sorában megadott
együtthatókkal rendelkező polinom fent leírt szabályok szerint megformázott
alakja szerepeljen!
Példa input
0
0 0 1 22 -333
0 1 -1
0
0 0 0 0 0 -55 5
0
Példa output
x^5 + 22x^4 – 333x^3 + x – 1
-55x^2 + 5x
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/5
Faktoriális
Egy GSM hálózat legfontosabb része
az ún. adó-vevő bázisállomás (Base Transceiver Station, BTS). Ezek az adó-vevők általában a cellák közepén
helyezkednek el, és (kicsit leegyszerűsítve) minden mobiltelefon a legerősebb
jelet kibocsátó bázisállomáshoz kapcsolódik. Természetesen a bázisállomások
karbantartást igényelnek, és működésüket rendszeresen műszaki szakemberek
ellenőrzik.
Az ACM szakemberei nemrégiben egy
nagyon érdekes problémával találták szemben magukat. Meg kellett találniuk a
legrövidebb utat, amellyel az összes meglátogatandó bázisállomás érintésével
visszajutnak a cég központi épületébe. A programozók több hónapig
tanulmányozták a problémát, de nem jutottak eredményre: nem sikerült elég gyors
megoldást találniuk. Végül az egyik programozó megtalálta ezt a problémát egy
konferenciacikkben. Sajnos azonban az derült ki, hogy ez az ún. utazóügynök-probléma, amelyet nagyon nehéz megoldani. N
darab tetszőleges sorrendben meglátogatandó bázisállomás esetén ugyanis a
megvizsgálandó lehetőségek száma N! (vagyis 1-től N-ig a számok
szorzata), amely viszonylag kis N érték esetén is nagyon nagy lehet.
A programozók rájöttek, hogy nincs
esélyük a probléma megoldására. Mivel azonban már megkapták a kutatási
támogatást a kormányzattól, valamilyen eredményt fel kellett mutatniuk,
így hát folytatták a probléma tanulmányozását, mégpedig a faktoriális függvény
viselkedésének vizsgálatával.
Ennek keretében definiálták a Z
függvényt. Egy tetszőleges N pozitív egész esetén Z(N)
az N! decimális ábrázolásmódjának a végén
található nullák darabszáma. Rájöttek arra is, hogy ez a függvény nemcsökkenő, vagyis bármely két egész esetén, ha N1<N2, akkor Z(N1)<Z(N2),
mivel egy pozitív szám megszorzásával nem „veszíthetünk el” egyetlen hátulsó
nullát sem, csak újabbak és újabbak jelenhetnek meg. A Z függvény nagyon
érdekes, ezért olyan programra van szükségünk, amellyel ennek értékét
hatékonyan kiszámíthatjuk.
Input
A bemenet első sora egy T
pozitív egész számot tartalmaz. Ez az ezt követő számok számát adja meg. Majd T
sor következik, amelyek mindegyikében pontosan egy, (a szélsőértékeket is
beleértve) 1 és 1000000000 (109) közötti pozitív egész szám (N)
helyezkedik el.
Output
A kimeneten minden N-hez
egyetlen sor tartozik, amely a Z(N) nemnegatív egész értéket tartalmazza.
Példa input
6
3
60
100
1024
23456
8735373
Példa output
0
14
24
253
5861
2183837
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/6
Bangla számok
A bangla
számok kiejtésekor vagy szöveges formában történő felírásakor a „kuti” (10000000), „lakh”
(100000), „hajar” (1000) és „shata”
(100) szavakat használják. A feladatod egy olyan program készítése, amely egy
adott számot szöveggé alakít e szavak felhasználásával.
Input
A bemenet több tesztesetet
tartalmazhat. Minden teszteset egy nemnegatív számot
fog tartalmazni, amelynek értéke nem nagyobb 999 999 999 999 999-nél.
Output
A bemenet minden egyes sorához ki
kell írnod a kimenetre a teszteset sorszámát négy helyiértéken
jobbra igazítva, majd a szövegessé alakított számot a példa outputban megadott
formában.
Példa input
23764
45897458973958
Példa output
1. 23 hajar 7 shata
64
2. 45 lakh 89 hajar
7 shata 45 kuti 89 lakh 73 hajar 9 shata 58
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/7
Goldbach sejtése
1742-ben Christian
Goldbach, egy német műkedvelő matematikus küldött egy levelet Leonhard Eulernek, amelyben a következő sejtését írta
le:
Minden 4-nél nagyobb páros szám
felírható két páratlan prímszám összegeként.
Például:
•
8 = 3 + 5. A 3 és az 5 is páratlan
prímszám.
•
20 = 3 + 17 = 7 + 13.
•
42 = 5 + 37 = 11 + 31 = 13 + 29 =
19 + 23.
Mind a mai napig nem sikerült
eldönteni, hogy igaz-e a sejtés. (Ó, várjunk csak, nekem természetesen megvan rá
a bizonyításom, de túl hosszú ahhoz, hogy ideírjam az oldal margójára.)
A te feladatod mindenesetre az,
hogy ellenőrizd Goldbach sejtését minden egymilliónál kisebb páros számra.
Input
A bemenet egy vagy több tesztesetet
fog tartalmazni. Minden teszteset egy olyan páros n számból áll, melyre
6 ≤ n < 1000000 teljesül. A
feldolgozandó adatokat egy 0 érték fogja zárni n értékeként.
Output
Minden tesztesetre egy n = a + b
alakú sort kell kiírnod, ahol a és b
páratlan prímek. A számokat és a műveleti jeleket pontosan egy szóközzel kell
elválasztani egymástól, ahogyan az a példa outputban is látható. Ha egynél több
páratlan prímpárra is felbontható n, akkor azt a párt válaszd, amelyre a
b - a különbség a legnagyobb.
Ha nem létezik ilyen pár, akkor egy
„Goldbach's conjecture is wrong.” tartalmú sort írj
a kimenetre.
Példa input
8
20
42
0
Példa output
8 = 3 + 5
20 = 3 + 17
42 = 5 + 37
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/8
Négyzetek mindenütt
Geometriailag minden négyzetnek van
egy egyedi, jól definiált középpontja. Ez egy négyzetrácson csak akkor igaz, ha
a négyzet oldalai páratlan számú rácspont hosszúságúak. Mivel bármely páratlan
szám felírható 2k+1 alakban, bármely ilyen négyzetet jellemezhetünk k
megadásával, azaz azt mondhatjuk, hogy egy négyzetnek, amelynek az oldalai 2k+1
hosszúak, a mérete k. Ezek után definiáljuk négyzeteknek egy mintázatát
a következőképpen:
1. A legnagyobb négyzet k méretű (azaz az oldala 2k+1
hosszúságú), és egy 1024 méretű négyzetrács közepére van igazítva (azaz a
négyzetrács oldalai 2049 hosszúak).
2. A legkisebb megengedhető négyzet mérete 1, a legnagyobbé 512, így
1 ≤ k ≤ 512.
3. Minden k>1 méretű négyzetnek egy-egy k div 2 méretű négyzet van a 4 sarkára
mint középpontra igazítva. (A div szó az
egészosztásra utal, azaz például 9 div 2 = 4.)
4. A képernyő bal felső sarkának koordinátája (0, 0), a jobb alsóé (2048, 2048).
Ezek után
ha adott egy k érték, felrajzolhatjuk a fenti szabályoknak megfelelően
négyzeteknek egy egyedi mintáját. Megfigyelhetjük, hogy a képernyő bármely
pontját nulla vagy több négyzet fogja határolni. (Ha egy pont a négyzet
oldalvonalán van, azt a négyzet által határoltnak tekintjük.) Így például ha a
legnagyobb négyzet mérete 15, akkor a következő mintázatot állíthatjuk elő:
Írj egy programot, amely beolvassa k
és egy koordináta értékét, és meghatározza, hogy hány négyzet határolja a
beolvasott pontot.
Input
A bemenet több sorból fog állni.
Minden sor egy k értéket és egy pont koordinátáit fogja tartalmazni. A
bemenet végét egy olyan sor jelzi, amely három darab nulla értéket tartalmaz,
ezt a sort már nem kell feldolgozni.
Output
A bemenet minden egyes sorához egy
sort kell a kimenetre írni. Ebbe a sorba a megadott pontot magába foglaló négyzetek
számát kell írni, 3 mező szélesen jobbra igazítva.
Példa input
500 113 941
0 0 0
Példa output
5
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/9
Szusiparti
Partit szervezel a barátaid
számára. Hogy legyen mit enni az este folyamán, vásároltál néhány szusiroládot. Mivel nem szeretnéd, hogy barátaid rossz
szájízzel távozzanak, próbálod úgy intézni, hogy mindenki ugyanannyi szusiroládot kapjon (beleértve téged is), és mindenkinek
1-nél több szusirolád jusson. Ha például 20 szusiroládod van, akkor 1, 3, 4 vagy 9 barátodat hívhatod
meg. A feladatod az, hogy írj egy programot, amely adott számú szusirolád esetén megadja, hogy legfeljebb hány barátodat
láthatod vendégül.
Input
A bemenet több tesztesetet
tartalmaz. Minden teszteset egyetlen sorból áll, amely egy n egész
számot tartalmaz (1 ≤ n ≤ 10000). Ez a
megvásárolt szusiroládok darabszáma. A bemenetet egy
0-t tartalmazó sor zárja.
Output
Minden tesztesetre soronként
egyetlen pozitív egész számot kell a kimenetre írni: azt, hogy legfeljebb hány
barátodat láthatod vendégül. Ha egyáltalán nem lehetséges vendégeket hívni
adott számú szusirolád esetén, akkor a „No solution.” szöveget kell a kimenetre írni (idézőjelek nélkül).
Példa input
12
14
11
20
0
Példa output
5
6
No solution.
9
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1/10
Számjegyprobléma
A Kütyüboltban minden áru olcsóbb
lett, ki kell tehát cserélni az ártáblákat. Az új táblákat a Számjegypiacról lehet
beszerezni: vásárolhatunk számjegyeket 0-tól 9-ig, és ezekből állíthatjuk össze
az új táblákat. A feladatod, hogy írj egy programot, amely kiszámítja, hogy
hány darab szükséges az egyes számjegyekből.
Input
A bemenet tesztesetek blokkjaiból
áll. Minden teszteset egy n egész számot tartalmazó sorral kezdődik (1≤n≤1000),
amely az elkészítendő táblák darabszámát adja meg. Minden tábla egyetlen árat
tartalmaz, amely egy 1 és 1000000 közé eső egész szám. A következő n
sorban egy-egy szám található: ezek a táblákon szereplő árakat adják meg.
A bemenetet egy olyan blokk zárja,
amelyben n=0.
Output
Minden tesztesetre 10, egymástól egy-egy
szóközzel elválasztott egész számot kell a kimenetre írni. Ezek a számok azt
adják meg, hogy hány darabra van szükség az egyes számjegyekből: az első szám a
megvásárolandó 0-k száma, az utolsó a szükséges 9-esek száma.
Példa input
2
101
250
1
99999
0
Példa output
2 2 1 0 0 1 0 0 0
0
0 0 0 0 0 0 0 0 0 5
------------------------------------------------------------------------------------------------------------------------------
1/11
Össze tudod adni?
Adott két egész szám, x és y.
Számítsd ki és írd ki az összegüket!
Input
A bemenet több tesztesetet
tartalmaz. A bemenet első sora egy Z ≤ 100 pozitív egész számot
tartalmaz, amely a tesztesetek számát jelzi. Az első sort követő sorok
mindegyike egy-egy tesztesetet ír le. Minden teszteset egy olyan sor, amely két
egész számot tartalmaz, az egymástól szóközzel elválasztott x-et és y-t
(x, y ∈ [-109, 109]).
Output
A programodnak minden tesztesetre
egy sort kell kiírnia, amely a tesztesetben megadott x és y
értékek összegét tartalmazza.
Példa input
4 -100 100 2 3 0 110101 -1000000000
1
Példa output
0 5 110101 -999999999