2022.12.20. Web gyakorlás

A legtöbben befejezték a Párizsi látnivalókat. Legközelebb ellenőrizzük csak a végét, és megyünk tovább.

(Ketten majdnem végeztek a Paprikával.)

2022.12.15.-16. Web gyakorlás

Átismételtük a Nyomtatást, elkezdtük a Párizsi látnivalókat, itt fejezzük be.

2022.12.(12. helyettesítés)-13.

Nyomtatás feladat megoldása megoldókulccsal.

A w3schools Forms oldalának tanulmányozása.

2022.12.09. Nyomtatás - web feladat

Átnéztük a megoldást, átismételtük a tudnivalókat. Köv. órán megoldjuk.

2022.12.08. Reszponzív weboldalak

Átvettünk minden tudnivalót a témában, linkek az előző bejegyzésben.

2022.12.06. Helyettesítés

Gratulálok a szalagavatóhoz! Szépek, ügyesek voltatok.

A múlt hétre kiadott feladatok gondolom még nincsenek készen teljesen. Akinek nincs, az fejezze be őket.

Aki készen van, lélekben készüljön a webes feladat-megoldásra, esetleg a két feladatsor webes feladataival ismerkedjetek. Ott van a megoldás, nem lehet baj.

A reszponzivitás újdonság, ehhez először a következő oldalakat olvassátok el, nézzétek át (ez mindenképp órai feladat, ha a webesig mindennel készen vagy):

reszponzív weboldal készítés (magyar)

w3schools responsive web design css

w3schools responsive web design html

Elemér és Máté az előző két feladatsort végig oldja meg (a hálózat nélkül persze). Ha marad időtök, a múltkor kiadott javascriptes anyaggal haladjatok tovább.

2022.12.01.-02. Helyettesítés

Remélem, sikerült előrehaladni az előző feladatsorral. Ha még nincs kész, először azt fejezzétek be.

Innen le tudjátok tölteni a 2017. őszi informatika ismeretek érettségi feladatsort. Ez egy régebbi ípusú feladatsor, nincs benne ablakos program írás, az adatbázis feladat teljesen külön sorszám alatt szerepel, hosszabb, viszont csak lekérdezés van benne. (És a web is könnyebb, de azzal most még nem kell foglalkoznod.)

Jó munkát!

2022.11.29. Helyettesítés

Erről a linkről töltsétek le a 2020. őszi informatikai ismeretek érettségi feladatlapját, forrásait és megoldókulcsát.

A programozás konzolos és ablakos részt, végül az adatbázis feladatot kell megoldani, ebben a sorrendben.

A konzolos részben a beolvasást és a sorok kiírását mindenki oldja meg, a többi opcionális.

Ha a megoldásban ismeretlen módszereket találsz, ne ijedj meg, mindent többféleképpen meg lehet oldani.

Segítsetek egymásnak, és ha kész vagytok, ellenőrizzétek a megoldókulccsal a megoldásokat.

Elemér és Máté is ezzel a feladatsorral kezdjen, ti végig írjátok meg a programozás-konzolos feladatot.

2022.11.24. Sudokus feladatlap adatbázis feladata

Átismételtünk néhány témát az SQL jegyzetből, és vettük a DELETE, INSERT INTO, UPDATE parancsokat. Majdnem végig megoldottuk az adatbázis feladatot.

2022.11.17. -18. Sudoku

Majdnem elkészültünk a Sudoku WPF-es részével.

2022.11.15. Random felelő megoldás

Készen vagyunk, átnéztük a Sudokus érettségi feladatsort is.

class1.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace randomfelelo2
{
    public class Osztaly
    {
        public int csoport;
        public string nev;

        public Osztaly(string sor)
        {
            List<string> atmeneti = sor.Split(";").ToList();
            csoport = Convert.ToInt32(atmeneti[0]);
            nev = atmeneti[1];
        }
    }
}
MainWindow.xaml.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Windows;


namespace randomfelelo2
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        Random rnd = new Random();
        public MainWindow()
        {
            InitializeComponent();
            List<Osztaly> tanulok = new List<Osztaly>();
            Chb1.IsChecked = true;
            //kezdetben az 1. csoport legyen az aktív (ezt nem feltétlen kell megtenni)
            //ezt be lehet állítani a vezérlőelem tulajdonságainál is

            foreach (var item in File.ReadAllLines("12b.txt"))
            {
                tanulok.Add(new Osztaly(item));
            }

            for (int i = 0; i < tanulok.Count; i++)
            {
                if (tanulok[i].csoport == 1)
                {
                    Lb1.Items.Add(tanulok[i].nev);
                }
                else
                {
                    if (tanulok[i].csoport ==2)
                    {
                        Lb2.Items.Add(tanulok[i].nev);
                    }
                }
            }
        }

        private void Chb1_Checked(object sender, RoutedEventArgs e)
        {
            Chb2.IsChecked = false;
        }

        private void Chb2_Checked(object sender, RoutedEventArgs e)
        {
            Chb1.IsChecked = false;
        }

        private void BtnFelelo_Click(object sender, RoutedEventArgs e)
        {
            if (Chb1.IsChecked == true)
            {            
                LblFelelo.Content = Lb1.Items[rnd.Next(Lb1.Items.Count)];
            }
            else
            {
                LblFelelo.Content = Lb2.Items[rnd.Next(Lb2.Items.Count)];
            }
        }
    }
}
MainWindow.xaml

<Window x:Class="randomfelelo2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:randomfelelo2"
        mc:Ignorable="d"
        Title="Random felelő választó" Height="610" Width="600">
    <Grid Background="#FFC8ECF0">
        <Label Content="Random felelő választó" HorizontalAlignment="Center" Margin="0,39,0,0" VerticalAlignment="Top" Background="#FF4A58C0" Foreground="#FFF9F20A" FontSize="16"/>
        <Label x:Name="LblFelelo" Content="" HorizontalAlignment="Left" Margin="280,89,0,0" VerticalAlignment="Top" Width="272" Background="#FF98DDDA" Height="31" FontSize="16"/>
        <ListBox x:Name="Lb1" HorizontalAlignment="Left" Height="318" Margin="29,218,0,0" VerticalAlignment="Top" Width="236" RenderTransformOrigin="0.5,0.5"></ListBox>
        <ListBox x:Name="Lb2" HorizontalAlignment="Left" Height="318" Margin="316,218,0,0" VerticalAlignment="Top" Width="236"/>
        <Label Content="1. csoport" HorizontalAlignment="Left" Margin="30,167,0,0" VerticalAlignment="Top"/>
        <Label Content="2. csoport" HorizontalAlignment="Left" Margin="324,167,0,0" VerticalAlignment="Top"/>
        <CheckBox x:Name="Chb1" Content="" HorizontalAlignment="Left" Margin="104,176,0,0" VerticalAlignment="Top" RenderTransformOrigin="13.602,0.115" Checked="Chb1_Checked"/>
        <CheckBox x:Name="Chb2" Content="" HorizontalAlignment="Left" Margin="396,176,0,0" VerticalAlignment="Top" RenderTransformOrigin="13.602,0.115" Checked="Chb2_Checked"/>
        <Button x:Name="BtnFelelo" Content="A következő felelő: " HorizontalAlignment="Left" Margin="43,89,0,0" VerticalAlignment="Top" Background="#FF5C85D4" FontSize="16" Click="BtnFelelo_Click"/>
    </Grid>
</Window>

2022.11.10.-11. WPF bevezetés: Random felelőválasztó

Elkezdtük a programot megírni, együtt folytatjuk.

2022.11.03.-04. Hajó és Szótár adatbázis megoldás

Aki nincs kész, házi feladat befejezni. Köv. órán ellenőrizzük részletesen, jövő kedden dolgozat ebből a két adatbázisból.

Hajó adatbázis megoldás

/1/
CREATE DATABASE hajo
DEFAULT CHARACTER SET UTF-8
COLLATE UTF8_hungarian_ci;
/* 3. Írassa ki a J1 hajójárat menetrendjét! Jelenjenek meg az indulási és érkezési állomások az időpontokkal együtt!/
SELECT honnan, hova, indul, erkezik
FROM menetrend
WHERE jarat = "j1";

/ 4. Listázza ki, hogy Balatonfüredről milyen állomások felé indulnak hajók
11 óra 30 perc és 12 óra 30 perc között (beleértve a megadott időpontokat is)! (4. feladat:)/
/Egyik megoldás/

SELECT menetrend.hova
FROM menetrend
WHERE ((honnan = "Balatonfüred") and (menetrend.indul between '11:30' AND '12:30'));

/Másik megoldás/

SELECT menetrend.hova
FROM menetrend
WHERE ((honnan = "Balatonfüred") and (menetrend.indul>= '11:30' AND menetrend.indul<= '12:30'));

/5. Listázza ki, hogy Siófokról milyen jelű járatok indulnak 9 óra után (beleértve a 9 órát is). (5. feladat:)/

SELECT menetrend.jarat
from menetrend
WHERE honnan = "Siófok" and indul >= 9;

/6. Listázza ki indulási sorrendben az összes B-vel kezdődő jelű járatot, ami délután indul. (6. feladat:)/
select menetrend.jarat, menetrend.indul
from menetrend
where jarat like 'b%' and indul>'12:00:00'
order by indul;

/7. Határozza meg lekérdezés segítségével, hogy naponta hány hajó érkezik a kikötőkbe!
A lista az állomás nevéből és a kikötő hajók számából álljon, az utóbbi értéke szerint csökkenően!(7. feladat:)/
SELECT menetrend.hova, count(menetrend.azon)
from menetrend
group by hova
order by 2 desc;

SELECT menetrend.hova, count(azon)
from menetrend
group by hova
order by count(azon) desc;

/8. Adja meg, hogy a legkésőbben érkező hajó hánykor ér Balatonföldvárra! (8. feladat:)/

/Egyik megoldás/
SELECT menetrend.erkezik
from menetrend
where hova="Balatonföldvár"
order by erkezik desc
limit 1;

/Másik megoldás/
SELECT max(menetrend.erkezik)
from menetrend
where hova="Balatonföldvár";

/9. Az E2-es hajójáratnak mi a végállomása és hánykor érkezik oda? (9. feladat:)*/
SELECT hova, erkezik
from menetrend
where jarat="e2"
order by erkezik DESC
limit 1;

Szótár adatbázis megoldás

/1. Hozzon létre a lokális SQL szerveren szotar néven adatbázist!
Az adatbázis alapértelmezett rendezési sorrendje a magyar szabályok
szerinti legyen!
Ha az Ön által választott SQL szervernél nem alapértelmezés az UTF-8 kódolás,
akkor azt is állítsa be alapértelmezettnek az adatbázis létrehozásánál!/
CREATE DATABASE szotar
CHARACTER SET utf8
COLLATE utf8_hungarian_ci;

/2. A tabla.sql és az adatok.sql állományok tartalmazzák a táblákat létrehozó, valamint az adatokat a táblába beszúró SQL parancsokat! Futtassa a lokális SQL szerveren elsőként a tabla.sql, majd az adatok.sql parancsfájlt.
A feladatok megoldására elkészített SQL parancsokat a megoldasok.sql állományba illessze be a feladatok végén jelzett zárójelben lévő sor alá!/

/3. Készítsen lekérdezést, amely felsorolja azokat az angol szavakat,
amelyeknek magyar megfelelőjét pontosan
az angol írásmóddal egyezően írják! (3. feladat:) /
select angol
from szolista
where angol=magyar;

/4. Készítsen lekérdezést, amely ABC sorrendben
felsorolja azokat a magyar szavakat,
amelyeknél az adatbázisba kerülés dátuma 2003-ban,
vagy 2004-ben volt! (4. feladat:)/
select szolista.magyar
from szolista
where felvetel>='2003.01.01.'
AND felvetel<='2004.12.31.'
order by magyar;

select szolista.magyar
from szolista
where felvetel between '2003.01.01.'
AND '2004.12.31.'
order by magyar;

select szolista.magyar
from szolista
where year(felvetel) between 2003 AND 2004
order by magyar;

select szolista.magyar
from szolista
where year(felvetel) = 2003 OR year(felvetel) = 2004
order by magyar;

select szolista.magyar
from szolista
where felvetel like "2003%" OR felvetel like "2004%"
order by magyar;

/5. Készítsen lekérdezést, amely megjeleníti azokat az angol szavakat,
amelyek valamelyik magyar jelentését legalább 150 fő helyesnek ítélte,
vagy kevesebb, mint 5 fő találta hibásnak! (5. feladat:)/
select angol
from szolista
where helyes>=150 or helytelen<5;

/6. Készítsen lekérdezést, amely megjeleníti
az „ac” betűkkel kezdődő és „y”-nal végződő angol szavakat
és a magyar megfelelőiket. (6. feladat:)/
select angol, magyar
from szolista
where angol like 'ac%y';

/7. Készítsen lekérdezést, amely megadja a 4000-nél
nagyobb azonosítójú angol szavakra vonatkozóan
a következőket: helyes minősítések száma,
helytelen minősítések száma,
minősítések száma átlagosan.
A harmadik mező „átlag” néven jelenjen meg.
(Egyetlen sort kell kiírni.) (7. feladat:)/
select sum(helyes), sum(helytelen), avg(helyes+helytelen) as 'átlag'
from szolista
where azon>4000;

/Rávezető feladatok:
7.a Készítsen lekérdezést, amely megadja a 4000-nél
nagyobb azonosítójú angol szavakra vonatkozóan
a következőket: angol szó, magyar szó,
helyes minősítések száma (soronként),
helytelen minősítések száma (soronként),
minősítések száma átlagosan (soronként).
A harmadik mező „minősítések száma átlagosan soronként” néven jelenjen meg.
(Több sort kell kiírni.) (7.a feladat:)/

select angol, magyar, helyes, helytelen, (helyes+helytelen)/2
as 'minősítések száma átlagosan soronként'
from szolista
where azon>4000;

/* 7.b Készítsen lekérdezést, amely megadja a 4000-nél
nagyobb azonosítójú angol szavakra vonatkozóan
a következőket:
helyes minősítések száma átlagosan (az összes sorban lévő értékek átlaga),
helytelen minősítések száma átlagosan (az összes sorban lévő értékek átlaga),
helyes és helytelen minősítések száma átlagosan (az összes sorban lévő értékek átlaga).
(Egyetlen sort kell kiírni.) (7.b feladat:)/

select avg(helyes), avg(helytelen), avg(helyes+helytelen) as 'minősítések száma átlagosan'
from szolista where azon>4000;
/Itt a helyes értékeket soronként összeadja,majd elosztja a rekordok számával,
a helytelen értékeket soronként összeadja,majd elosztja a rekordok számával,
soronként a helyes és helytelen értékeket összeadja,
majd ezeket is összeadja és elosztja a rekordok számával.
Ha két rekorddal ki akarjuk próbálni, konkrétan milyen eredményt kapunk:
select avg(helyes), avg(helytelen), avg(helyes+helytelen) as 'minősítések száma átlagosan'
from szolista where azon = 3203 or azon = 3204;
/

/ 7.c Készítsen lekérdezést, amely megadja a 4000-nél
nagyobb azonosítójú angol szavak számát.
(Egyetlen sort kell kiírni.) (7.c feladat:)/

select count(azon) as 'rekordok száma'
from szolista where azon>4000;
/Itt minden olyan mezőt megadhatunk a függvénynek, aminek az értéke garantáltan kitöltött.
Az azonosító mező ezért mindig alkalmas.
Vegyük észre, hogy az ilyen feladatoknál nincs értelme
kiírni egy mezőt, pl. az angol nevet, mivel az nem köthető
az összesítő függvény eredményéhez.
pl. a következő megoldás nem dob hibát, de nincs értelme:
select angol, count(azon) as 'rekordok száma' from szolista where azon>4000;
Itt az első, szűrésnek megfelelő rekordban lévő angol szót írja ki.
Győződj meg róla:
SELECT angol, azon FROM `szolista` where angol like "perfume";
/

/8. Készítsen lekérdezést, amely megadja,
hogy legelőször mikor került
a „warp” angol szó az adatbázisba! (8. feladat:)/

select felvetel
from szolista
WHERE angol like 'warp'
order by felvetel
limit 1;

select min(felvetel)
from szolista
WHERE angol like 'warp';

/9. Készítsen lekérdezést, amely megadja,
hogy az adatbázis angol szavai közül
melyeknek van legalább 3 magyar jelentése!
A lekérdezésben csak az angol szavak jelenjenek meg. (9. feladat:)*/
select angol
from szolista
group by angol
having count(azon)>=3;

2022.10.28. AB

Befejeztük a Hajó adatbázist.

Elkezdtük a Szótár adatbázist.

2022.10.27. AB

Számonkérés, illetve elkezdtük a Hajó adatbázist.

2022.10.25. AB-SQL

Ellenőriztük a múlt órai feladatsort (az utolsóra még visszatérünk). Röpdolgozat lesz a termék adatbázisból két óra múlva.

Termék adatbázis

1. Listázd ki a képernyőre a termék kódját, és árát a termék neve szerinti csökkenő sorrendben.

2. Listázd ki a képernyőre a csoport nevét, és a termék nevét, adj alias neveket a mezőknek.

3. Listázd ki a képernyőre az első 5 termék csoportnevét és a termék nevét.

4. Listázd ki a képernyőre azoknak a termékeknek a nevét, amelyekben szerepel az s betű és az ára 3000 és 30000 között van (beleértve a két értéket is).

5. Írd ki a képernyőre a csoportonkénti legolcsóbb termék csoportnevét, és a termék árát.

6. Listázd ki a képernyőre termékcsoportonként (a termék csoportneve jelenjen meg) a maximális árat.

6. Listázd ki a képernyőre azokat a termékeket, amelyet kódja nagyobb 1500-nál, kisebb 5000-nél, és a nevükben szerepel a monitor szó, vagy a kártya szó.

Az SQL jegyzetet folyamatosan kell tanulni.

Következő órákon várható gyakorlati számonkérés (de nem a következő órán).

Megoldás:

1. Listázd ki a képernyőre a termék kódját, és árát a termék neve szerinti csökkenő sorrendben.

SELECT termékkód, termék_ár FROM termékek ORDER BY terméknév DESC

2. Listázd ki a képernyőre a csoport nevét, és a termék nevét, adj alias neveket a mezőknek.

Select terméknév AS "termék", csoportnév AS "csoport" FROM termékcsoportok INNER JOIN termékek ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító

3. Listázd ki a képernyőre az első 5 termék csoportnevét és a termék nevét.

Select csoportnév, terméknév

FROM termékcsoportok INNER JOIN termékek

ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító

limit 5

4. Listázd ki a képernyőre azoknak a termékeknek a nevét, amelyekben szerepel az s betű és az

ára 3000 és 30000 között van (beleértve a két értéket is).

select terméknév

from termékek

where terméknév like "%s%"

AND (termék_ár>=3000 AND termék_ár<=30000)

5. Írd ki a képernyőre a csoportonkénti legolcsóbb termék csoportnevét, és a termék árát..

SELECT csoportnév, MIN(termék_ár)

FROM termékek INNER JOIN termékcsoportok

ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító

GROUP BY termékcsoportok.csoportnév

6. Listázd ki a képernyőre termékcsoportonként (a termék csoportneve jelenjen meg) a maximális árat.

SELECT csoportnév, MAX(termék_ár) FROM termékek INNER JOIN termékcsoportok ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító GROUP BY termékcsoportok.csoport_azonosító

7. Listázd ki a képernyőre azokat a termékeket, amelyet kódja nagyobb 1500-nál, kisebb 5000-nél,

és a nevükben szerepel a monitor szó, vagy a kártya szó.

select terméknév, termékkód

from termékek

where (terméknév like "%kártya%" OR terméknév like "%monitor%")

AND (termékkód>1500 AND termékkód<5000)

2022.10.21. AB-SQL

Helyettesítés lesz, ezt a feladatlapot kell megoldanod a Termék adatbázisra.

1. Listázd ki a képernyőre a termék kódját, és árát a termék neve szerinti csökkenő sorrendben.

2. Listázd ki a képernyőre a csoport nevét, és a termék nevét, adj alias neveket a mezőknek.

3. Listázd ki a képernyőre az első 5 termék csoportnevét és a termék nevét.

4. Listázd ki a képernyőre azoknak a termékeknek a nevét, amelyekben szerepel az s betű és az ára 3000 és 30000 között van (beleértve a két értéket is).

5. Írd ki a képernyőre a csoportonkénti legolcsóbb termék csoportnevét, és a termék ~~nevét~~ árát.

6. Listázd ki a képernyőre termékcsoportonként (a termék csoportneve jelenjen meg) a maximális árat.

6. Listázd ki a képernyőre azokat a termékeket, amelyet kódja nagyobb 1500-nál, kisebb 5000-nél, és a nevükben szerepel a monitor szó, vagy a kártya szó.

2022.10.20. AB - SQL

Megtanultuk az INNER JOIN-t, és befejeztük a Termék adatbázis feladatlapját, kiegészítettük további feladatokkal.

Adatbázis létrehozása, importálás
1.  Listázd ki a képernyőre a termék nevét, és árát a termék neve szerinti növekvő sorrendben.
select terméknév, termék_ár
 from termékek 
order by terméknév;
2.  Listázd ki a képernyőre a termék nevét és a csoport nevét, a második oszlop neve legyen: csoport.
select terméknév,csoportnév
as csoport
from termékek inner join termékcsoportok
on termékek.csoport_azonosító=termékcsoportok.csoport_azonosító;
3.  Listázd ki a képernyőre az első kettő termék csoportnevét és a termék nevét a csoport neve szerinti csökkenő sorrendben.
select csoportnév, terméknév
from termékek inner join termékcsoportok
on termékek.csoport_azonosító=termékcsoportok.csoport_azonosító
order by csoportnév desc
limit 2;
4.  Listázd ki a képernyőre azoknak a termékeknek a nevét, amelyekben szerepel a "kártya".
select terméknév from termékek
where terméknév like ”%kártya%”;
5.  Írd ki a képernyőre, hogy hány darab termék tartozik a 04-es csoportba (egyenlő a 04-gyel).
select count(termékkód)
from termékek
where csoport_azonosító=04;
6.  Írd ki a képernyőre a termékek átlag árát.
select avg(termék_ár)
from termékek;
7.  Listázd ki a képernyőre termékcsoportonként (a termék csoportkódja jelenjen meg) a maximális árat.
select csoportnév,
 max(termék_ár)
from termékek inner join termékcsoportok
on termékek.csoport_azonosító=termékcsoportok.csoport_azonosító
group by csoportnév;

-------------------
1.  Listázd ki a képernyőre a termék nevét, és árát a termék neve szerinti növekvő sorrendben.
SELECT terméknév, termék_ár FROM termékek ORDER BY terméknév ASC

2.  Listázd ki a képernyőre a termék nevét és a csoport nevét, a második oszlop neve legyen: csoport.
SELECT terméknév, csoportnév AS "csoport" FROM termékek INNER JOIN termékcsoportok ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító

3.  Listázd ki a képernyőre az első kettő termék csoportnevét és a termék nevét a csoport neve szerinti csökkenő sorrendben.
SELECT csoportnév,terméknév FROM termékcsoportok INNER JOIN termékek ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító ORDER BY csoportnév DESC LIMIT 2

4.  Listázd ki a képernyőre termékcsoportonként (a termék csoportneve jelenjen meg) a maximális árat.
SELECT csoportnév, MAX(termék_ár) FROM termékek INNER JOIN termékcsoportok ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító GROUP BY termékcsoportok.csoport_azonosító

5. Listázd ki a képernyőre termékcsoportonként a maximális árat csak  az első három sornak.
SELECT csoportnév, MAX(termék_ár) FROM termékek INNER JOIN termékcsoportok ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító GROUP BY termékcsoportok.csoport_azonosító LIMIT 3

6. Listázd ki a képernyőre termékcsoportonként a maximális árat csak az utolsó 3 sornak.
SELECT csoportnév, MAX(termék_ár) FROM termékek INNER JOIN termékcsoportok ON termékek.csoport_azonosító = termékcsoportok.csoport_azonosító GROUP BY termékcsoportok.csoport_azonosító ORDER BY csoportnév DESC limit 3

2022-10-18. SQL

A group by-t még megtanultuk. A termék adatbázis utolsó feladatával folytatjuk legközelebb.

2022.10.14. SQL

A Termék adatbázissal továbbmentünk, aztán visszatértünk az SQL jegyzethez, itt tartunk:

Az üzletkötők átlagfizetése: SELECT AVG (sal) FROM amp WHERE job = ’SALESMAN’;

2022.10.13. SQL

A XAMPP-ot innen töltheted le. Házi feladat feltelepíteni és kipróbálni az ÁRU adatbázist.

Megoldottuk az Áru adatbázishoz tartozó feladatsort.

Elkezdtük a Termék adatbázist.

1. feladat

Hozd létre az adatbázist.
CREATE DATABASE aru
    CHARACTER SET utf8
    COLLATE utf8_hungarian_ci;
2. feladat
Írass ki minden adatot az áru táblából.
SELECT * FROM áru
3. feladat
Írass ki minden adatot a kategória táblából.
SELECT * FROM kategória
4. feladat
Írass ki minden adatot a számla_részletező táblából.
SELECT * FROM számla_részletező
5. feladat
Írasd ki azokat az áruneveket, amelyet t betűvel kezdődnek.
SELECT árunév FROM áru WHERE árunév like "t%"
6. feladat
Írasd ki azokat az áruneveket, amelyet g betűvel végződnek.
SELECT árunév FROM áru WHERE árunév like "%g"
7. feladat
Írasd ki azokat az áruneveket, amelyekben van h betű.
SELECT árunév FROM áru WHERE árunév like "%h%"
8. feladat
Listázzuk ki az áru tábla tartalmát 
az áru egységára szerinti abc sorrendben.
SELECT * FROM áru order by áru_egységára
SELECT * FROM áru order by áru_egységára ASC
SELECT kategóriakód, árukód, árunév, áru_egységára FROM áru order by áru_egységára ASC
9. feladat
Listázzuk ki az áru tábla tartalmát 
az áru egységára szerinti csökkenő sorrendben.

SELECT * FROM áru order by áru_egységára desc
10. feladat
Listázzuk ki az áru kódját és nevét 
az áru egységára szerinti csökkenő sorrendben.
Csak azokat írjuk ki, amelyeknek az árukódja 4 és 6 között van,
a két értéket is beleértve.
Az árukód KÓD néven, az árunév ÁRU néven jelenjen meg.
SELECT árukód as KÓD, árunév as ÁRU 
FROM áru
WHERE Árukód between 4 and 6
order by áru_egységára

11. feladat
Az előző feladatot oldd meg más módszerrel.

SELECT árukód as KÓD, árunév as ÁRU FROM áru WHERE Árukód >= 4 and árukód <= 6 order by áru_egységára
12. feladat
Az előző feladatot egészítsd ki azzal, hogy
 csak a t betűvel keződő árukra vonatkozzon.
SELECT árukód as KÓD, árunév as ÁRU 
FROM áru
WHERE (árukód >= 4 and árukód <= 6) and
(árunév like "t%")
order by áru_egységára

2022.10.11. Adatbázis - SQL

SZÁMÍTOTT MEZŐK LÉTREHOZÁSA - eddig jutottunk el, aztán elkezdtük a gyakorlatot. Elkészítettük az ÁRU adatbázist, beimportáltuk az adatokat is.

2022.10.07. Adatbázis - SQL alapok

Az sql jegyzetet drive-on megosztva eléred. Az order by-ig jutottunk el.

2022.10.06. Ismétlés, számonkérés

2022.10.04. AB

Ellenőriztük a Horgászatot, írtunk témazárót, és megterveztük a Fesztiválok adatbázist. Aki nincs kész, annak házi feladat befejezni. Köv. órán röpdolgozat egy hasonló feladatból.

2022.09.27. AB tervezés

A horgász adatbázist majdnem készre megoldottuk. Házi feladat befejezni.

Tavalyi szalagavató

2022.09.23. AB

Elkezdtük az első adatbázis-tervezési feladatunkat Dia-val megtámogatva, excelben. Itt folytatjuk.

2022.09.22. AB

Az elméletből 1 hét múlva témazáró

Indextáblát készítettünk.

Próba röpdolgozat volt, a kérdéseit házi feladat otthon kidolgozni.

azonosító
fölérendelt tábla
N:M
redundancia
kapcsoló tulajdonság

Telepítettük a DIA diagramszerkesztő programot, elkezdtük kipróbálni.

2022.09.20. Adatbázis

Befejeztük az elméleti tananyagot, házi feladat megtanulni.

2022.09.16.

Faliújságot alkottunk...

2022.09.15. AB

A logikai adatmodellek következnek a jegyzetben.

Házi feladat az eddigieket megtanulni.

2022.09.13. AB

Eljutottunk az anomáliák végéig, és elkezdtünk adatbázist tervezni.

Ötletek:

védett állatok országos adatbázisa 4
öngyilkosságok... 1
használt tárgyak adás-vétele és ajándékozása 5
országos albérlet-kereső 6
szelektív hulladékgyűjtés 5
mentális betegségek 6
állatok örökbefogadása 6
talált állatok 7
szakember-kereső 10
szórakozóhely-kereső 6

Szakember-kereső adatbázis

Szakma

szakmaszám
név
leírás
(metaadatok)

Település

településId
név
irányítószám

Megye

megyeId
név

Tájegység

tájegységId
név

Szakember

szakemberAz
név
kezdés éve
telefonszám
telefonszámtípus
e-mail cím
webcím
fb oldal
insta
értékelés

Megrendelő

felhasználónév
név
jelszó
értékelés
e-mail

Telefonszám típus

telefonszámTípusId
név

2022.09.08. AB

Eddig jutottunk a jegyzetben: Adatintegritás.

2022.09.06. Adatbázis-kezelés

Eddig jutottunk a jegyzetben:

Adatbázis-kezelő rendszer fő funkciói

2022.05.31. Adatbázis

Megnéztük a dolgozatokat és az adatbázinál ejutottunk az azonosítóig.

2022.05.27. Önvezető autók régebbi példaprogram OOP megoldása

Ennek a feladatnak az első megoldása mindenkinek megvan a digifüzetében. Itt most közzéadom olyan optimalizált verzióját, amiben mindenre találsz példát.

Önvezető autók

Napjainkban az önvezető autók egyre gyorsabban fejlődnek, több neves cég is fejleszt ilyeneket. Ebben a feladatban a rájuk vonatkozó adatokat kell feldolgoznia.

Az adatokat a lenti keretben találja. Az állomány soronként tartalmazza az autók következő adatait egymástól pontosvesszővel elválasztva:

- azonosító (gyártó és modellszám)

- teljesítmény (lóerő)

- tömeg (tonna)

- gyorsulás (hány másodperc alatt gyorsul 100 km/h-ra)

- a vezetőnek hányszor kellett beavatkozni a vezetésbe 10.000 km-en

A fájlban 9 autó adatai vannak.

Tesla Model S P90D;760;2,20;3;3

Volvo XC90;889;2,90;4;14

Volkswagen GO989;1378;3,66;5;6

Audi Q525;772;2,40;2;3

Mercedes Benz898;739;2,20;3;9

Google Drive 18;752;2,55;4;11

Delphi Magic 428B;1194;3,00;3;4

Bosch Doom300;700;2,09;4;6

Nissan Cherry 100;725;3,1;3;7

Például a Tesla Model S P90D autó 760 lóerős teljesítményű, 2,2 tonna tömegű, 3 másodperc alatt gyorsul 100 km/órára és a 10.000 km-es tesztvezetésen 3-szor volt szükség humán beavatkozásra.

using System;

using System.Collections.Generic;

using System.IO;

namespace autokOOP

{

class auto

{

public string azonosito { get; set; } //property (tulajdonság/jellemző)

//a fentit a prop tab-tab módszerrel könnyen elő lehet hívni

//de így is lehetne egyszerűbben:

//public string azonosito;

public int loero { get; set; }

public double tomeg { get; set; }

public int gyorsulas { get; set; }

public int beavatkozas { get; set; }

public auto(string sor) //konstruktor, példányosításkor automatikusan végrehajtódik

{

string[] atmeneti = sor.Split(';');

azonosito = atmeneti[0];

loero = Convert.ToInt32(atmeneti[1]);

tomeg = Convert.ToDouble(atmeneti[2]);

gyorsulas = Convert.ToInt32(atmeneti[3]);

beavatkozas = Convert.ToInt32(atmeneti[4]);

}

public override string ToString() //virtuális metódus

{

return $"{azonosito,-18} | {loero,4} lóerő | {tomeg,4} t | {gyorsulas,2} mp | {beavatkozas,2}* kellett beavatkozni";

//így is jó:

//Console.WriteLine("{0,-18} | {1,4} lóerő | {2,4} t | {3,2} mp | {4,2}* kellett beavatkozni", azonosito, loero, tomeg, gyorsulas, beavatkozas);

}

//ez így egyszerűbb:

public void kiir()

{

Console.WriteLine($"{azonosito,-18} | {loero,4} lóerő | {tomeg,4} t | {gyorsulas,2} mp | {beavatkozas,2}* kellett beavatkozni");

}

class Program

{

static int leggyorsabb3(List<auto> a)

{

int kiIndex = 0;

int min = a[0].gyorsulas;

for (int i = 1; i < a.Count; i++)

{

if (min > a[i].gyorsulas)

{

min = a[i].gyorsulas;

kiIndex = i;

}

return kiIndex;

}

static void legkevesbeOnallo4(List<auto> a)

{

int kiIndex = 0;

int max = a[0].beavatkozas;

for (int i = 1; i < a.Count; i++)

{

if (max < a[i].beavatkozas)

{

max = a[i].beavatkozas;

kiIndex = i;

}

Console.WriteLine($"\nA legkevésbé önálló autó:\n{a[kiIndex]}");

}

static double atlag5(List<auto> a)

{

double osszTomeg = 0;

for (int i = 0; i < a.Count; i++)

{

osszTomeg += a[i].tomeg;

}

return osszTomeg / a.Count;

}

static void Main(string[] args)

{

List<auto> autok = new List<auto>(); //példányosítás

//2.Az adatokat olvassa be fájlból és tárolja el egy listában.

foreach (var item in File.ReadAllLines("autok.txt"))

{

autok.Add(new auto(item));

}

Console.WriteLine("Kiírás 4 módszerrel\n1. kiírás\n");

//Összes kiírása:

foreach (var i in autok)

{

Console.WriteLine(i);

}

Console.WriteLine("\n2. kiírás");

foreach (var i in autok)

{

Console.WriteLine(i.ToString());

}

Console.WriteLine("\n3. kiírás");

for (int i = 0; i < autok.Count; i++)

{

Console.WriteLine(autok[i].ToString());

}

Console.WriteLine("\n4. kiírás");

for (int i = 0; i < autok.Count; i++)

{

autok[i].kiir();

}

//3.Írja ki a képernyőre a minta szerint a leggyorsabb autó adatait.

//(Az a leggyorsabb, ami a legkevesebb idő alatt gyorsul 100 ra.)

//A feladatot függvénnyel kell megoldani.

int index = leggyorsabb3(autok);

Console.WriteLine($"\nLeggyorsabb autó:\n{autok[index]}"); //virtuális metódussal

Console.WriteLine($"\nLeggyorsabb autó once more:");

autok[index].kiir();

//4.Írja ki a képernyőre a minta szerint a legkevésbé önálló autó azonosítóját.

//(Az a legkevésbé önálló, amelynél a legtöbbet kellett beavatkozni a vezetésbe.)

//Metódust kell használni.

legkevesbeOnallo4(autok);

//6.Írja ki a képernyőre az autók átlag tömegét, függvénnyel.

Console.WriteLine("Az autók átlag tömege: {0:0.00}", atlag5(autok));

Console.WriteLine("Az autók átlag tömege once more: {0}", Math.Round(atlag5(autok),2));

//7.Írja ki a képernyőre, és egy új fájlba autónként a következő adatokat szóközzel elválasztva:

//sorszám(a feldolgozás sorrendjében automatikusan generált), tömeg kg-ban. (1 tonna = 1000 kg).

//Nem kötelező metódust használni.

Console.WriteLine("Fájlba írás 1. verzió");

List<string> ki = new List<string>();

for (int i = 0; i < autok.Count; i++)

{

ki.Add($"{i + 1}. {autok[i].tomeg * 1000} kg");

Console.WriteLine(ki[i]);

}

File.WriteAllLines("tomeg1.txt", ki);

Console.WriteLine("Fájlba írás 2. verzió");

StreamWriter sw = new StreamWriter("tomeg2.txt");

string kiirando = string.Empty;

for (int i = 0; i < autok.Count; i++)

{

kiirando = $"{i + 1}. {autok[i].tomeg * 1000} kg";

//egyszerűbben:

//kiirando = i + 1 + ". " + autok[i].tomeg * 1000 + " kg";

sw.WriteLine(kiirando);

Console.WriteLine(kiirando);

}

sw.Close();

Console.Write($"\nA program bezárásához nyomjon meg egy billentyűt...");

Console.ReadLine();

}