algoritmi strukture podataka uvod u oop · 2020. 4. 3. · programa informacione tehnologije,...

АКАДЕМИЈА СТРУКОВНИХ СТУДИЈА ЗАПАДНА СРБИЈА Одсек Ужице 31000 Ужице • Трг Светог Саве 34 www.vpts.edu.rs [email protected]

Предмети: Увод у објектно програмирање Алгоритми и структуре података

др Милован Миливојевић страна 1 oд 30

Блок 3-P Algoritmi ● Strukture podataka ●

Uvod u OOP

др Милован Миливојевић

http://www.vpts.edu.rs/




VAŽNO

• Materijal u ovom Bloku predstavlja kompilaciju materije iz referenci [1], [2] i [7];

• Materija je namenjena samo za internu upotrebu za studente I i II godine - studijskog programa Informacione tehnologije, Akademije zapadna Srbija ● odsek Užice, kao pomoć u pripremi i savladavanju materije vezane za: Algoritme, Strukture podataka i Uvod u objektno programiranje;

• Pri korišćenju ovog teksta za druge namene OBAVEZNO je referenciranje na originalnu literaturu.

Preporučena literatura:

1.

Microsoft Visual C# 2012 korak po korak

Autor: John Sharp

Izdavač: CET Beograd, Srbija Godina izdavanja: 2013.

2.

Microsoft Visual C# Step by Step, Ninth Edition

John Sharp

Izdavač: Published with the authorization of Microsoft Corporation by: Pearson Education, Inc. Copyright © 2018 by Pearson Education, Inc.

3.

Exam Ref 70-483: Programming in C#

Wouter de Kort

Published with the authorization of Microsoft Corporation by: O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, California 95472 /// Copyright © 2013 by O'Reilly Media, Inc.

4.

Osnove dizajna i analize algoritama

Autor(i): Dejan Živković

Godina izdavanja: 2007.

5.

Algoritmi i strukture podataka

Autor: Milo Tomašević

Izdavač: Mikroknjiga Beograd, Srbija Godina izdavanja: 2008.

6.

Algoritmi i strukture podataka

Autor: Dragan Urošević

Izdavač: Računarski fakultet Beograd (RAF) / CET Beograd, Srbija Godina izdavanja: 2018.

7.

Rešeni zadaci iz programskog jezika C# (drugo izdanje)

Autor: Laslo Klaus

Izdavač: Akademska Misao Beograd, Srbija Godina izdanja: 2018.





Sadržaj 3. BLOKA

• Elementi C# sitakse i semantike.

• Iskazi, ključne reči, identifikatori.

• Primitivni tipovi podataka. Deklaracija promenljivih.

• Rad sa promenljivim, operatorima i izrazima.

• Korišćenje Bulovih operatora

• Naredbe grananja (if ... else ...).

• Naredba višestrukog grananja (switch ... case).

Iskazi. Identifikatori. Ključne reči.

• Iskaz je komanda koja izvršava neku određenu radnju.

• Sintaksa predstavlja definisani skup pravila kojima se opisuje formatiranje i pravila konstrukcije iskaza.

OSNOVNO PRAVILO: Svalki iskaz u C# se mora završiti sa ;

Često se koristi pojam IDENTIFIKATOR. Identifikatori su nazivi koji se koriste da bi se identifikovali elementi programa kao što su prostori imena, klase, metode i promenljive.

Pravilo 1: U C# se za identifikatore mogu koristiti samo:

o slova (mala i velika) o cifre i o donja crta (_).

Pravilo 2: Identifikator mora počinjati slovom.

C# ima rezervisano preko 70 identifikatora za vlastitu upotrebu. Ovakvi identifikatori nazivaju se ključne reči.

Primeri ključnih reči:

class

namespace

using

new

if

switch

private

public

do

double

float

int

while,

...





• Jedan od ključih pojmova je i pojam promenljive (varijable).

• Promenljiva (varijabla) je skladišna lokacija koja sadrži neku vrednost.

• Svaka promenljiva mora imati nedvosmislen naziv.

Pravila za imenovanje varijabli:

1. Ne koristiti kosu crtu (/) 2. Ne treba koristiti imena varijabli koja se razlikuju samo po velikim i malim slovima. 3. Naziv varijable treba započeti malim slovom 4. Koristiti notaciju camelCase (u identifikatoru koji se sastoji od više reči, počev od

druge reči svaka počinje velikim slovom... primer: zbirClanovaNiza)

Primitivni tipovi podataka. Deklarisanje promenljivih

C# sadrži čitav niz ugrađenih tipova koje nazivamo PRIMITIVNIM TIPOVIMA PODATAKA.

Tabela 3.1. Vrste primitivnih tipova podataka ●

Tip podataka

Opis Veličina (bytes)

Opseg Primeri

int celi brojevi 4 -231 do 231-1 int count

count=42;

long celi brojevi (veći raspon)

8 -263 do 263-1 long mm

mm=43L;

float Realni brojevi sa pokretnim zarezom

4 +-1.5x10-45 do +-3.4x 1038

float mik

mik=0.42F;

Dovoljno da memoriše 6 do 7 decimala

double

Realni brojevi sa pokretnim zarezom dvostruke preciznosti

8 +-5.0 x 10-324 do +-1.7 x 10308

double a34 a34=0.42;

Dovoljno da memoriše 15 decimala

decimal Novčane vrednosti

7 28 značajnih cifara decimal pare pare=0.42M;

string Nizovi karaktera

2 bytes po znaku

Nije primenljivo string vest vest=”baba-roga”;

char Pojedinačni znak

2 0 do 216-1 char grill

grill=’x’

bool Logičke vrednosti

8 True (tačno) ili False (netačno=

bool pravda pravda=false;





Deklarisanje promenljivih.

• Promenljiva sadrži vrednost. / kutijica u memoriji računara koja čuva neku privremenu vrednost

• C# može da obrađuje različite tipove vrednosti, ali se u programima najčešće koriste sledeća tri tipa podataka (vrednosti):

o Celi brojevi o Brojevi sa pokretnim zarezom i o Nizovi podataka

Kada se deklariše promenljiva (varijabla), mora se specifikovati tip podataka koji će ta varijabla čuvati.

• Tip i naziv promenljive definišu se u naredbi za deklaraciju.

• C# zahteva eksplicitnu deklaraciju promenljivih i ne dozvoljava implicitno deklarisanje varijabli.

• Varijable se pri deklarisanju mogu i inicijalizovati:

int m=10;

double x=z*99.4; // pretpostavka je da je z već deklarisana i inicirana kao double

• Vrednost koja se dodeljuje varijabli mora biti istog tipa kao varijabla.

C# kompajler obrađuje tip iskaza koji je korišćen pri inicijalizaciji varijable i obaveštava korisnika ukoliko se iskaz po tipu ne poklapa sa tipom varijable.

• Kada se deklariše promenljiva ona sadrži slučajnu vrednost sve dok joj se ne dodeli vrednost!

• Promenljivoj (varijabli) se mora dodeliti vrednost pre nego što se ona upotrebi. U protivnom compiler će javiti grešku.

Deklarisanje lokalnih varijabli implicitno klasifikovanog tipa

Ukoliko korisnik nije siguran u tip varijable i podataka može se koristiti sposobnost C# da samostalno zaključuje o tipu promenljive na bazi izraza pomoću ključne reči var:

var niki=99;

var rec=”Olimpija”;

Promenljive niki i rec upućuju na varijable implicitno unetog tipa (implicitly typed variables). Kompajler zaključuje o tipu varijable na bazi iskaza dodele ili inicijalizacije.





o U prethodnom primeru varijabla niki je celobrojna a varijabla rec je string tipa. o Ovo važi samo pri deklarisanju promenljivih. Kada je varijabla deklarisana, na primer

kao int pri inicijalizaciji, ne može joj se kasnije dodeliti string, float, ili double vrednost u programu.

o var se može koristiti samo pri inicijalizaciji pomoću izraza. o var malisa; // Kompajler bi javio grešku jer var ne može da odredi tip varijable ako

nema izraz.

Rad sa promenljivim, operatorima i izrazima

• Znak = je operator dodele koji vrednost sa svoje desne strane dodeljuje varijabli sa leve strane.

Primer:

int zbir;

zbir=42;

value.Text=zbir.ToString();

• Svaki tip podataka u .NET radnom okruženju ima metodu ToString.

• Svrha ove metode je konvertovanje nekog objekta u njegovu reprezentaciju u obliku znakovnog niza.

• .NET Framework omogućava metodu int32.ToParse, koja se može koristiti da bi se konvertovala vrednost tipa string u celobrojnu vrednost, ukoliko se želi izvođenje aritmetičkih operacija nad vrednostima koje se čuvaju kao nizovi znakova (stringovi)

(Parse = raščlaniti)

• Za spajanje stringova može se koristiti operator +.

Primer moguće greške:

float brojA;

brojA=0.42

program se neće kompajlirati, jer je trebalo da stoji brojA=0.42F

C# je veoma strog po ovom pitanju.

Ne može se jedan tip podataka dodeliti promenljivoj drugog tipa a da se ne napiše dodatni kod.





• Operatori dodele mogu se koristiti na različite načine:

mik=5.6;

kao i

int m;

int n;

n=m=10;

Operator dodele je asocijativan zdesna nalevo.

• Voditi računa o operandima pri primeni nekih operacija:

5.00/2.00 daje 2.5 jer se oba operanda tretiraju kao double a ne kao float da bi se očuvala što je moguće veća tačnost.

ali

5/2 daje 2 ... u ovom slučaju je tip operanada integer pa je rezultat takođe integer tipa!!!

Situacija postaje malo komplikovanija za:

5/2.0 jer je jedan operand tipa integer a drugi tipa double.

C# kompajler detektuje loš spoj i generiše kod koji konvertuje tip integer u double, pre izvođenja operacije. Rezultat će biti tačan 2.5. Ipak, iako ovo funkcioniše, smatra se i jeste loša praksa.

Nekoliko napomena za deljenje sa 0.

Primer: 5/0 uvek rezultira greškom!

Međutim tipovi double i float imaju specijalnu vrednost koja može predstaviti beskonačnost. Ovo znači da 5.0/0.0 daje infinity (beskonačno).

Specifično je 0.00/0.00 gde rezultat može biti neodređen i 0 i beskonačno. C# ima specijalnu vrednost za ovaj slučaj i označava ga sa NaN (Not a Number=nije broj). Dakle rezultat 0.00/0.00 je NaN.

(Subtraction=oduzimanje /// Division = deljenje)

• C# kompajler podržava operator moduo ili ostatak i označava ga sa %. / / (modulus = ostatak)

• Tako 9%2 daje 1.... ili 13%5 daje 3. //

• Operator ostatka je validan sa svim numeričkim tipovima, a rezultat nije obavezno celobrojan. Na primer, rezultat izraza 7.0%2.4 daje 2.2





• Prioritet operacija je najbolje definisati zagradama.

Povećanje i umanjenje varijabli

Operacije dodele mogu se pisati skraćeno // (postfiks i prefix notacija):

brojac=brojac+1 .... isto je što i .... brojac++ (postfiks notacija)

brojac=brojac-1 .... isto je što i .... brojac- -

Prefix notacija se ređe koristi (++brojac).

Operatori složene dodele:

mm65=mm65+42;

isto je kao

mm65+=42

...na prethodnu vrednost varijable mm65 dodaje se vrednost jednaka 42.

Za naredbe složene dodele važi i:

klasična notacija... ...novija notacija

promenljiva=promenljiva*broj promenljiva*=broj

promenljiva=promenljiva/broj promenljiva/=broj

promenljiva=promenljiva%broj promenljiva%=broj

promenljiva=promenljiva+broj promenljiva+=broj

promenljiva=promenljiva-broj promenljiva-=broj

U tekstu koji sledi daje se primer programskog koda koji operiše sa tipovima podataka, deklaracijom varijabli i elemetarnim operacijama ...





Primer koda fajla AISP_B3primer1P.cs

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;

namespace AISP_B3primer1P { class Program { static void Main(string[] args) { int a, b, c; // deklarisanje celobrojnih varijabli string ime; // deklarisanje alfanumerickih varijabli tipa string Console.WriteLine("Akademija Zapadna Srbija"); //System.Console.WriteLine("Akademija Zapadna Srbija"); /*Komanda IZNAD bi se morala koristiti ako je iskljucen using System sa zato sto klasa Console pripada prostoru imena System odnosno njeno puno ime je System.Console*/ Console.WriteLine("Zdravo svima na Severnoj polulopti"); // WriteLine preopterecena metoda (19)

Console.WriteLine("Unesite Vase ime: "); ime = Console.ReadLine(); // Unos sa tastature smesta se u promenljivu ime Console.WriteLine("Zdravo " + ime); // ovde je + nadovezivanje

/*a = Console.ReadLine(); iskaz iznad ne bi radio jer ReadLine()= cita String a ocekuje se broj zbog deklarisanja. U takvim slucajevima je potrebno konvertovanje*/ Console.WriteLine("Unesite a: "); a = int.Parse(Console.ReadLine()); /* Parsiranje slicno konvertovanju Parse = rasclaniti rec, razdvojiti ... void = prazan*/ Console.WriteLine("Vrednost a je: " + a); Console.WriteLine("Unesite b: "); b = Convert.ToInt32(Console.ReadLine()); /* ToInt32 znaci da se pretvara u broj za koga je definisano 32 bita, mi sami biramo u koji tip varijable da se konvertuje*/

Console.WriteLine("Vrednost za b je: " + b);

c = a + b; Console.WriteLine("Zbir je c= " + c);

//drugi nacin ispisa Console.WriteLine("a je: {0}, b je: {1}. c={0}+{1}={2}", a, b, c); /* Dodatno operacija % oznacava ostatak pri deljenju npr. a%2 vraca ostatak deljenja a sa 2, primer: 4%2 je 0, 11%2 je 1*/

} } }






using System;

using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;

namespace AISP_B3primer2P { class Program { static void Main(string[] args) { double prvi, drugi, zbir; string ime; // varijabla ime je deklarisana ali nije upotrebljenau Console.WriteLine("Unesite prvi broj:"); prvi = Convert.ToDouble(Console.ReadLine());//Koverzija iz string Double tip Console.WriteLine("Unesite drugi broj:"); drugi = Convert.ToDouble(Console.ReadLine()); zbir = prvi + drugi; Console.WriteLine("Zbir brojeva je: {0} + {1} = {2}", prvi, drugi, zbir); int broj, i ; // \n za prelamanje reda broj = 6; broj++; // postfix notacija //float a55 = 5.6F; --- 4 bytes //double a34 = 6.345343333e-3; ---- 8 bytes double a = 5.44; // deklarisanje sa inicijalizacijom i = 1; // operator dodele = ... razlukuje se od operatora poredjenja ==

//a=broj; broj = (int)a; // ovo je KASTOVANJE!!!... mora se prebaciti u int

Console.WriteLine("Ovo je kastovani ceo broj: {0}, dok je a= {1}", broj, a); Console.WriteLine("Ovo je broj " + a); //efekat kao kod komande iznad Console.WriteLine("Ovo je broj " + a.ToString); //Pretvarnaje stepeni Farenhajta u Celzijusove stepene double tF, tC; Console.WriteLine("Unesi temperaturu u Farenhajtima:"); tF = Convert.ToDouble(Console.ReadLine()); tC = ((double)5 / 9) * (tF - 32); Console.WriteLine("Temperatura u Farenhajtima je {0}:", tF); Console.WriteLine("Temperatura u Celzijusima je {0}:", tC); Console.ReadKey();

} } }

Prema definiciji, nula na Cezijusovoj skali (0° C) jednaka je 273,15 K (Kelvinova temperaturna skala). 1 0 C = 1 K, što znači da su veličine jedinica na obe skale iste. To dalje znači da je temperatura od 100° C, koja je prethodno bila definisana kao tačka ključanja vode, sada definisana kao jednaka sa 373,15 K. Celzijusova skala predstavlja sistem intervala, što znači da prati relativnu skalu, a ne apsolutnu skalu. To postaje očigledno kada vidimo da je temperaturni interval između 0 °C- 40 °C duplo veći u odnosu na interval 0 °C-20 °C, ali da 40 °C nema dvostruko veću toplotnu energiju vazduha od 20° C.

Farenhajt je termodinamična temperaturna skala, prema kojoj tačka na kojoj se voda ledi iznosi 32 stepena Farenhajta (°F), a tačka ključanja vode iznosi 212° F (pri standardnom atmosferskom pritisku). Tako su tačke na kojima se voda ledi odnosno ključa udaljene tačno 180 stepeni. S toga, stepen na Farenhajtovoj skali iznosi 1/180 intervala između tačke zamrzavanja i tačke ključanja vode. Apsolutna nula iznosi -459,67° F.

0C=(0F-32)/1.800





• Potrebno je za prethodni primer analizirati kod sa aspekta: o Postavljanja komentara na ekranu o Učitavanja sa tastature - preopterećene metode o Deklarisanje primitivnih tipova podataka i varijabli. o Parsiranja, kastovanja i konvertovanja o Iskaza dodele

a potom ... Testirati program.

Elementi na koje treba obratiti pažnju:

• Kastovanje (Casting)

• Naučni način notacije (1.23E07; 1.23E-05)

• Da li koristiti float ili double tip podataka (brojevi sa pokretnim zarezom)?

• Formatiranje vrednosti u procesu štampanja

Casting / ... promena tipa podatka

Casting (kastovanje) je kada se podaci jednog tipa pridružuju (dodeljuju) drugom tipu.

Razlikuje se sledeće dve vrste Casting-a (Type Casting):

• Implicit Casting (automatski) – konvertuje podatke iz manjeg tipa u veći tip

char -> int -> long -> float -> double

• Explicit Casting (manuelno) - konvertuje podatke iz većeg tipa u manji tip

double -> float -> long -> int -> char

Primeri:

A) Implicit Casting

int myInt = 19;

double myDouble = myInt; // Automatski casting : int to double

Console.WriteLine(myInt);

Console.WriteLine(myDouble);





B) Explicit method

Explicitno kastovanje mora biti realizovano manuelno postavljanjem tipa u malim zagradama ispred same vrednosti (varijable) koja se kastuje:

double myDouble = 9.78;

int myInt = (int) myDouble; // Manuelni casting: double to int

Console.WriteLine(myDouble); // Izlaz 9.78

Console.WriteLine(myInt); // Izlaz 9

C) Type conversion methods // Primena metode Convert za promenu tipa podatka

int myIntMM = 15; double myDoubleMM = 5.25; bool myBoolMM = true; Console.WriteLine(Convert.ToString(myIntMM)); // Convert int to string // 15 Console.WriteLine(Convert.ToDouble(myIntMM)); // Convert int to double // 15 Console.WriteLine(Convert.ToInt32(myDoubleMM)); // Convert double to int // 5 Console.WriteLine(Convert.ToString(myBoolMM)); // Convert bool to string // True

Naučni način prikaza podataka / ... Scientific Numbers

• Brojevi sa pokretnim zarezom (floating point number) mogu biti prikazani u naučnoj notaciji pomoću "e", koje je indikator za stepenovanje sa brojem 10:

Primer:

float f1 = 35e3F;

double d1 = 12e4D; //D se može izostaviti

Console.WriteLine(f1);

Console.WriteLine(d1);





Kod u nastavku je vezan za Casting, prikaz podataka u naučnoj notaciji ...


using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AISP_B3primer3P { class Program { static void Main(string[] args) { //Implicit Casting int myInt2020 = 95; double myDouble2020 = myInt2020; // Automatsko kastovanje: int to double Console.WriteLine("Originalni podatak: int " + myInt2020); Console.WriteLine("Implicit Casting: int to double> " + myDouble2020); //Explicit casting double myDouble20 = 9.78; int myInt20 = (int)myDouble20; // Manuelni casting: double to int Console.WriteLine("Originalni podatak: double " + myDouble20);// bice prikazano 9.78 Console.WriteLine("Explicit Casting: double to int " + myInt20); // bice prikazano 9 //Type convertion methods ... primena metoda za konvertovanje int myIntmm = 7; double myDoublemm = 5.25; bool myBoolmm = true; Console.WriteLine("Primena Convert. metoda "); Console.WriteLine(Convert.ToString(myIntmm)); // Convert int to string..(7->7) Console.WriteLine(Convert.ToDouble(myIntmm)); // Convert int to double..(7->) Console.WriteLine(Convert.ToInt32(myDoublemm));// Convert double to int.. (5.25->5) Console.WriteLine(Convert.ToString(myBoolmm)); // Convert bool to string..(true->True) //------------------------------------------------------------------------ Console.WriteLine("Prikaz podatak u naucnoj notaciji"); Console.WriteLine("---------------------------------"); //Prikaz podataka u "naucnoj notaciji" float f1 = 35e3F; double d1 = 12E4D;// oznaka D za dvostruku prciznost nije neophodna Console.WriteLine("f1 = 35e3F " + f1); Console.WriteLine("d1 = 12E4D " + d1); //------------------------------------------------------------------------





//Nekoliko primera int myNumUE = 5; //integer (whole number) float myNumF = 5.75F; //floating point number... 4 bytes double myDoubleNum = 5.99D; // floating point number ... 8 bytes //"D"(nije neophodno navoditi) //broj sa pokretnim zarezom od 1.7e−308 do 1.7e+308 char myLetter = 'M'; //character string myText = "Akademija"; //string bool myBool = true; //boolean Console.WriteLine("Ceo broj> " + myNumUE); Console.WriteLine("Broj sa pokretnim zarezom F > " + myNumF); Console.WriteLine("Broj sa pokretnim zarezom D> " + myDoubleNum); Console.WriteLine("Character> " + myLetter); Console.WriteLine("Logicki podatak> " + myBool); Console.WriteLine("Tekstualni podatak> " + myText); } } }

double ili float? / ...

Da li koristiti float ili double tip podataka za brojeve sa pokretnim zarezom?

• Preciznost podataka koji su memorisani u obliku pokretnog zareza, govori o tome koliko cifara posle decimalne tačke, podatak može imati.

• Preciznost podataka zapisaih u float formatu je samo 6 ili 7 cifara posle decimalnog zapisa, dok double varijable imaju preciznost oko 15 cifara.

• Tako da je sigurnije koristiti double format (tip zapisa) za najveći broj kalkulacija.

Formatiranje podataka u procesu štampanja/prikaza

U C# projektu Primer koda fajla AISP_B3primer2P.cs, implementiran je, pored ostalog, i jednostavan algoritam pretvaranja stepeni Farenhajta (0F) u Celzijusove stepene (0C).

• Može se videti da je način ispisa vrednosti temperature u 0C, neodgovarajući:

109 0F=42.7777777777778 0C • Programsko okruženje C#, raspolaže brojnim opcijama za oblikovanje i prikazivanje

podataka svih tipova.

U tekstu koji sledi daje se prikaz dela mogućnosti.

Odabrani elementi su preuzeti sa linka:

https://www.csharp-examples.net/string-format-double/

http://www.vpts.edu.rs/https://www.csharp-examples.net/string-format-double/




Autori primera

formatiranja podataka

u C#

Jan Slama, Czech Republic,

email: info[at]csharp-examples.net

Authors:

Jan Slama, Oto Skrkal, Franta Zahora,

Martin Konicek, Michal Kogut

String Format for Double [C#]

The following examples show how to format float numbers to string in C#. You can use static method String.Format or instance methods double.ToString and float.ToString.

Digits after decimal point

This example formats double to string with fixed number of decimal places. For two decimal places use pattern „0.00“. If a float number has less decimal places, the rest digits on the right will be zeroes. If it has more decimal places, the number will be rounded.

// just two decimal places

String.Format("{0:0.00}", 123.4567); // "123.46"

String.Format("{0:0.00}", 123.4); // "123.40"

String.Format("{0:0.00}", 123.0); // "123.00"

Next example formats double to string with floating number of decimal places. E.g. for maximal two decimal places use pattern „0.##“.

// max. two decimal places

String.Format("{0:0.##}", 123.4567); // "123.46"

String.Format("{0:0.##}", 123.4); // "123.4"

String.Format("{0:0.##}", 123.0); // "123"

Digits before decimal point

If you want a float number to have any minimal number of digits before decimal point use N-times zero before decimal point. E.g. pattern „00.0“ formats a float number to string with at least two digits before decimal point and one digit after that.

// at least two digits before decimal point

String.Format("{0:00.0}", 123.4567); // "123.5"

String.Format("{0:00.0}", 23.4567); // "23.5"

String.Format("{0:00.0}", 3.4567); // "03.5"

String.Format("{0:00.0}", -3.4567); // "-03.5"

http://www.vpts.edu.rs/http://msdn2.microsoft.com/en-us/library/system.string.format.aspxhttp://msdn2.microsoft.com/en-us/library/kfsatb94.aspxhttp://msdn2.microsoft.com/en-us/library/f71z6k0c.aspx




Align numbers with spaces

To align float number to the right use comma „,“ option before the colon. Type comma followed by a number of spaces, e.g. „0,10:0.0“ (this can be used only in String.Format method, not in double.ToString method). To align numbers to the left use negative number of spaces.

String.Format("{0,10:0.0}", 123.4567); // " 123.5"

String.Format("{0,-10:0.0}", 123.4567); // "123.5 "

String.Format("{0,10:0.0}", -123.4567); // " -123.5"

String.Format("{0,-10:0.0}", -123.4567); // "-123.5 "

String Format for Int [C#]

Integer numbers can be formatted in .NET in many ways. You can use static method String.Format or instance method int.ToString. Following examples show how to align numbers (with spaces or zeroes), how to format negative numbers or how to do custom formatting like phone numbers.

Add zeroes before number

To add zeroes before a number, use colon separator „:“ and write as many zeroes as you want.

String.Format("{0:00000}", 15); // "00015"

String.Format("{0:00000}", -15); // "-00015"

Align number to the right or left

To align number to the right, use comma „,“ followed by a number of characters. This alignment option must be before the colon separator.

String.Format("{0,5}", 15); // " 15"

String.Format("{0,-5}", 15); // "15 "

String.Format("{0,5:000}", 15); // " 015"

String.Format("{0,-5:000}", 15); // "015 "

http://www.vpts.edu.rs/http://msdn2.microsoft.com/en-us/library/system.string.format.aspxhttp://msdn2.microsoft.com/en-us/library/kfsatb94.aspxhttp://msdn2.microsoft.com/en-us/library/system.string.format.aspxhttp://msdn2.microsoft.com/en-us/library/system.int32.tostring.aspx




Align String with Spaces [C#]

This example shows how to align strings with spaces. The example formats text to table and writes it to console output.

To align string to the right or to the left use static method String.Format. To align string to the left (spaces on the right) use formatting patern with comma (,) followed by a negative number of characters: String.Format(„{0,–10}“, text). To right alignment use a positive number: {0,10}.

Following example shows how to format text to the table. Values in the first and second column are aligned to the left and the third column is aligned to the right.

Console.WriteLine("-------------------------------");

Console.WriteLine("First Name | Last Name | Age");


Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Bill", "Gates", 51));

Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Edna", "Parker", 114));

Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Johnny", "Depp", 44));


Output string: -------------------------------

First Name | Last Name | Age

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

Bill | Gates | 51

Edna | Parker | 114

Johnny | Depp | 44

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

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

http://www.vpts.edu.rs/http://msdn2.microsoft.com/en-us/library/system.string.format.aspx





using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AISP_B3primer4P { class Program { static void Main(string[] args) { //"{0:F2}", //Podesavanje ispisa podataka tipa double //Primer double fractNum = -1.856; //Console.WriteLine(string.Format({10:f2}),fractNum); Console.WriteLine("{0:F2}", fractNum);//prikazuje -1.86 Console.WriteLine("{0:F4}", fractNum);//prikazuje -1.8560 Console.WriteLine("{0:F1}", fractNum);//prikazuje -1.9 //----------------------------------------------------- //https://www.csharp-examples.net/string-format-double/ //double vrednost promenljive u string ..... PRIMERI // just two decimal places Console.WriteLine(String.Format("{0:0.00}", 123.4567)); // "123.46" Console.WriteLine(String.Format("{0:0.00}", 123.4)); // "123.40" Console.WriteLine(String.Format("{0:0.00}", 123.0)); // "123.00" // max. two decimal places Console.WriteLine(String.Format("{0:0.##}", 123.4567)); // "123.46" Console.WriteLine(String.Format("{0:0.##}", 123.4)); // "123.4" Console.WriteLine(String.Format("{0:0.##}", 123.0)); // "123" // at least two digits before decimal point Console.WriteLine(String.Format("{0:00.0}", 123.4567)); // "123.5" Console.WriteLine(String.Format("{0:00.0}", 23.4567)); // "23.5" Console.WriteLine(String.Format("{0:00.0}", 3.4567)); // "03.5" Console.WriteLine(String.Format("{0:00.0}", -3.4567)); // "-03.5" Console.WriteLine("-------------------------------"); Console.WriteLine("First Name | Last Name | Age"); Console.WriteLine("-------------------------------"); Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Bill", "Gates", 51)); Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Edna", "Parker", 114)); Console.WriteLine(String.Format("{0,-10} | {1,-10} | {2,5}", "Johnny", "Depp", 44)); Console.WriteLine("-------------------------------");





//Pretvarnaje stepeni Farenhajta u Celzijusove stepene ... broj decimala double tF, tC; Console.WriteLine("Unesi temperaturu u Farenhajtima:"); tF = Convert.ToDouble(Console.ReadLine()); tC = ((double)5 / 9) * (tF - 32); Console.WriteLine("Temperatura u Farenhajtima je {0}:", tF); //Console.WriteLine("Temperatura u Celzijusima je:" + String.Format("{0:F2}",tC)); Console.WriteLine("{0:F2}",tC); Console.WriteLine("Temperatura u Celzijusima je:" + String.Format("{0:0.00}", tC)); } } }

Bulovi operatori i Bulove promenljive.

• Deklarisanje Bulovih promenljivih

• Bulov izraz se uvek ocenjuje kao tačan ili netačan.

Primer:

bool status;

status=true;

Console.WriteLine(status);

Primeri relacionih i logičkih operatora dati su u tabeli 3.1.

Tabela 3.2. Operatori ●

Kategorija Operator Značenje Primer Rezultat ako je godine=42

Jednakost == Jednako godine==42 False

!= Nejednako age!= True

Relacioni < Manje od age= Veće od age>=30 True

Unarni ! Logički NE !(True) False

Logički I && Uslovno AND (age




Upotreba iskaza if u odlučivanju

• Uslovni iskaz if obezbedjuje da se izvrši jedan od dva bloka komandi u zavisnosti od retultata Bulovog iskaza.

• Sintaksa iskaza if:

If(Bulov iskaz)

{

... blok komandi (ili jedna komanda/iskaz)

.... koje se isvršavaju, ako je Bulov iskaz tačan

}

else

{

.. blok komandi (ili jedna komanda/iskaz)

.... koje se isvršavaju, ako Bulov iskaz NIJE tačan

}

• Blok je niz iskaza grupisaih između leve i desne vitičaste zagrade.

• Blok pokreće novo područje važenja (područje važenja promenljivih će biti objašnjeno kasnije)

• Promenljive se mogu definisati lokalno unutar bloka, ali na kraju bloka one će nestati ...





Kaskadni iskazi if

• Iskaz if se može ugnezditi unutar drugih if iskaza.

• Na ovaj način može se ulančati niz Bulovih iskaza, koji se ispituju jedna za drugim, sve dok jedan od njih ne bude procenjen kao true.

If(Bulov iskaz 1)

{

... blok komandi (ili jedna komanda/iskaz) koje

.... koje se isvršavaju,

ako je Bulov iskaz 1 tačan

}

else if (Bulov iskaz 2)

{

... blok komandi (ili jedna komanda/iskaz) koje

.... koje se isvršavaju

ako je Bulov iskaz 2 tačan

}

...

else

{

.. blok komandi koje (ili jedna komanda/iskaz)

.... koje se isvršavaju

ako je ijedan od Bulov iskaza NIJE tačan

}

If(dan==1)

{

nazivDana=“Ponedeljak“;

}

else if (dan==2)

{

nazivDana=“Utorak“;

}

else if (dan==3)

{

nazivDana=“Sreda“;

}

else if (dan==4)

nazivDana=“Cetvrtak“;

else if (dan==5)

nazivDana=“Petak“;

else if (dan==6)

nazivDana=“Subota“;

else

{

nazivDana=“Nedelja“;

}

U tekstu koji sledi navode se elementarni primeri upotrebe relacionih operatora i naredbi grananja.

{ deklarisanje varijabli, if ... else if ... , logički operatori OR i AND... parsiranje... Console.WriteLine,

Upotreba klase Math } ● provera jednakosti ==; provera da li je različito !=; >; =;




Primeri: deklarisanje varijabli, if ... else if ... , logički operatori OR i AND... parsiranje... Console,WriteLine. Upotreba klase Math



namespace AISP_B3primer5P { class Program { static void Main(string[] args) { int n; double y; Console.WriteLine("Uneti x:"); n = int.Parse(Console.ReadLine()); if (n < 5 || n > 25) // ... || ... OR { y = Math.Pow(n, 2);// n na 2 } else if (n < 15 && n % 2 != 0) //&&... AND { y = n / 3.0; // y je double } else if (n < 15 && n % 2 == 0) //ostatak pri deljenju sa 2 { y = Math.Log(n); // math je staticka klasa } else { y = Math.Cos(n); } Console.WriteLine("Resenje je {0} za zadato {1}.", y, n); Console.WriteLine("Resenje je: y="+"{0:F4}", y ); string sentence = string.Format("Za {0} resenje je {1:F4}", n, y); Console.WriteLine(sentence); //Jos nekoliko primera formatiranja string student = "Ivo Rajic, IN 24/19"; int uzrast = 20; DateTime god = new DateTime(2020, 4, 4); string opis = string.Format("{0} ima {1} godina ove {2:yyyy}-te.", student, uzrast, god); Console.WriteLine(opis);

Slika 3.1.1. Algoritam

● Primer AISP_B3primer5P●





double bod = 0.889; string predmet = "Algoritmi"; string ocena = string.Format("{0} je osvojio {1:0.00%} bodova na predmetu: {2}", student, bod, predmet); Console.WriteLine(ocena); } } }



namespace AISP_B3primer6P { class Program { static void Main(string[] args) { double a, b, c, max;

Console.WriteLine("Unesite Prvi broj:"); a = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Unesite Drugi broj:"); b = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Unesite Treci broj:"); c = Convert.ToDouble(Console.ReadLine());

if (a > b && a > c) max = a; else if (b > c) max = b; else max = c;

Console.WriteLine("Maksimum je {0}.", max);

// druga varijanta max = a; if (b > max) max = b; if (c > max) max = c; Console.WriteLine("Maksimum je {0}.", max); } } }








REŠAVANJE KVADRATNE JEDNAČINE

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AISP_B3primer7P { class Program { static void Main(string[] args) { double a, b, c, diskriminanta = 0, x1, x2; string jednacina;







Console.WriteLine("Kvadratna jednacina. RESENJA" + '\n' + "M. Milivojevic"); //ucitavanje koeficijenata kvadratne jednacine Console.Write("Uneti koeficijent a: "); a = double.Parse(Console.ReadLine()); Console.Write("Uneti koeficijent b: "); b = double.Parse(Console.ReadLine()); Console.Write("Uneti koeficijent c: "); c = double.Parse(Console.ReadLine()); jednacina = "y=a*x^2+b*x+c"; Console.WriteLine(jednacina); Console.WriteLine("Resenja jednacine: {0}*x^2+{1}*x+{2} su:", a, b, c); // dato da bi se uvidela razlika u ispisu jednacine //Resenje if (a == 0 && b == 0) { Console.WriteLine("Prava je paralelna x osi ... y=c !!!"); } else if (a == 0 && b != 0) { Console.WriteLine('\n' + "U pitanju nije parabola vec linearna jednacina!!!"); x1 = -c / b; Console.WriteLine("Resenje linearne jednacine je x=" + Convert.ToString(x1)); } else if (a != 0 && b != 0) { diskriminanta = Math.Pow(b, 2) - 4 * a * c; Console.WriteLine("Diskiminanta je D=" + diskriminanta); if (diskriminanta > 0) { x1 = (-b + Math.Sqrt(diskriminanta)) / (2 * a); x2 = (-b - Math.Sqrt(diskriminanta)) / (2 * a); Console.WriteLine('\n' + "Resenja KVADRATNE JEDNACINE su REALNA:" + '\n' + "x1=" + x1 + '\n' + "x2="+ x2); // drugi nacin formatiranja string sentenca = String.Format("Resenja REALNA i RAZLICITA: " + '\n' + "x1={0:F4} x2={1:F4}", x1,x2); Console.WriteLine(sentenca); }





else if (diskriminanta < 0) { diskriminanta = -diskriminanta; Console.WriteLine('\n' + "Resenja KVADRATNE JEDNACINE su KOMPLEKSNA"); double Re = -b / (2 * a); double Im = (Math.Sqrt(diskriminanta)/ (2 * a)); string ispis1 = String.Format("x1={0:F4} + {1:F4}*i",Re, Im); string ispis2 = String.Format("x2={0:F4} - {1:F4}*i",Re, Im); Console.WriteLine(ispis1 + '\n' +ispis2); } else { Console.WriteLine('\n' + "Resenja KVADRATNE JEDNACINE su REALNA I JEDNAKA:"); Console.WriteLine("x1=x2=" + "{0:F4}",(-b / (2 * a))); } } } } }

Slika 3.1.4. Rešenje kvadratne jednačine

● Primer D





● Primer D=0;

AISP_B3primer8P●





Važno: Ukoliko izostavite vitičaste zagrade, C# kompajler pridružuje if iskazu samo prvi iskaz. Sledeći iskaz u bloku ne bi bio prepoznat od strane kompajlera kao deo if bloka. Osim toga, kada bi kompajler došao do ključne reči else, ne bi je povezao sa prethodnim izrazom if. Umesto toga bila bi prijavljena sintaksna greška. Iz tog razloga, uvek je dobro definisati iskaze za svaki deo if bloka unutar vitičastih zagrada, čak iako se blok sastoji iz jednog iskaza. To će biti važno kasnije ako programer želi da doda neki iskaz if bloku.

Blok takođe pokreće novo područje važenja. Mogu se definisati varijable u bloku, ali će na kraju bloka one nestati.


● Primer D>0;

AISP_B3primer8P●





VIŠESTRUKO GRANANJE - switch

Ponekad, kada se pišu kaskadni if iskazi, svi if podsegmenti izgledjau slično, zato što svi ispituju identični iskaz.

Reč je o višestrukom uslovnom grananju: Ovo se realizuje switch strukturom.

Pravila strukture switch:

• može se koristiti samo za tipove podataka: int, char i string. Za druge vrste podataka mora se korisiti if.

• labele case blokova moraju biti konstantni iskazi (primeri: 23 za int, ‘r’ za char,”Beograd” za string tip podataka)

• dve labele case ne mogu imati istu vrednost

• može se naznačiti da se pokreće isti blok iskaza za više case vrednosti

• ne može se propasti iz jedne u drugu case labelu. Iskay break je uobičajeni način da se zaustavi propadanje, ali može se koristiti i return i throw.

Napomena: Znakovi ‘ kao i “ se koriste da označe character i string konstante.

switch(kontrolniIzraz) { case konstantniIzraz1: iskaz; ... break;

case konstantniIzraz2: iskaz; ... break;

case konstantniIzrazX: iskaz; ... break; ... default: iskaz; ... break; }

Kontrolni iskaz mora biti u zagradi. Izračunava se samo jednom. Koristi se onaj case blok čija je vrednost jednaka vrednosti kontrolnog iskaza. U case bloku (case labeli) izvršavaju se komande (iskazi) sve do iskaza break koji obezbeđuje izlazak iz case strukture. Nakon izlazka programsko upravljanje se prenosi na prvu komandu nakon zatvorene vitičaste zagrade switch strukture.

Ukoliko nijedna od vrednosti konstantniIzrazX nije jednaka vrednosti kontrolnogIskaza upravljanje se predaje default bloku.

Svaki konstantniIzrazX mora biti jedinstven.

Ukoliko se vrednost kontrolnogIskaza ne podudari ni sa jednom vrednošću konstantniIzrazX a nema default bloka, upravljanje se predaje prvoj komandi nakon zatvorene vitičaste zagrade switch strukture.






Primer: switch struktura

●●●

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AISP_B3primer9P { class Program { static void Main(string[] args) { char ch; Console.WriteLine("Uneti slovo alfabeta:"); ch = Convert.ToChar(Console.ReadLine()); switch (Char.ToLower(ch)) { case 'a': case 'e': case 'i': case 'o': case 'u': Console.WriteLine("Samoglasnik"); break; default: Console.WriteLine("Nije samoglasnik"); break; } } } }

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AISP_B3primer8P { class Program { static void Main(string[] args) { int broj; Console.WriteLine("Unesite postanski broj:"); broj = Convert.ToInt32(Console.ReadLine()); switch (broj) { case 34000: Console.WriteLine("Kragujevac"); break; case 31000: Console.WriteLine("Uzice"); break; case 32000: Console.WriteLine("Cacak"); break; default: Console.WriteLine("Nepoznat postanski broj"); break; } } } }

algoritmi strukture podataka uvod u oop · 2020. 4. 3. · programa informacione tehnologije,...

Documents