LearningApps.org - interaktive und multimediale Lernbausteine

Anzeigesprache:

Titel der App

Aufgabenstellung

Geben Sie eine Aufgabenstellung zu dieser App ein. Diese wird beim Start eingeblendet. Benötigen Sie diese nicht, lassen Sie das Feld einfach leer.

Aufgabenart

Wählen Sie die Art der Aufgabe. Sollen die Lücken durch eine Auswahl vorgegebener Wörter gefüllt werden oder durch Einschreiben. Haben Sie bei Aufgabenart Einschreiben gewählt, können Sie entscheiden, ob die Groß- und Kleinschreibung beachtet werden muss.

Aufgabenart

Auswahl aus Liste

Groß- und Kleinschreibung beachten

Überschrift

Geben Sie optional einen Titel und Untertitel als Bild, Audio oder Video vor dem eigentlichen Lückentext an.

Überschrift 1

Text Bild Text zu Audio Audio Video

Überschrift 2

Hinweis:

Lückentext

Geben Sie hier den Lückentext ein. Verwenden Sie -1-, -2- usw. als Platzhalter für die Lücken im Text. Sie können die gleiche Lücke (Platzhalter) auch mehrmals verwenden.

<h2>Simetrizarea Matricilor: Diagonale și Centrul </h2>

---------------------------------------
1.Simetrizarea elementelor plasate deasupra diagonalei principale

<pre>Scrie un program C++ care citește o matrice pătratică de dimensiune n × n din fișierul "date.in". 
-Afișează matricea inițială în fișierul "date.out";
-Simetrizează matricea prin oglindirea elementelor plasate deasupra diagonalei principale;
-Afișează matricea transformată în fișierul "date.out".
Programul este implementat prin funcții iterative sau prin iterații în corpul funcției main(). </pre>🌟Prin atribuiri directe elementele aflate sub diagonala principală se pierd. Pentru a menține integritatea datelor în timpul procesului de oglindire, matricea inițială este copiată într-o matrice auxiliară (aux). Aceasta asigură păstrarea valorilor originale ale elementelor în timpul procesului de simetrizare!
Exemplu:
<pre>date.in
4 
1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 16

date.out
afisare matrice originala:
  1   2   3   4 
  5   6   7   8 
  9  10  11  12 
 13  14  15  16

afisareMatr.simetr. fata de diagonalaP:
 1 2 3 4 
 2 6 7 8 
 3 7 11 12 
 4 8 12 16 </pre>

I.implementare prin funcții iterative
<pre>#include< fstream >
#include< iomanip >
#define dim 100
using namespace std;

ifstream f("date.in");
ofstream g("date.out");
void citMat(int a[][dim], int &n);
void afisMat(int a[][dim], int n);
..................................;

int main()
{
 int a[dim][dim], n, i, j;
citMat(a,n);
g<< "\nafisare matrice originala:\n" ;
afisMat(a,n);
g<< "\nafisareMatr.simetr. fata de diagonalaP:\n" ;
simetrieDgP(a,n);
afisMat(a,n);
}
void citMat(int a[][dim], int &n)
{f>>n;
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 f>>a[i][j];
}
void afisMat (int a[][dim], int n)
{
for(int i=0; i < n; i++)
 { for(int j=0; j < n;j++)
 g<< ........ << a[i][j] << " " ;
g<< endl; }
}

void simetrieDgP (int a[][dim], int n)
{
int aux[dim][dim];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=a[i][j];

for(int i=0;i < n; i++)
 for(int j=0;j < i; j++)
 a[i][j]=aux[j][i];
 }</pre>
🌍Alege prototipul funcției care copiază elementele de deasupra diagonalei principale peste elementele corespunzătoare de sub diagonală, simetrizând matricea față de diagonala principală:-1-
🌍Funcția afisMat afișează matricea în fișierul date.out utilizând formatări pentru aliniere: -2-


II.implementare iterativă, cu instrucțiuni scrise direct în corpul funcției main().
<pre>#include< fstream >
#include< iomanip >
using namespace std;
int main()
{
int A[100][100], n, i, j;
ifstream f ("date.in");
ofstream g ("date.out");
f>>n;
for(i=0; i < n; i++)
 for(j=0; j < n;j++)
 f>>A[i][j];
g<< "\nafisareMatriceOriginala \n" ;
for(i=0; i < n; i++)
{
 for (j=0; j < n; j++)
 g<< setw(3) << A[i][j] << " " ;
g<< endl;
}
g<< "\nsimetria elementelor de deasupra dgP :\n" ;
int aux[100][100];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=A[i][j];

for(i=0; i < n; i++)
 for(j=0; j < i; j++)
 ............;

g<< "\nafisarematr.simetr. fata de diagonalaP:\n" ;
for(i=0;i < n;i++)
 {
 for(j=0;j < n;j++) 
 g<< setw(3) << A[i][j] << " " ;
g<< endl;
}
 }
</pre>
🌍Modifică matricea inițială prin schimbarea elementelor aflate deasupra diagonalei principale cu elementele corespunzătoare aflate sub diagonală: -3-

---------------------------------------
2.Oglindirea elementelor de sub diagonala principală

date.out
afisare matrice originala:
  1   2   3   4 
  5   6   7   8 
  9  10  11  12 
 13  14  15  16

afisareMatr. oglindireDeSub dgP:
 1 5 9 13 
 5 6 10 14 
 9 10 11 15 
 13 14 15 16 </pre>

Implementare prin funcții iterative
<pre>#include< fstream >
#include< iomanip >
#define dim 100
using namespace std;

ifstream f("date.in");
ofstream g("date.out");
void citMat(int a[][dim], int &n);
void afisMat(int a[][dim], int n);
...............................;

int main()
{
 int a[dim][dim], n, i, j;
citMat(a,n);
g<< "\nafisare matrice originala:\n" ;
afisMat(a,n);
g<< "\nafisareMatr. oglindireDeSub dgP:\n" ;
oglindireDeSubDgP(a,n);
afisMat(a,n);
}
void citMat(int a[][dim], int &n)
{f>>n;
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 f>>a[i][j];
}
void afisMat (int a[][dim], int n)
{
for(int i=0; i < n; i++)
 { for(int j=0; j < n;j++)
 g<< setw(3) << a[i][j] << " " ;
g<< endl; }
}
void oglindireDeSubDgP(int a[][dim], int n)
{
int aux[dim][dim];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=a[i][j];

for(int i=1; i < n; i++)
 for(int j=0; j < i; j++)
 ..............; }</pre>
🌍Alege prototipul funcției care copiază elementele aflate sub diagonala principală deasupra diagonalei, astfel încât matricea devine simetrică față de diagonala principală:-4-.
🌍Elementele de deasupra diagonalei principale sunt înlocuite cu valorile corespunzătoare din partea de jos a diagonalei:-5-

---------------------------------------
3.Oglindirea elementelor plasate deasupra diagonalei secundare

date.out
afisare matrice originala:
  1   2   3   4 
  5   6   7   8 
  9  10  11  12 
 13  14  15  16

afisareMatr. oglindireDeasupraDgSec:
 1 2 3 4 
 5 6 7 3 
 9 10 6 2 
 13 9 5 1</pre>

I.implementare prin funcții iterative
<pre>#include< fstream >
#include< iomanip >
#define dim 100
using namespace std;

ifstream f("date.in");
ofstream g("date.out");
void citMat(int a[][dim], int &n);
void afisMat(int a[][dim], int n);
void oglindireDeasupraDgSec(int a[][dim], int n);

int main()
{
 int a[dim][dim], n, i, j;
citMat(a,n);
g<< "\nafisare matrice originala:\n" ;
afisMat(a,n);
g<< "\nafisareMatr. oglindireDeasupraDgSec:\n" ;
.......................................;
afisMat(a,n);
}
void citMat(int a[][dim], int &n)
{f>>n;
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 f>>a[i][j];
}
void afisMat (int a[][dim], int n)
{
for(int i=0; i < n; i++)
 { for(int j=0; j < n;j++)
 g<< setw(3) << a[i][j] << " " ;
g<< endl; }
}
void oglindireDeasupraDgSec(int a[][dim], int n)
{
int aux[dim][dim];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=a[i][j];

for(int i=0;i < n; i++)
 for(int j=0;j < n; j++)
 if(i+j > n- 1) .......................;
 
 }</pre>
🌍Alege apelul funcției care simetrizează matricea față de diagonala secundară prin copierea elementelor de deasupra diagonalei secundare peste cele de sub diagonală:-6-
🌍Copiază elementul de deasupra diagonalei secundare în poziția corespunzătoare de sub diagonala secundară:-7- 


II.implementare iterativă, cu instrucțiuni scrise direct în corpul funcției main().
<pre>#include< fstream >
#include< iomanip >
using namespace std;
int main()
{
int A[100][100], n, i, j;
ifstream f ("date.in");
ofstream g ("date.out");
f>>n;
for(i=0; i < n; i++)
 for(j=0; j < n;j++)
 f>>A[i][j];
g<< "\nafisareMatriceOriginala \n" ;
for(i=0; i < n; i++)
{
 for (j=0; j < n; j++)
 g<< setw(3) << A[i][j] << " " ;
g<< endl;
}
g<< "\noglindireDeasupraDgSec:\n" ;
int aux[dim][dim];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=A[i][j];

for(int i=0;i < n; i++)
 for(int j=0;j < n; j++)
 if(..................) A[i][j]=A[n- 1 -j][n- 1 -i];

g<< "\nafisarematr. oglindireDeasupraDgSec:\n" ;
for(i=0;i < n;i++)
 {
 for(j=0;j < n;j++) 
 g<< setw(3) << A[i][j] << " " ;
g<< endl;
}
 }</pre>
🌍Verifică dacă elementul a[i][j] este sub diagonala secundară:-8-

---------------------------------------
4.Oglindirea elementelor de sub diagonala secundară

date.out
afisare matrice originala:
  1   2   3   4 
  5   6   7   8 
  9  10  11  12 
 13  14  15  16

afisareMatr. oglindireSubDgSec:
 16 12 8 4 
 15 11 7 8 
 14 10 11 12 
 13 14 15 16 </pre>

Implementare prin funcții iterative
<pre>#include< fstream >
#include< iomanip >
#include<fstream>
#include<iomanip>
#define dim 100
using namespace std;

ifstream f("date.in");
ofstream g("date.out");
void citMat(int a[][dim], int &n);
void afisMat(int a[][dim], int n);
void oglindireSubDgSec(int a[][dim], int n);

int main()
{
 int a[dim][dim], n, i, j;
citMat(a,n);
g<< "\nafisare matrice originala:\n" ;
afisMat(a,n);
g<< "\nafisareMatr. oglindireSubDgSec:\n" ;
.........................................;
afisMat(a,n);
}
void citMat(int a[][dim], int &n)
{f>>n;
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 f>>a[i][j];
}
void afisMat (int a[][dim], int n)
{
for(int i=0; i < n; i++)
 { for(int j=0; j < n;j++)
 g<< setw(3) << a[i][j] << " " ;
g<< endl; }
}
void oglindireSubDgSec(int a[][dim], int n)
{
int aux[dim][dim];
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 aux[i][j]=a[i][j];

for(int i=0;i < n; i++)
 for(int j=0;...... ; j++)
 ........=aux[n- 1 -j][n- 1 -i];
 }</pre>
🌍Alege apelul funcției care simetrizează matricea față de diagonala secundară prin copierea elementelor de sub diagonala secundară (i + j > n - 1) peste cele de deasupra diagonalei secundare (i + j < n - 1):-9-.
🌍Iterează doar sub diagonala secundara (j se oprește înainte de diagonala secundară): -10-
🌍Atribuirea directă copiază elementul de sub diagonala secundară (aux[n - 1 - j][n - 1 - i]) în poziția corespunzătoare de deasupra diagonalei secundare (a[i][j]):-11-

---------------------------------------
5.Matrice simetrică față de centru

<pre>Scrie un program C++ care citește o matrice pătratică de dimensiune n × n din fișierul "date.in". 
-Afișează matricea inițială în fișierul "date.out";	
- Simetrizează matricea față de centru prin interschimbarea elementelor, nu prin atribuire; 
- Afișează matricea transformată în fișierul "date.out".
Programul este implementat prin funcții iterative .</pre>
🌟Interschimbarea elementelor din colțul dreapta jos cu cele din colțul stânga sus, și elementele din colțul stânga jos cu cele din colțul dreapta sus, asigură că toate valorile sunt corect mutate la pozițiile lor simetrice fără a pierde valorile originale!
Exemplu:
<pre>date.in
4 
1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 16

date.out
afisare matrice originala:
  1   2   3   4 
  5   6   7   8 
  9  10  11  12 
 13  14  15  16

afisareSimetrieFataDeCentru:
 16 15 14 13 
 12 11 10 9 
 8 7 6 5 
 4 3 2 1 
 </pre>
<pre>#include< fstream >
#include< iomanip >
#define dim 100
using namespace std;

ifstream f("date.in");
ofstream g("date.out");
void citMat(int a[][dim], int &n);
void afisMat(int a[][dim], int n);
void simetrieFataDeCentru(int a[][dim], int n);

int main()
{
 int a[dim][dim], n, i, j;
citMat(a,n);
g<< "\nafisare matrice originala:\n" ;
afisMat(a,n);
g<< "\nafisareSimetrieFataDeCentru:\n" ;
simetrieFataDeCentru(a,n);
afisMat(a,n);
}
void citMat(int a[][dim], int &n)
{f>>n;
for(int i=0; i < n; i++)
 for(int j=0; j < n;j++)
 f>>a[i][j];
}
void afisMat (int a[][dim], int n)
{
for(int i=0; i < n; i++)
 { for(int j=0; j < n;j++)
 g<< setw(3) << a[i][j] << " " ;
g<< endl; }
}
void simetrieFataDeCentru(int a[][dim], int n)
{int aux;
for(int i=0;......; i++)
 for(int j=0;j < n; j++)
 { aux=a[i][j];
 a[i][j]=a[n- 1 -i][n- 1 -j];
 a[n- 1 -i][n- 1 -j]=aux; }
 }</pre>
🌍Se parcurg liniile până la -12- pentru a evita schimbarea înapoi a elementelor deja schimbate.
Simetrizarea față de centru implică utilizarea a două axe de simetrie (verticală și orizontală) care trec prin centrul matricei, interschimbând elementele din colțul dreapta jos cu cele din colțul stânga sus, și elementele din colțul stânga jos cu cele din colțul dreapta sus. Acest proces va "oglindi" matricea față de centrul său!

Lücken

Je nach gewählter Aufgabenart (Auswahl, Einschreiben) geben Sie hier die einzelnen Lücken an. Auswahl: Geben Sie entweder das richtige Lösungswort oder jeweils die zur Auswahl stehenden Wörter für eine Lücke getrennt durch ; an. Das erste angegebene Element entspricht dann immer der richtigen Lösung, die folgenden Elemente sind falsch. Einschreiben: Geben Sie alle als richtig gewerteten Wörter getrennt durch ; für jede Lücke an.

Lücke -1-

Lücke -2-

Lücke -3-

Lücke -4-

Lücke -5-

Lücke -6-

Lücke -7-

Lücke -8-

Lücke -9-

Lücke -10-

Lücke -11-

Lücke -12-

Lücke -13-

Lücke -14-

Lücke -15-

Lücke -16-

Lücke -17-

Lücke -18-

Lücke -19-

Lücke -20-

Lücke -21-

Lücke -22-

Lücke -23-

Lücke -24-

Lücke -25-

Lücke -26-

Lücke -27-

Lücke -28-

Lücke -29-

Lücke -30-

Lücke -31-

Lücke -32-

Lücke -33-

Lücke -34-

Lücke -35-

Lücke -36-

Lücke -37-

Lücke -38-

Lücke -39-

Lücke -40-

Lücke -41-

Lücke -42-

Lücke -43-

Lücke -44-

Lücke -45-

Lücke -46-

Lücke -47-

Lücke -48-

Lücke -49-

Lücke -50-

Hilfe einblenden (bei Einschreiben)

Wenn drei Mal eine falsche Eingabe erfolgt, wird eine Lösungshilfe eingeblendet.

Hilfe einblenden (bei Einschreiben)

Feedback

Geben Sie einen Text an, der eingeblendet wird, wenn alle Fragen richtige beantwortet wurden.

Hintergrundbild

Wählen Sie optional ein Hintergrundbild für den Lückentext aus.

Hilfestellung

Geben Sie Lösungshinweise an, die über ein kleines Symbol in der linken oberen Ecke der App vom Nutzer abgerufen werden können. Benötigen Sie diese nicht, lassen Sie das Feld einfach leer.