Predavanje 11: Glava 30,31

FlipView[{Text[Style[" Branko Urošević, imqfbrankourosevic@gmail.com ",20,"Text",Italic]],Text[Style[" Faculty of Economics, University of Belgrade, NBS and CESIfo Munich",20,"Text", Italic]]}]

30. Preuređenje lista

Uvod u preuređenje lista

{{1,2,3},{2,5}}\[Transpose]

Preuređenje lista je ključno u radu sa podacima o od njega veoma zavisi šta se od njih dobije. Možemo da je predstavimo grafički na primer ovako:

{{1,2},{3,4},{5,6},{7,8},{9,10}}//ListLinePlot

Imali bismo jedan grafik koji spaja pomoću linije te tačke. A šta bi se desilo ako bismo listu transponovali? Onda bismo imali dva grafika:

%//ListLinePlot

Transpose[{{1,2},{3,4},{5,6},{7,8},{9,10}}]

\[Transpose]

U 2d, transponovanje se može napisati pomoću EsctrEsc. Vidimo da isti podaci, kada se transponuju, dobijaju sasvim novi smisao.

{{1,2},{3,4},{5,6},{7,8},{9,10}}\[Transpose]

Transponovanje

Primetimo da sada imamo dve liste brojeva, a ne jednu (svaka od lista ima x koordinate sada implicitno 1,2,3,4...)

{{1,2},{3,4},{5,6},{7,8},{9,10}}\[Transpose]//ListLinePlot

{{1,2,3},{3,4}}//Grid

{{1,2},{3,4},{5,6},{7,8},{9,10}}//MatrixForm

Transpose[{{1,2},{3,4},{5,6},{7,8},{9,10}}]//MatrixForm

Transpose pretvara ove dve podliste u uredjene parove:

Transpose[{{1,3,5,7,9},{2,4,6,8,10}}]//MatrixForm

Thread spaja elemente dve liste istih dimenzija pomoću neke operacije

Thread je bliska operacija koja je veoma korisna recimo kada hoćemo da, recimo, napravimo pravimo listu jednakosti ili nejednakosti i slično. Naime, ukoliko imamo dve proste liste iste dužine i neki izraz koji želimo da provučemo kroz te liste, Thread to omogućava. Najbolje je da se to vidi na primeru. Evo kako radi  Thread -> kroz elemente dve liste:

Thread[{a,b,c,d,f}->{2,4,6,8,10}]

Umesto strelice možemo imati bilo koju operaciju. Na taj način dobijamo od dve liste zapravo jednu listu u kojoj je prvi element prve liste povezan sa prvim elementom druge liste, itd. Evo kako možemo da za svaku od promenljivih uvedemo neke dodatne uslove (ključno prilikom optimizacije):

Thread[{x1,x2,x3}≥ {0,1,3}]

Thread[1≥ {x1,x2,x3}≥ 0]

Particija (Partition) od početne liste pravi liste složenije strukture

Partition menja strukturu liste i razbija je na blokove određene veličine. Razbijste listu od 12 elementata u podliste veličine 3:

Partition[Range[11],3,2]

Partition[Range[11],3,1]

Partition[Range[11],3]

Partition[Range[12],2]

Partition[Range[12],6]

Range[12]

Partition[Range[12],3]

Razbijte listu karaktera pomoću Partition kako biste ih prikazali u gridu:

Grid[Partition[Characters["An array of text made in the Wolfram Language"],7],Frame->All]

Characters["An array of text made in the Wolfram Language"]

Grid[Partition[Characters["An array of text made in the Wolfram Language"],7,1],Frame->All]

Grid[Partition[Characters["An array of text made in the Wolfram Language"],7],Frame->All]

Još o Partition

Ako mu se drugačije ne naredi, Partition pravi blokove koji se ne preklapaju. Ali, nekad je korisno dozvoliti delimično preklapanje ili offset. Partition listu u blokove veličine 3 sa offsetom 1:

Partition[Range[10],3,1]

Uporedimo to sa

Partition[Range[10],3]

Evo još primera:

Grid[Partition[Characters["Wolfram Language"],12,1],Frame->All]

Grid[Partition[Characters["Wolfram Language"],12,2],Frame->All]

Flatten: uprošćavanje složene liste

Flatten[{{{2,a,b},{3,1}},{1}}]

Flatten[{{{2,a,b},{3,1}},{1}},2]

Flatten[{{{2,a,b},{3,1}},{1}},1]

Partition[Flatten[{{{2,a,b},{3,1}},{1}}],3]

Partition uzima prostije liste i razbija ih na podliste. Flatten “poravnjava” podliste, u potpunosti ili delimično, odnosno od složenijih lista pravi prostije. Napravite listu cifara sukcesivnih celih brojeva:

ListLinePlot[Flatten[IntegerDigits/@Range[200]]]

Ukoliko koristimo Flatten bez dodatnih opcija, dobićemo uvek prostu listu koja sadrži sve elemente onim redom kojim se pojavljuju u složenoj listi:

Flatten[IntegerDigits/@Range[20]]

ListLinePlot[Flatten[IntegerDigits/@Range[100]],PlotTheme->"Detailed"]

Još o Flatten

Flatten normalno poravnjava do kraja, do potpuno proste liste, bez podlista. Ali često to ne želimo nego hoćemo da se poravnja samo do određenog nivoa (nivo je Level). Ovako pravimo tabelu 4×4 table u kojoj je svaki element takođe lista:

Flatten[Table[IntegerDigits[i^j],{i,4},{j,4}],1]

Sada poravnjajmo samo jedan nivo ove liste:

Flatten[Table[IntegerDigits[i^j],{i,4},{j,4}],1]

Flatten[Table[IntegerDigits[i^j],{i,4},{j,4}],2]

Pretpostavimo da želimo da napravimo uređene trojke koje se sastoje od celih brojeva od 1 do 10 kao i kvadratnog korena od sume njihovih kvadrata. Kako to možemo da uradimo? Koristeći Table dobijamo

Flatten[Table[{i,j,(Sqrt[(i^2)+(j^2)])},{i,10},{j,10}],1]

Da bismo dobili od te složene liste uređene trojke, treba da Flatten za jedan nivo

Flatten[Table[{i,j,(Sqrt[(i^2)+(j^2)])},{i,10},{j,10}],1]

Vidimo da je poslednji broj nekada ceo broj. To su takozvane Pitagorine trojke.

Flatten[Table[IntegerDigits[i^j],{i,4},{j,4}],1]

FromDigits/@%

FromDigits/@Table[IntegerDigits[i^j],{i,4},{j,4}]

ArrayFlatten uzima matrice od matrica i uprošćava im strukturu

ArrayFlatten je generalizacija Flatten koja uzima arrays od arrays i poravnjava ih u individualne arrays. Ovo generiše veoma duboko nestiranu strukturu koju je teško razumeti:

NestList[{{#,0},{#,#}}&,{{1}},2]

Ako iskoristimo ArrayFlatten dobijamo nešto što je malo jasnije:

NestList[ArrayFlatten[{{#,0},{#,#}}]&,{{1}},2]

Sa ArrayPlot, mnogo se bolje vidi kako to izgleda: i

ArrayPlot/@NestList[ArrayFlatten[{{#,0},{#,#}}]&,{{1}},4]

Generisati fraktal Sierpinskog sa 8 nivoa nestinga:

ArrayPlot[Nest[ArrayFlatten[{{#,0},{#,#}}]&,{{1}},8]]

Split razbija prostu listu po određenom kriterijum

Ukoliko ne zadamo dodatnu funkciju na kraju Split pravi takozvane runs istih elemenata.

Split[{1,1,1,2,1,2,1,1,3,1,1,1,2}]

Split[{1,1,1,2,2,1,1,3,1,1,1,2}]

Vidimo da Split napravi grupu elementa tri puta. Onda dolazi do prekida u tom elementu kad se pojavi u nizu neki drugi element. Split može i da se kontroliše dodatnom čistom funkcijom na kraju. Razmotrimo listu prvih 20 prostih brojeva

Split[Array[Prime,20]]

Array[Prime,20]

Razbijmo u podliste kod kojih se sukcesivna dva člana razlikuju za manje od 4.

Split[Array[Prime,20],#2-#1<6&]

Split[Array[Prime,20],#2-#1<4&]

Gather i GatherBy

Gather, sa druge strane, skuplja iste elemente gde god da su bili u listi:

Gather[{1,1,1,2,2,1,1,3,1,1,1,2}]

Ovako možemo da skupimo na jedno mesto uređene parove koji imaju isti prvi element (recimo a, ili b)

Gather[{{a,1},{b,1},{a,2},{d,1},{b,3}},Last[#1]==Last[#2]&]

Gather[{{a,1},{b,1},{a,2},{d,1},{b,3}},First[#1]==First[#2]&]

GatherBy skuplja elemente na osnovu rezultata aplikacije neke čiste funkcije. Ovde skupljamo elementa na osnovu LetterQ, tako da razbijamo skup karaktera na one koji su slova i one koji nisu:

Characters["It's true that 2+2 is equal to 4!"]

GatherBy[Characters["It's true that 2+2 is equal to 4!"],LetterQ]

Ovako jednostavnije možemo da uradimo ono od malopre

GatherBy[{{a,1},{b,1},{a,2},{d,1},{b,3}},First[#]&]

SortBy sortira na osnovu rezultata primene neke funkcije

SortBy sortira na osnovu rezultata primene neke funkcije:

Table[IntegerDigits[2^n],{n,10}]

Sort[Table[IntegerDigits[2^n],{n,10}]]

Ovde SortBy sortira na na osnovu prvog elementa u svakoj od podlisti:

SortBy[Table[IntegerDigits[2^n],{n,10}],First]

SortBy[{{a,1},{b,1},{a,2},{d,1},{b,3}},First]

SortBy[{{a,1},{b,1},{a,2},{d,1},{b,3}},Last]

Union (unija skupova) i Join

Union spaja više lista i izbacuje sve ponovljene elemente (to je unija skupova). Takođe, ako primenimo samo na jednu listu, izbaciju sve ponovljene elemente.

Union[{1,2,3},{2,3,4},{5,6}]

Join[{1,2,3},{2,3,4}]

Union[{1,9,5,3,1,4,3,1,3,3,5,3,9}]

Union[{1,2,3},{2,3,5}]

⋃

Union možemo predstaviti u 2d preko  Esc un Esc

{1,2,3}⋃{2,3,5}

U slučaju Join ništa se ne izbacuje:

Join[{1,2,3},{2,3,5}]

Intersection (presek skupova) i Complement (razlika skupova)

Naći elemente koji su zajednički za grupu lista (presek skupova):

Intersection[{2,1,3,7,9},{4,5,1,2,3,3},{3,1,2,8}]

Intersection može da se predstavi preko 2d simbola sa Esc inter Esc

⋂

Dakle, prethodna operacija može ekvivalentno da se napiše i kao:

{2,1,3,7,9}⋂{4,5,1,2,3,3}⋂{3,1,2,8}

Razlika u skupovima (komplement). Naći elemente koji su u prvom skupu ali ne i u drugom:

Complement[{4,5,1,2,3,3},{3,1,2,8}]

Complement[{4,5,1,2,3,3},{3,1,2,8}]

Union[{4,5,1,2,3,3},{3,1,2,8}]

Intersection[{4,5,1,2,3,3},{3,1,2,8}]

Complement[Union[{4,5,1,2,3,3},{3,1,2,8}],Intersection[{4,5,1,2,3,3},{3,1,2,8}]]

Primeri sa azbukama

Naći slova koja se pojavljuju bilo u engleskoj, švedskoj ili turskoj azbuci:

Union[Alphabet["English"],Alphabet["Swedish"],Alphabet["Turkish"]]

ili

⋃

Alphabet["English"]⋃Alphabet["Swedish"]⋃Alphabet["Turkish"]

Nađimo slova koja su zajednička u hrvatskom i švedskom

Complement[Alphabet["Croatian"],Alphabet["Swedish"]]

Intersection[Alphabet["Croatian"],Alphabet["Swedish"]]

ili

Alphabet["Croatian"]⋂Alphabet["Swedish"]

Još primera sa azbukama

A koja slova su zajednička u hrvatskom i engleskom?

Intersection[Alphabet["Croatian"],Alphabet["English"]]

Evo slova koja se pojavljuju u švedskom ali ne i u engleskom i obrnuto:

Complement[Alphabet["Norwegian"],Alphabet["English"]]

Complement[Alphabet["Swedish"],Alphabet["English"]]

Complement[Alphabet["English"],Alphabet["Swedish"]]

Ubacivanje ponovljenog elemenata u listu: Riffle

Flatten[Riffle[{{1,a},{2,b},3,4,5},x]]

Riffle[{{1,a},{2,b},3,4,5},x]

Pretpostavimo da želimo da ubacimo jedan isti element između svaka dva elementa liste. To se dobija pomoću Riffle:

Riffle[{1,2,3,4,5},x]

Riffle “--“ u listu karaktera:

Riffle[Characters["WOLFRAM"],"--"]

StringJoin sve karaktere u jedan string:

StringJoin[Riffle[Characters["WOLFRAM"],"--"]]

Stvaranje lista od neke grupe elemenata: Permutations, Subsets

Pretpostavimo da imate neke elemente i da od njih hoćete da napravite liste na neki način.

Permutations vam daje sve permutacije neke grupe elemenata (u svakoj učestvuju svi elementi). Tu je poredak važan i nema ponavljanja. Generišemo listu od 3!=3×2×1=6 mogućih permutacija 3 elementa:

Permutations[{Red,Green,Blue}]

Umesto toga mogu da nas interesuje skup svih podskupova koje možemo konstruisati od ta tri elementa. Njih će biti (2^3)=8. Dobijamo ih putem Subsets. To je takozvani Power Set skupa {Red,Green,Blue}

Subsets[{Red,Green,Blue}]

Tu nam nije važan poredak u podskupu nego samo koji su elementi u njemu. Šta ako želimo samo podskupove koji imaju 2 člana? U tom slučaju:

Subsets[{Red,Green,Blue},2]

Subsets[{Red,Green,Blue},{2}]

Još o Subsets

Evo zanimljive primene Subsets u finansijama. Pretpostavimo da imamo mandat da od 5 akcija izaberemo samo 3 za našu investiciju. Akcije kojima raspolažemo su

{"Microsoft","IBM","Apple","Google","ATT"}

U koje akcije možemo da investiramo? Subsets daje odgovor na to pitanje:

Subsets[{"Microsoft","IBM","Apple","Google","ATT"},{3}]

Tuples

Tuples generiše sve kombinacije ukazanih dimenzija (uz moguće ponavljanje). Tu je, za razliku od Subsets, poredak važan.

Generisati listu mogućih uređenih trojki sastavljenu od Red i Green:

(2^6)

Tuples[{u,d},8]

Tuples[{Red,Green},3]

Kao primer primene možemo da razmotrimo binomni model za akcije. Naime, neka akcije može ići ili na gore za faktor u, ili na dole za faktor d. Kakve su moguće kombinacije u 4 koraka šta sve može da se desi sa akcijom?

Tuples[{u,d},4]

Slučajni izbor elemenata (RandomChoice)

RandomChoice[{u,d},8]

RandomChoice[{u,d},100]

RandomChoice[{Red,Green,Blue},100]

RandomChoice nam omogućava da napravimo slučajan izbor iz grupe elemenata:

Napravite slučajni izbor iz liste jednom:

RandomChoice[{Red,Green,Blue}]

Napravite 100 slučajnih izbora iz liste:

RandomChoice[{Red,Green,Blue},100]

Još o RandomChoice

Napravimo listu dimenzija 5 x 3 sa slučajnim izborima sa ove liste:

RandomChoice[{u,d},{10,8}]

RandomChoice[{Red,Green,Blue},{5,3}]

Ovde smo do sada implicitno podrazumevali da su sve mogućnosti podjednako verovatne. Pretpostavimo da imamo akciju koja može da nam da prinose od -0.5, 0, ili 0.6 s tim što je prinos 0 dva puta verovatniji nego prinosi -0.5  ili 0.6, koji su podjednako verovatni. Ako imamo 100 dana investiranja, kakvi su mogući ishodi? U tom slučaju moramo da uvedemo težine (weights).

RandomChoice[{1,2,1}->{-0.5,0,0.6},100]

Histogram[RandomChoice[{-0.5,0,0.6},1000]]

Histogram[RandomChoice[{1,2,1}->{-0.5,0,0.6},1000]]

Slučajan uzorak (RandomSample)

Primetimo da kod RandomChoice možemo ponavljanjem dobite više puta jedan isti element. To odgovara izboru kuglica kod verovatnoće sa ponavljanjem. Međutim, nekad želimo da izbor pravimo bez ponavljanja (drugim rečima, ne vraćamo kuglicu nazad u urnu).

RandomSample slučajno bira elemente iz liste, nikada ne birajući dva puta jedan isti element. Izabrati 20 elemenata od 1 do 100:

RandomChoice[Range[100],80]

RandomSample[Range[100],80]

Naravno, bez ponavljanja ne možemo od 100 različitih elemenata izabrati 101. Drugim rečima, ukoliko nema ponavljanja, moramo da biramo manje elemenata u uzorku nego što ih imamo u celini.

RandomSample[Range[100],101]

Append i Prepend

Kada radimo sa podacima, korisno je Prepend zaglavlja:

data={{1.2,0.4},{0.4,1.3},{-2.1,3}};heading={"Column1","Column2"};

Prepend[data,heading]

Prepend[data,heading]//Grid

Pretpostavimo da želimo da dodamo kasnije rezultat još jednog merenja na kraju. To radimo sa Append funkcijom:

Riffle[Prepend[data,heading],{2.,0.1}]

Append[Prepend[data,heading],{2.,0.1}]

Append[Prepend[data,heading],{2.,0.1}]//Grid

RotateLeft i RotateRight

Često su korisne i funkcije rotiranja levo i desno:

RotateLeft[Append[RotateRight[Prepend[data,heading],1],{2.,0.1}]]

Prepend[data,heading],{2.,0.1}

RotateLeft[{1,2,3,4,5},1]

RotateLeft[{1,2,3,4,5},2]

RotateRight[{1,2,3,4,5},1]

RotateRight[{1,2,3,4,5},2]

Primetimo da kada imamo listu od liste, RotateLeft (kao i RotateRight) rada na listama dubine 1 a ne na listama dubine 2.

RotateLeft[{{1,2,3,4,5},{0,2,5,3,1}},1]

Kako bismo mogli da rotiramo na dubini 2 (odnosu svaku od podlista, bez da ispermutujemo podliste). To možemo ovako:

RotateLeft[#,1]&/@{{1,2,3,4,5},{0,2,5,3,1}}

31. Ekstrakcija delova liste

Izbor jednog elementa liste pomoću Part

Part nam omogućava da izaberemo deo neke liste. Izabrati element 2 iz liste:

Part[{a,b,c,d,e,f,g},Range[2,5,1]]

{a,b,c,d,e,f,g}[[2;;5]]

Part[{a,b,c,d,e,f,g},2]

[[...]]  je alternativni zapis za to isto. Koristi [[2]] da izabereš drugi element:

{a,b,c,d,e,f,g}[[2]]

Part[Reverse[{a,b,c,d,e,f,g}],2]

Part[{a,b,c,d,e,f,g},-2]

Negativni broj meri od kraja liste:

{a,b,c,d,e,f,g}[[-2]]

Izbor više elemenata liste pomoću Part

Umesto samo jednog možemo da izaberemo više elemenata: ovde izaberimo 2., 4. and 5. element:

{a,b,c,d,e,f,g}[[{2,4,5}]]

U punoj formi

Part[{a,b,c,d,e,f,g},{2,4,5}]

Primetimo da to nije isto što i

{a,b,c,d,e,f,g}[[2,4,5]]

Part možemo da koristimo i da izaberemo više uzastopnih elemenata. Izaberimo sve elemente od 2. do 5:

{a,b,c,d,e,f,g}[[2;;5]]

ili u FullForm:

Part[{a,b,c,d,e,f,g},Range[2,5]]

Izbacivanje elemenata liste pomoću Drop

Još jedna funkcija koja se koristi često je Drop. Dozvoljava da se neki element ili grupa elemenata izbaci. Drop prva dva ili poslednja dva elementa iz liste:

Drop[{1,2,3,4,5},2]

Drop[{1,2,3,4,5},-2]

Ukoliko imamo složenu listu Drop izbacuje odgovarajuće podliste:

Drop[{{1,2,3,5},{3,2},{-1,2}},1,1]

Drop[{{1,2,3,5},{3,2},{-1,2}},-2][[1,3]]

Drop[{{1,2,3,5},{3,2},{-1,2}},-2][[2,3]]

Drop[{{1,2,3,5},{3,2},{-1,2}},1]

Možemo da specifikujemo preciznije šta tačno treba da se dropuje. Ovo dropuje elemente 2 i 4 sa liste:

Drop[Drop[Range[10],{2}],{3}]

A ovako izbacujemo elemente od 2 do 4:

Drop[Range[10],{2,4}]

Table[Drop[n,1],{n,{{1,2,3,5},{3,2},{-1,2}}}]

Ostavljanje grupe elemenata liste pomoću Take (komplementarno sa Drop)

Take je na neki način komplementarna sa Drop. Ovde uzimamo prva 4 ili poslednja 3 elementa:

Take[{a,b,c,d,f},4]

Take[{a,b,c,d,f},-3]

Ovako uzimamo elemente od 2 do 4.

Take[{a,b,c,d,f},{2,4}]

Take[Range[100],{10,30,5}]

Ovako možemo da uzmemo parne elemente od 2 do 6

Take[{a,b,c,d,f,g,h},{2,6,2}]

Operacije na složenim listama

Razmotrimo sada složene liste. Svaka podlista sada jeste red u array.

{{a,b,c},{d,e,f},{g,h,i}}//Grid

Grid[{{a,b,c},{d,e,f},{g,h,i}},Frame-> All]

Izabrati drugu podlistu, odnosno drugi red:

{{a,b,c},{d,e,f},{g,h,i}}[[2]]

Izaberi prvi element u drugom redu:

{{a,b,c},{d,e,f},{g,h,i}}[[2,1]]

Izabrati celu kolonu ili red u složenoj listi

Često je korisno uzeti celu kolonu ili ceo red:

{{a,b,c},{d,e,f},{g,h,i}}[[All,1]]

{{a,b,c},{d,e,f},{g,h,i}}[[1,All]]

Ovaj poslednji izraz mogli smo da uradimo i ovako:

{{a,b,c},{d,e,f},{g,h,i}}[[1]]

Ako imamo još složenije liste, evo načina da izaberemo c:

{{a,b,{c,d}}}[[1,3,1]]

Primena Part vezana za ekstrakciju rešenja algerskog sistema jednačina

Evo i jedne primene ovih koncepata. Na primer, pretpostavimo da želimo da rešimo sledeći sistem jednačina

Solve[{(x^2)+(y^2)==1,x+2 y==2},{x,y}]

Vidimo da imamo dva rešenja. Kako izabrati prvo rešenje?

Solve[{(x^2)+(y^2)==1,x+2 y==2},{x,y}][[1]]

Kako doći do rešenja za x?

Solve[{(x^2)+(y^2)==1,x+2 y==2},{x,y}][[1,1]]

Solve[{(x^2)+(y^2)==1,x+2 y==2},{x,y}][[1,1,2]]

Position nalazi položaj određenog elementa u listi

Position nalazi listu pozicija na kojima se nalazi neki element: Na primer, ovde imamo samo jedno d u matrici, na poziciji 2, 1:

Position[{{a,b,c},{d,e,f},{g,h,i}},d]

Ovo nam daje listu svih pozicija gde se pojavljuje x:

Position[{{x,y,x},{y,y,x},{x,y,y},{x,x,y}},x]

Evo pozicija gde se pojavljuje “a” u listi karaktera:

Position[Characters["The Wolfram Language"],"a"]

Naći pozicije gde se pojavljuje 0 u listi cifara broja 2^500:

IntegerDigits[2^500]

Flatten[Position[IntegerDigits[2^500],0]]

TakeLargest i TakeSmallest

TakeLargest i TakeSmallest uzimaju elemente liste prema veličini. Uzeti prvih 5 najvećih i pet najmanjih elemenata na listi:

TakeLargest[Range[20],5]

TakeSmallest[Range[20],5]

TakeLargest i TakeSmallestBy

TakeLargestBy i TakeSmallestBy rade slično ali kada se na elemente primeni neka funkcija. Od prvih 100 rimskih brojeva uzeti 5 kojima imaju najveću StringLength.

Evo 100 prvih rimskih brojeva. Ovako možemo da izaberemo 5 rimskih brojeva sa najvećim brojem slova u izrazu.

Array[RomanNumeral,100]

TakeLargestBy[Array[RomanNumeral,100],StringLength,5]

A ovako to pretvaramo u obične arapske brojeve.

TakeLargestBy[Array[RomanNumeral,100],StringLength,5]//FromRomanNumeral

ReplacePart: zamena dela liste

Mada ćemo te stvari raditi kasnije detaljnije ovde uvodimo pojam ReplacePart. Koristimo neko pravilo. Ovde zamenjujemo deo na poziciji 3 sa x:

ReplacePart[{a,b,c,d,e,f,g},3->x]

a ovde deo na poziciji 3 sa x i deo na poziciji 5 sa y:

ReplacePart[{a,b,c,d,e,f,g},{3->x,5->y}]

Primetimo da u izrazu 3->x, 3 nije vrednost elementa liste nego redni broj elementa. Kasnije ćemo raditi i zamene gde ne koristimo redni broj neko oblik (pattern). Razmotrimo složemo listu. Ovako ćemo zameniti 3. element u prvoj podlisti (to je c) sa x.

ReplacePart[{{a,b,c,d,e,f,g},{32,21,g,f}},{1,3}->x]

Primena ReplacePart

Zameni 5 slučajno izabranih delova liste karaktera u  “The Wolfram Language” sa “--”. Prvo vidimo kako da generišemo te slučajne zamene:

Table[RandomInteger[20]->"--",5]

ReplacePart[Characters["The Wolfram Language"],Table[RandomInteger[20]->"--",5]]

StringJoin[ReplacePart[Characters["The Wolfram Language"],Table[RandomInteger[20]->"--",5]]]

Ponekad želimo da neki delovi jednostavno nestanu. Ukoliko se Nothing pojavi u listi, to nema nikakve konsekvence na dalje. Na primer:

{1,2,5,Nothing,4,5,Nothing,8}

Length[{1,2,5,Nothing,4,5,Nothing,8}]

Stoga ako želimo da nešto nestane iz liste, možemo i jednostavno da ga zamenimo sa Nothing

ReplacePart[{a,b,c,d,e,f,g},{1->Nothing,3->Nothing}]