RPN: algorithm, mga pamamaraan at mga halimbawa

RPN sa sandaling nabuo ang batayan ng isang computer programmer sa buong mundo. Ngayon ito ay hindi kaya mahusay na kilala. Samakatuwid, comic paglalarawan, na naglalarawan ng isang "reverse" Polish sausage roll sa labas, maaari pa ring gusot sa pamamagitan ng ilang mga kaalaman programmer. Hindi masyadong na rin ipaliwanag ang joke, ngunit sa kasong ito ito ay magiging ganap na nabigyang-katarungan.

gitlapi

Ang lahat ng mga programmer, at karamihan sa mga mag-aaral ay pamilyar sa ang paggamit ng mga operator. Halimbawa, ang mga halaga expression x + kabuuan para sa mga variable x at y na mga plus sign. Mas mahusay na kilala ay ang katunayan na ito ay hiniram sa matematika notation, na tinatawag na gitlapi notation, sa katunayan, ay isang malaking problema para sa mga machine. operator na ito na natatanggap ng input dalawang mga halaga ay naitala sa kaliwa at kanan. Sa programming pagtatanda na ginamit opsyonal na may mga palatandaan na operasyon. Halimbawa, x + y maaaring nakasulat na bilang isang katangian ng fold (x, y), kung saan ang compiler at sa huli ay nag-convert gitlapi notation. Gayunman, lahat ng tao alam ang matematika ay masyadong magandang na hindi gamitin ang arithmetic expression, na bumubuo ng isang uri ng panloob na mini-wika sa halos bawat programming language.

formula tagasalin

Ang unang tunay na matagumpay Fortran programming language ay naging kaya higit sa lahat dahil sa arithmetic expression (ie formula ..) Ito-convert (broadcast) sa code, samakatuwid ay ibinigay ang pangalan ng ito - Formula pagsasalin. Bago iyon, kailangan nilang isulat, halimbawa, nakatiklop sa anyo ng mga function (at multiply (b, c)). Sa COBOL problema ng pagpapatupad ng awtomatikong pag-formula ng conversion ay itinuturing na mahirap dahil ang programmer ay nagkaroon na magsulat ng mga bagay tulad ng Magdagdag ng Isang Upang B Mutliply Sa pamamagitan ng C.

Ano ang mali sa gitlapi?

Ang problema ay, na ang operator ay may tulad properties tulad ng higit na kahalagahan at associativity. Dahil dito, ang kahulugan ng gitlapi function ay nagiging di-mahalaga gawain. Halimbawa, multiplication ay may mas mataas na mangingibabaw kaysa sa karagdagan o pagbabawas, na nangangahulugan na ang expression 2 + 3 * 4 ay hindi katumbas ng sum ng 2 at 3, multiply sa 4, tulad ng ito ay sa ang pagganap ng mga operator mula kaliwa papuntang kanan. Sa katunayan, multiply 3 ng 4 at magdagdag 2. Ang halimbawang ito ay naglalarawan na ang pagkalkula ng gitlapi expression ay madalas na nangangailangan ng pagbabago sa pagkakasunud-sunod ng mga operator at operands. Bilang karagdagan, ito ay kinakailangan upang gamitin ang braces upang tumingin mas malinaw notation. Halimbawa, (2 + 3) * (4 + 5) ay hindi maaaring isulat nang walang panaklong, dahil 2 + 3 * 4 + 5 ay nangangahulugan na kailangan mo upang i-multiply 3 ng 4 at magdagdag ng 2 at 5.

Ang pagkakasunud-sunod kung saan nais mong upang makalkula ang mga operator ay nangangailangan ng isang mahabang matandaan. Dahil dito, ang mga mag-aaral na simulan upang matuto arithmetic, madalas makakuha ng maling resulta, kahit na ang aktwal na operasyon ay ginanap ng tama. Ito ay kinakailangan upang turuan ang pagkakasunod-sunod ng pagkilos pahayag sa pamamagitan ng puso. Una, ay dapat na natupad sa pagkilos na naka-panaklong, at pagkatapos multiplikasyon at dibisyon, at sa wakas ay karagdagan at pagbabawas. Ngunit may ay isa pang paraan ng pagsusulat ng mathematical expression bilang pagtatanda itanim ay isa sa mga posibleng "maliit na mga wika" na maaaring idagdag sa higit lamang.

Prefix at postfix notation

Dalawa sa mga pinaka-kilalang mga alternatibo ay upang i-record ang operator bago o pagkatapos nito operands. Ang mga ito ay kilala bilang ang prefix at postfix notation. Logician Yan Lukasevich imbento ang unang isa sa 1920. Siya ay nanirahan sa Poland, para sa rekord ay tinatawag na Polish. Postfix bersyon, ayon sa pagkakabanggit, na tinatawag na Reverse Polish notasyon (ARF). Ang tanging pagkakaiba sa pagitan ng dalawang mga pamamaraan ay ang direksyon kung saan na basahin ang mga record (mula kaliwa papuntang kanan o kanan pakaliwa), kaya suffices upang isaalang-alang nang detalyado ang isa lamang sa mga ito. Ang OPN operator ay nakasulat pagkatapos nito operands. Kaya, ang mga expression AB + ay kumakatawan sa isang halimbawa RPN para sa A + B.

Walang limitasyong bilang ng mga operands

Ang agarang bentahe ng pagtatanda ay tumutulong ito nagbubuod sa n-adic operator at pagtatanda itanim ay talagang lamang ay gumagana sa dalawang operands, t. E. Sigurado likas na angkop lamang para sa mga binary operasyon. Halimbawa, ABC @ ay ang reverse Polish expression gamit triadic mark kung saan ay ang pinakamataas na halaga ng A, B at C. Sa kasong ito ang operator ay gumaganap sa kaliwa ng tatlong operand mismo at tumutugma sa isang function na tawag @ (A, B, C). Kung susubukan mong isulat ang simbolong @ pati gitlapi, tulad ng A @ BC o isang bagay tulad na, ito ay nagiging malinaw na ang mga ito lamang ay hindi gumagana.

Ang priority na ibinigay ng ang pagkakasunod-sunod

RPN may isa pang kalamangan sa na ang prayoridad ng mga operator ay maaaring kinakatawan ng ang pagkakasunod-sunod ng kanilang hitsura. Kasabay nito ay hindi kailanman kailangang braces, bagaman maaaring sila isasama bilang mga character pagpapatakbo upang mapadali ang conversion mula sa gitlapi notation. Halimbawa, AB + C * - hindi malabo katumbas (A + B) * C, kaya ang pagpaparami ay hindi maaaring kalkulahin hanggang sa karagdagan ginanap, kung saan ay nagbibigay ng isang pangalawang operand para sa pagpaparami. Iyon ay, kung ang kinakalkula AB + C * sa pamamagitan ng isang operator sa isang pagkakataon, makakakuha tayo ng AB + C * -> (AB +) * C -> (A + B) * C.

pagkalkula algorithm

Ang OPN operator mukhang katulad ng isang function na tumatagal ng tulad ng argumento ng dalawang halaga na nakasulat sa kanyang kaliwa. Bilang karagdagan, ito ay isang natural notation para gamitin sa programming wika, na gaya ng ugali ng kanyang kalkulasyon ay tumutugon sa mga operasyon ng stack at ang pangangailangan para sa pag-parse ay eliminated. Halimbawa, ang mga tagapag-aresto sa expression 5 + 6 * 7 ay lilitaw bilang isang 5, 6, 7 *, +, at ito ay maaaring kinakalkula sa pamamagitan lamang ng pag-scan mula kaliwa papuntang kanan at isulat ang mga halaga sa isang stack. Sa tuwing ang isang pangkaraniwang pag-sign ng pagpapatakbo, pinili ng upper element 2 ng ang computer ng memorya, ang operator ay ginagamit at ang resulta ibabalik sa memorya. Kapag ang resulta ng expression pagkalkula ay magiging sa itaas ng stack.

Halimbawa:

• S = () 5, 6, 7, *, + 5 ilagay sa stack.
• S = (5) 6, 7, *, + 6 ilagay sa stack.
• S = (5, 6), 7 *, 7 + ilagay ang stack.
• S = (5, 6, 7), * 2 + piliin ang mga halaga mula sa stack, paggamit * at ilagay ang resulta sa stack.
• S = (5, 6 * 7) = (5, 42) + 2 na halaga napili mula sa stack, upang ilapat ang + at ilalagay ang mga resulta sa stack.
• S = (5 + 42) = (47) pagkalkula ay nakumpleto, ang resulta ay naka-imbak sa itaas ng stack.

algorithm na ito ay maaaring naka-check RPN nang paulit-ulit, ngunit sa bawat oras na ito ay gumagana, kahit gaano complex ang arithmetic expression.

OPN at mga stack ay malapit na naka-link. Ang halimbawang ito ay nagpapakita kung paano gamitin ang memory upang makalkula ang halaga ng reverse Polish notation. Mas mababa halata ay na maaari mong gamitin ang stack, pag-convert ng standard itanim expression sa talamak na kabiguan ng bato.

Mga halimbawa ng mga programming languages

Pascal RPN natanto na tulad nito (nagpapakita ng mga bahagi ng programa).

Upang basahin ang mga numero at operator sa cycle na tinatawag na pamamaraan, na tumutukoy kung ang mga token numero o sign na operasyon. Sa unang kaso, ang halaga na naka-imbak sa stack, at ang pangalawang ng dalawang upper stack numero kaukulang aksyon ay ginanap at ang resulta ay naka-imbak.

toktype: = num;

(S) nabasa ko;

kung c sa [ '+', '-', '*', '/'] pagkatapos ay magsisimulang

kung eoln pagkatapos cn: = '' pa ang basahin (cn);

kung cn = '' pagkatapos ay

kaso ng isang

'+': Toktype: = add; '-': toktype: = sub;

'*': Toktype: = mul; '/': Toktype: = div

katapusan

pa ang magsimula

kung ang isang = '-' pagkatapos ng SGN: = -1 pa ang error: = c <> '+';

na may: = cn

katapusan

end;

kung (hindi error) at (toktype = num) at pagkatapos ay getNumber;

kung toktype <> num pagkatapos ay magsisimulang

y = pop; x: = pop;

kung hindi error pagkatapos ay

kaso toktype ng

idagdag: z: = x + y; sub: z: = x-y; mul: z: = x * y; div: z: = x / y

katapusan

push (z);

C-pagpapatupad RPN (ipinapakita bahagi ng programa):

para sa (s = strtok (s, w); s; s = strtok (0, w)) {

a = strtod (s, & e);

kung (e> s) push (a);

#define rpnop (x) printf ( "% c:", * s), b = pop (), a = pop (), push (x)

iba pa kung (* s == '+') rpnop (a + b);

iba pa kung (* s == '-') rpnop (a - b);

iba pa kung (* s == '*') rpnop (a * b);

iba pa kung (* s == '/') rpnop (a / b);

#undef rpnop

}

hardware pagpapatupad

Sa mga araw na iyon, kapag ang computer teknolohiya ay masyadong mahal, ito ay naisip isang magandang ideya upang pilitin ang mga tao na gumamit ng tagapag-aresto. Noong 1960-ngian., Tulad ng ngayon, ito ay posible na bumili ng mga calculators, na magtrabaho sa reverse Polish notation. Upang magdagdag ng 2 at 3 sa kanila ay dapat magpasok 2, pagkatapos ay 3, at pindutin ang "plus" na pindutan. Sa unang tingin, ang input operands sa operator tila kumplikado at mahirap matandaan, ngunit matapos ang isang habang ang ilan ay gumon sa ito paraan ng pag-iisip at hindi maintindihan kung bakit ang iba ipilit bobo gitlapi, na kung saan ay kaya kumplikado at kaya ay limitado.

Burroughs kumpanya kahit na binuo ng isang kompyuter ng karaniwang sukat, na kung saan ay walang iba pang mga memory, maliban stack. Ang tanging bagay na gumagawa ng mga machine - inilapat sa mga algorithm at mga pamamaraan RPN sa central stack. Ang lahat ng mga operasyon nito ay itinuturing na arresters operator, na kung saan ay sumasaklaw sa itaas na halaga n. Halimbawa, ang koponan kinuha ang Return Address mula sa itaas ng stack, at iba pa. D. Ang arkitektura ng naturang machine ay simple, ngunit hindi sapat na mabilis upang makipagkumpetensya sa mga mas karaniwang mga architectures. Pero marami pa rin ikinalulungkot ang katunayan na ang tulad ng isang simple at eleganteng diskarte sa computing kung saan ang bawat programa ay isang pagpapahayag ng OPN, natagpuan pagpapatuloy nito.

Isang beses calculators na may RPN ay popular, at ang ilang mga tao pa rin bigyan sila ng preference. Bilang karagdagan, sila ay binuo ng isang stack-oriented wika, tulad ng Forth. Ngayon ito ay maliit na ginamit, ngunit pa rin nostalgic mula sa kanyang dating gumagamit.

Kaya kung ano ang ibig sabihin joke tungkol Reverse Polish sausage?

Kung ipinapalagay namin na ang mga operator ng sausage, ang pagtatanda itanim, ito ay dapat na sa loob ng roll tulad ng sa maginoo mainit na aso. Ang RPN Matatagpuan mismo sa dalawang halves maghanda therebetween pagkatapos ng pagkalkula. Ngayon ay dumating ang mahirap na bahagi - mustasa. Siya ay naka-on ang sausage, t. E. Mayroon kinakalkula bilang unary operator. Ito ay pinaniniwalaan na mustasa ay dapat ding ipinapakita bilang uncalculated at samakatuwid ay dapat na inilipat sa kanan ng sausage ... Ngunit ito ay posible, ito ay mangangailangan ng masyadong malaki stack ng ...