Simple Array / java

this program takes 3 numbers from user, puts them in an array and calculate the max,min,sum and the average of the numbers.

package aara;
import java.util.Scanner;

public class Aara {

public static void main(String[] args) {

float max,min,ave,sum;
int numb[] = new int[3];

Scanner input = new Scanner(System.in);

System.out.println("enter first number: ");

numb[0] = input.nextInt();

System.out.println("enter second number: ");

numb[1] = input.nextInt();

System.out.println("enter third number: ");

numb[2] = input.nextInt();

if(numb[0]>numb[1])
{
max = numb[0];
min = numb[1];
}
else
{
max = numb[1];
min = numb[0];
}
if(numb[2]>max)
{
max = numb[2];
}
else if(numb[2] {
min = numb[2];
}

sum = numb[0]+numb[1]+numb[2];
ave = sum/3;

System.out.println("max: "+max);
System.out.println("min: "+min);
System.out.println("average: "+ave);
System.out.println("sum: "+sum);
}

}

Waarom Array???

Waarom Array???
Stel dat we twee getallen van de invoer willen ontvangen en hun som willen berekenen en weergeven.
int s1, s2, sum;
Console.Write("Numer 1 =");
s1 = Convert.ToInt32(Console.ReadLine());
Console.Write("Numer 2 =");
s2 = Convert.ToInt32(Console.ReadLine());
sum = s1 + s2;
Console.WriteLine("Sum=" +sum);

Nu stel je dat we som van de honderd getallen willlen berekenen.

Dus soms moeten we grote hoeveelheden gelijkaardige gegevens bewaren in het geheugen van de computer, bijvoorbeeld een lijst met cijfers van studenten.
Het is onmogelijk om voor iedere cijfers van de studenten een nieuwe variabele te definiëren. In deze situatie kiezen we voor een array zodat we alle cijfers op één geheugenadres opslaan.

Een array (Engels voor rij of reeks) is bij het programeren computers een datastructuur die bestaat uit een lijst van elementen. Ieder element heeft een unieke index waarmee dat element aangeduid kan worden.

Hoewel een array een eenvoudige datastructuur is, kunnen er krachtige dingen mee gedaan worden.

De eenvoudigste implementatie van een array is een reeks opeenvolgende geheugencellen.

Een array is eigenlijk een tabel of matrix waarin we meerdere waarden van hetzelfde datatype kunnen opslaan. Aan iedere waarde in een array wordt een index toegekend.

Hoe kunnen

index=3	index=2	index=1	index=0

een array declareren???

We moeten drie dingen weten:
1- Aantal array-elementen
2- Type waarden binnen de array
3- Geselecteerde naam voor de array

Er zijn drie manieren om een array te declareren.
Een manier om arrays aan te maken is de volgende, waarbij je aangeeft hoe groot de array moet zijn, zonder reeds effectief waarden toe te kennen:

Model 1:
De eenvoudigste variant is deze waarbij je een array variabele aanmaakt, maar deze nog niet initialiseert (i.e. je maakt enkel een identifier in aan). De syntax is als volgt:
Type[] ArrayName;
Type kan dus eender welk bestaand datatype zijn dat je reeds kent. De [] (square brackets) duiden aan dat het om een array gaat.
double[] A;

Andere voorbeelden van array declaraties kunnen dus bijvoorbeeld zijn:

int[] verkoopCijfers;

double[] gewichtHuisdieren;

bool[] examenAntwoorden;

ConsoleColor[] mijnKleuren;
Model 2:
Indien je ogenblikkelijk waarden wilt toekennen (initialiseren) tijdens het aanmaken van de array zelf dan mag dit ook als volgt:

Type[] ArrayName= { Waarden };
string[] myColors = {"red", "green", "yellow", "orange", "blue"};
Ook hier zal dus vanaf dit punt je array een vaste lengte van 5 elementen hebben.

Merk op dat deze manier dus enkel werkt indien je reeds weet welke waarden in de array moeten. In manier 1 kunnen we perfect een array aanmaken en pas veel later in het programma ook effectief waarden toekennen (bijvoorbeeld door ze stuk per stuk door een gebruiker te laten invoeren).

Model 3:
Nog een andere manier om arrays aan te maken is de volgende, waarbij je aangeeft hoe groot de array moet zijn, zonder reeds effectief waarden toe te kennen:
Type[] ArrayName;
ArrayName= new Type[ lengthOfNumbers];
Uiteraard kan dit ook in 1 stap:
Type[] ArrayName= new Type[ lengthOfNumbers];

example:
We geven hier aan dat de array bestaan 5 elementen kan bevatten.

string[] myColors;
myColors = new string[5];

string[] myColors = new string[5];

Elementen van een array aanpassen en uitlezen
We plaatsen de naam van de array, gevolgd door brackets waarbinnen een getal , 2 in dit voorbeeld, aangeeft het index van element die we wensen te benaderen (lezen en/of schrijven). Deze nummering start vanaf 0.

myColors[2];

De regels:
Bij het maken van een array is de lengte van een array gelijk aan het aantal elementen dat er in aanwezig is. Dus een array met 5 elementen heeft als lengte 5.
string[] myColors = {"red", "green", "yellow", "orange", "blue"};
Bij het schrijven en lezen van individuele elementen uit de array gebruiken we een indexering die start bij 0. Bijgevolg is 4 de index van het laatste element in een array met lengte 5.

4	3	2	1	0
blue	orange	yellow	green	red

Lezen
We weten nu hoe we individuele waarden in een array kunnen benaderen. Ze gebruiken is dus exact hetzelfde zoals we in het verleden al met eender welke andere variabele hebben gedaan.

Wanneer je dus het tweede element van een array wenst te gebruiken kan dit bijvoorbeeld als volgt:

Console.WriteLine(myColors[1]);

of ook

string kleurkeuze = myColors[1];

of zelfs

if(myColors[1] == "pink")

Een array proberen te tonen als volgt gaat niet:
Console.WriteLine(myColors);
De enige manier alle elementen van een array te tonen is door manueel ieder element individueel naar het scherm te sturen. Bijvoorbeeld:

for(int i = 0 ; i{
Console.WriteLine($"{myColors[i]}");
}

Stel dat we een array van getallen hebben, dan kunnen we dus bijvoorbeeld 2 waarden uit die array optellen en opslaan in een andere variabele als volgt:

int[] numbers = {5, 10, 30, 45};
int som = numbers[0] + numbers[1];
De variabele som zal dan vervolgens de waarde 15 bevatten (5+10).

Stel dat we alle elementen uit de array numbers met 5 willen verhogen, dan kunnen we schrijven:
int[] numbers = {5, 10, 30, 45};
numbers[0] += 5;
numbers[1] += 5;
numbers[2] += 5;
numbers[3] += 5;
Maar eigenlijk zijn we dan het voordeel van arrays niet aan het gebruiken.

Met loops maken we bovenstaande oplossing beter zodat deze zal werken, ongeacht het aantal elementen in de array:

for(int teller = 0; teller < numbers.Length; teller++)
{
numbers[teller] += 5;
}

Zoals je merkt zijn loops en arrays dikke vrienden.

Schrijven
Ook schrijven van waarden naar de array gebruikt dezelfde notatie. Enkel moet je dus deze keer de array accessor-notatie links van de toekenningsoperator(=) plaatsen.
Stel dat we bijvoorbeeld de waarde van het eerste element uit de myColors array willen veranderen van red naar indigo, dan gebruiken we volgende notatie:

myColors[0] = "indigo";

De lengte van de array te weten komen
Soms kan het nodig zijn dat je in een later stadium van je programma de lengte van je array nodig hebt. De Length-eigenschap van iedere array geeft dit weer. Volgend voorbeeld toont dit:

string[] myColors1 = { "red", "green", "yellow", "orange", "blue" };
foreach (string x in myColors1)

Console.WriteLine(x);

Elementen benaderen buiten de range van een array geeft erg dikke errors.
Het jammerlijke is dat VS dit soort subtiele 'out of range' bugs niet kan detecteren tijdens het compileren.
Je zal ze pas ontdekken bij de uitvoer.

Volgende code zal perfect gecompileerd worden, maar bij de uitvoer zal er op lijn 2 een error verschijnen en het programma zal stoppen:

string[] myColors = { "red", "green", "yellow", "orange", "blue" };
Console.WriteLine(myColors[6]);

Het is hetzelfde als wanneer ik tegen m'n personeel zeg "ga jij de muur alvast metsen op de zesde verdieping" (etage[5]) terwijl we een flatgebouw met maar 4 verdiepingen hebben (.Length is dus 5).

Nu willen we een programma maken die getallen kunnen invoeren en som van de getallen kunnen berekenen en uitvoeren.

double[] A;
Console.Write(" Nummer van cijfers:" );
int n= Convert.ToInt32(Console.ReadLine());
A = new double[n];

for(int i=0;i {
Console.Write("A[" + i + "]=");
A[i]= Convert.ToDouble(Console.ReadLine());

}

Console.WriteLine(" Data in array :");
int j = 0;
foreach(double m in A)
{
Console.WriteLine("A[" + j + "]=" + m);
j++;
}

double number2=12345.67; string s1=$"{number2:(#).##}"; string s2=string.Format("{0:(#).##}", number2); string s3= number2.ToString("(#).##");

Mijn power point 

Waarom Array???

Stel dat we twee getallen van de invoer willen ontvangen en hun som willen berekenen en weergeven.

            int s1, s2, sum;

            Console.Write("Numer 1 =");  

             s1 = Convert.ToInt32(Console.ReadLine());      

            Console.Write("Numer 2 =");      

            s2 = Convert.ToInt32(Console.ReadLine());        

           sum = s1 + s2;        

         Console.WriteLine("Sum=" +sum);

Nu stel je dat we som van de honderd getallen willlen berekenen.

Dus soms moeten we grote hoeveelheden gelijkaardige gegevens bewaren in het geheugen van de computer, bijvoorbeeld een lijst met cijfers van studenten. Het is onmogelijk om voor iedere cijfers van de studenten een nieuwe variabele te definiëren. In deze situatie kiezen we voor een array zodat we alle cijfers op één geheugenadres opslaan.

Een array (Engels voor rij of reeks) is bij het programeren  computers  een datastructuur die bestaat uit een lijst van elementen. Ieder element heeft een unieke index waarmee dat element aangeduid kan worden.

Hoewel een array een eenvoudige datastructuur is, kunnen er krachtige dingen mee gedaan worden. De eenvoudigste implementatie  van een array is een reeks opeenvolgende geheugencellen.

Een array is eigenlijk een tabel of matrix waarin we meerdere waarden van hetzelfde datatype kunnen opslaan. Aan iedere waarde in een array wordt een index toegekend.

----------------------------------------------------------

Hoe kunnen een array declareren???

We moeten drie dingen weten:

1- Aantal array-elementen

2- Type waarden binnen de array

3- Geselecteerde naam voor de array

 

Er zijn drie manieren om een array te declareren.

Manier 1:

type[] arraynaam;

De eenvoudigste variant is deze waarbij je een array variabele aanmaakt, maar deze nog niet initialiseert (i.e. je maakt enkel een identifier in aan). De syntax is als volgt:

Type kan dus eender welk bestaand datatype zijn dat je reeds kent. De [] (square brackets) duiden aan dat het om een array gaat.

Voorbeelden van array declaraties kunnen dus bijvoorbeeld zijn:

 

int[] verkoopCijfers;

double[] gewichtHuisdieren;

bool[] examenAntwoorden;

ConsoleColor[] mijnKleuren;

 

Op dit punt bestaan de arrays nog niet echt. Hun lengte ligt nog niet vast.

Stel dat je dus een array van strings wenst waarin je verschillende kleuren zal plaatsen dan schrijf je:

string[] myColors;

Vervolgens kunnen we later waarden toekennen aan de array:

string[] myColors;

myColors = {"red", "green", "yellow", "orange", "blue"};

Je array zal vanaf dit punt een lengte van 5 hebben en kan niet meer groeien of krimpen.

 

Manier 2

Indien je ogenblikkelijk waarden wilt toekennen (initialiseren) tijdens het aanmaken van de array zelf dan mag dit ook als volgt:

string[] myColors = {"red", "green", "yellow", "orange", "blue"};

Ook hier zal dus vanaf dit punt je array een vaste lengte van 5 elementen hebben.

Merk op dat deze manier dus enkel werkt indien je reeds weet welke waarden in de array moeten. In manier 1 kunnen we perfect een array aanmaken en pas veel later in het programma ook effectief waarden toekennen (bijvoorbeeld door ze stuk per stuk door een gebruiker te laten invoeren).

 

Manier 3

Nog een andere manier om arrays aan te maken is de volgende, waarbij je aangeeft hoe groot de array moet zijn, zonder reeds effectief waarden toe te kennen:

 

   Type[ ] ArrayName;

    ArrayName= new Type[ lengthOfNumbers];

example:

string[] myColors;

myColors = new string[5];

Uiteraard kan dit ook in 1 stap:

Type[ ] ArrayName= new Type[ lengthOfNumbers];  

example:

string[] myColors = new string[5];

We geven hier aan dat de array vanaf z'n prille bestaan 5 elementen kan bevatten.

 

Ook hier geldt dat de lengte vanaf dan vastligt en niet meer kan veranderen.

---------------------------------------------------------------------------------------------------------------

 

Elementen van een array aanpassen en uitlezen

Van zodra er waarden in een array staan of moeten bijgeplaatst worden kan je deze benaderen met de zogenaamde array accessor notatie. Deze notatie is heel eenvoudigweg de volgende:

myColors[2]; //element met index 2

We plaatsen de naam van de array, gevolgd door brackets waarbinnen een getal , 2 in dit voorbeeld, aangeeft het hoeveelste element we wensen te benaderen (lezen en/of schrijven). Deze nummering start vanaf 0.

De regels zijn duidelijk:

Bij het maken van een array is de lengte van een array gelijk aan het aantal elementen dat er in aanwezig is. Dus een array met 5 elementen heeft als lengte 5.

Bij het schrijven en lezen van individuele elementen uit de array (zie hierna) gebruiken we een indexering die start bij 0. Bijgevolg is 4 de index van het laatste element in een array met lengte 5.

 

Lezen

We weten nu hoe we individuele waarden in een array kunnen benaderen. Ze gebruiken is dus exact hetzelfde zoals we in het verleden al met eender welke andere variabele hebben gedaan. Het enige verschil is dat de identifier dus vierkante haken met een index in bevat om aan te geven welke element we nodig hebben van de array.

Wanneer je dus het tweede element van een array wenst te gebruiken kan dit bijvoorbeeld als volgt:

 

Console.WriteLine(myColors[1]);

of ook

string kleurkeuze = myColors[1];

of zelfs

if(myColors[1] == "pink")

Kortom, alles wat je al kon, kan ook met arrays. Je kan ze zelfs als parameters aan methoden meegeven of terugkrijgen (zie verder).

Een array proberen te tonen als volgt gaat niet:

Console.WriteLine(myColors);

De enige manier alle elementen van een array te tonen is door manueel ieder element individueel naar het scherm te sturen. Bijvoorbeeld:

 

for(int i = 0 , i

{

Console.WriteLine($"{myColors[i]}");

}

Stel dat we een array van getallen hebben, dan kunnen we dus bijvoorbeeld 2 waarden uit die array optellen en opslaan in een andere variabele als volgt:

int[] numbers = {5, 10, 30, 45};

int som = numbers[0] + numbers[1];

De variabele som zal dan vervolgens de waarde 15 bevatten (5+10).

Stel dat we alle elementen uit de array numbers met 5 willen verhogen, dan kunnen we schrijven:

 

int[] numbers = {5, 10, 30, 45};

numbers[0] += 5;

numbers[1] += 5;

numbers[2] += 5;

numbers[3] += 5;

Maar eigenlijk zijn we dan het voordeel van arrays niet aan het gebruiken. Met loops maken we bovenstaande oplossing beter zodat deze zal werken, ongeacht het aantal elementen in de array:

 

for(int teller = 0; teller < numbers.Length; teller++)

{

numbers[teller] += 5;

}

Zoals je merkt zijn loops en arrays dikke vrienden.

Schrijven

Ook schrijven van waarden naar de array gebruikt dezelfde notatie. Enkel moet je dus deze keer de array accessor-notatie links van de toekenningsoperator plaatsen. Stel dat we bijvoorbeeld de waarde van het eerste element uit de myColors array willen veranderen van red naar indigo, dan gebruiken we volgende notatie:

myColors[0] = "indigo";

Als we dus bij aanvang nog niet weten welke waarden de individuele elementen moeten hebben in een array, dan kunnen we deze eerst definiëren, en vervolgens individueel toekennen:

string[] myColors;

myColors = new string[5];

// ...

myColors[0] = "red";

myColors[1] = "green";

myColors[2] = "yellow";

myColors[3] = "orange";

myColors[4] = "blue";

Een veel gestelde vraag wanneer een programmeur het nut van arrays nog niet 100% ziet is het volgende. Stel dat je deze code hebt;

int dag1 = 34;

int dag2 = 45;

int dag3 = 0;

int dag4 = 34;

int dag5 = 12;

int dag6 = 0;

int dag7 = 23;

 

       double[] A;

       Console.Write(" Nummer van cijfers:" );

       int n= Convert.ToInt32(Console.ReadLine());  

       A = new double[n];

----------------------------------------------

De eigenschap Length van een array

Een array heeft de eigenschap Length die aangeeft hoeveel elementen er in de array zitten. Deze eigenschap kan gebruikt worden om de bovengrens van de teller aan te geven in de for-lus. Ook deze manier van werken vermijdt eventuele fouten veroorzaakt door een verkeerd aantal elementen op te geven.

================================

Bij het maken van een array is de lengte van een array gelijk aan het aantal elementen dat er in aanwezig is. Dus een array met 5 elementen heeft als lengte 5.

 

       for(int i=0;i<=A.Length;i++)

            {

                Console.Write("A[" + i + "]=");

                A[i]= Convert.ToDouble(Console.ReadLine());  

             }

__________________________________________

 

       Console.WriteLine(" Data in array :");

            int j = 0;

            foreach(double  m in A)            

               {                

                Console.WriteLine("A[" + j + "]=" + m);

                j++;            

              }

---------------------------------------------

Nu kunnen we gemiddelde van array met 10 elementen berekenen.

≈============================================

 

Indien je ogenblikkelijk waarden wilt toekennen (initialiseren) tijdens het aanmaken van de array zelf dan mag dit ook als volgt:

 

int[] A =  { 12, 6, 8, 9, 4 };  

Stel dat je dus een array van strings wenst waarin je verschillende kleuren zal plaatsen dan schrijf je:

string[] B =  { "Zwart", "wit", "Blauw", "Groen" };

Merk op dat deze manier dus enkel werkt indien je reeds weet welke waarden in de array moeten.

 

Array2

Een array (Engels voor rij of reeks) is bij het programeren computers een datastructuur die bestaat uit een lijst van elementen. Ieder element heeft een unieke index waarmee dat element aangeduid kan worden.

Hoewel een array een eenvoudige datastructuur is, kunnen er krachtige dingen mee gedaan worden.

De eenvoudigste implementatie van een array is een reeks opeenvolgende geheugencellen.

Een ​​pure array heeft als index een verzameling van opeenvolgende integers, of een ander discreet datatype. De elementen van array worden meestal opeenvolgend in het geheugen opgeslagen.

In C, en de meeste andere talen met pure arrays , zijn alle elementen van de array hetzelfde type.

meerdimensionale arrays

In veel programmeertalen is het ook mogelijk om meerdimensionale arrays te gebruiken.

Het voordeel van deze representatie is snelheid: alle elementen staan bij elkaar in het geheugen, er hoeven geen pointers gevolgd te worden naar andere delen van het geheugen.

Een andere mogelijkheid is om de rijen achter elkaar op te slaan als elementen in een eendimensionale array. Een tweedimensionale array met m rijen en n kolommen wordt dan een eendimensionale van grootte m×n. De eerste rij is dan opgeslagen in elementen 1 tot en met n, de tweede in elementen n+1 tot en met 2n, enz.

Tweedimensionale array

 

http://www.cpp-programming.blogsky.com/category/cat-1/

 

#include
#include
main()
{
clrscr();
long int a,b;
int i=0;
cout<<"enter number=";
cin>>a;
while(a>0)
{
b=a%10;
a/=10;
if(b%2==0)
i++;
}
cout<<"tedade zojha="}

 

#include
#include
int main()
{
   long num; int c=0;
   clrscr();
   cout<<"enter a number:";
   cin>>num;
   if (num==0)
   {
      cout<<"length of num:1";
      getch();
      return 0;
   }
   while (num !=0)
   {
      c++;
      num =num/10;
   }
   cout <<"length of num:" << c;
   getch();
   return 0;
}