Theory
Till એ ગણિતમાં નિષ્ફળ ન જવું જોઈએ
Till પર combo નો order આવે છે: 15 ના ભાવે 2 સમોસા વત્તા 3 ચા... software એ 2 + 3 × 5 ગણવું પડે.
એ 17 છે કે 25? તમને ખબર છે કે એ 17 છે (પહેલાં ગુણાકાર), કારણ કે તમારી શાળાએ અગ્રતા તમારામાં ઠસાવી છે.
પણ ડાબેથી જમણે વાંચતું યંત્ર પહેલાં 2 + 3 જુએ છે અને ખુશીથી 25 આપે છે. દરેક calculator ને કૌંસ સહિતનું આખું BODMAS શીખવવું ગૂંચવાડાભર્યું છે. Computer science ને વધુ સ્વચ્છ યુક્તિ મળી: બે પાઠ પહેલાંનો stack વાપરીને નોંધણી પોતે બદલી નાખો.
Theory
એક વાક્ય કહેવાની ત્રણ રીત
Operator ક્યાં બેસે છે એ ફક્ત વ્યાકરણ છે:
- Infix: A + B (operator વચ્ચે in: માણસની શૈલી)
- Postfix: A B + (operator પછી: "A અને B લો, હવે સરવાળો")
- Prefix: + A B (operator પહેલાં: "પછીના બેનો સરવાળો કરો")
એ જ અર્થ, શબ્દોના ત્રણ ક્રમ. જાદુ આ છે: postfix અને prefix માં કૌંસ કે અગ્રતાના નિયમોની ક્યારેય જરૂર પડતી નથી. ફક્ત ચિહ્નોનો ક્રમ જ કામનો ક્રમ નક્કી કરી દે છે.
Theory
ક્રમના નિયમો
રૂપાંતર operator ની અગ્રતા પર ચાલે છે (કોણ વધુ ચુસ્ત બાંધે છે):
1. કૌંસ ( ) પહેલાં, હંમેશા
2. ઘાત ^
3. પછી × અને /
4. છેલ્લે + અને -
5. સરખો ક્રમ: ડાબેથી જમણે કામ કરો
એટલે 2 + 3 × 5 માં, + ને વારો મળે એ પહેલાં × એ 3 અને 5 ને પકડી લે છે: પદાવલિનો ખરો અર્થ છે 2 + (3 × 5).
એ સૂઝ જ રૂપાંતરની રીત છે: અદૃશ્ય કૌંસને દૃશ્યમાન બનાવો, પછી દરેક operator ને ખસેડો.
Follow along
પરીક્ષાની રીત: પૂરા કૌંસ મૂકીને રૂપાંતર
- અગ્રતા વાપરીને infix પદાવલિ પર પૂરા કૌંસ મૂકો A + B × C એ (A + (B × C)) બને છે: દરેક operator ને પોતાની કૌંસની જોડ મળે છે.
- POSTFIX માટે: દરેક operator ને એના બંધ થતા કૌંસની બરાબર પછી ખસેડો (A + (B × C)) : × એ (B C) પછી કૂદે છે, + એ બધા પછી કૂદે છે: (A (B C) ×) +
- PREFIX માટે: દરેક operator ને એના ખૂલતા કૌંસની બરાબર પહેલાં ખસેડો + (A × (B C)) : operators એને બદલે પોતાના કૌંસની આગેવાની લે છે.
- બધા કૌંસ ભૂંસી નાખો Postfix: A B C × + Prefix: + A × B C. પતી ગયું, એકેય કૌંસ બચતો નથી.
Theory
બે વાર ઉકેલ્યું: કૌંસ બધું બદલી નાખે છે
A + B × C (× પહેલાં બાંધે છે):
કૌંસ સાથે: (A + (B × C))
Postfix: A B C × + Prefix: + A × B C
(A + B) × C (કૌંસ + ને પહેલાં ફરજ પાડે છે):
કૌંસ સાથે: ((A + B) × C)
Postfix: A B + C × Prefix: × + A B C
બે postfix જવાબ સરખાવો: એ જ ત્રણ અક્ષર, જુદી કથા. Infix આવૃત્તિનો કૌંસ જુદા ક્રમ તરીકે ટકી રહે છે, કૌંસ તરીકે નહીં.
Think first
કાગળ પર તમારો વારો
કૌંસની રીત વાપરીને A × (B + C) - D ને postfix માં ફેરવો. પહેલાં કાગળ પર કરો: પૂરા કૌંસ મૂકો, operators ખસેડો, કૌંસ ભૂંસો. પછી tap કરો.
Show the answer
અગ્રતા પ્રમાણે પૂરા કૌંસ: ((A × (B + C)) - D)
Operators ને એમના બંધ થતા કૌંસ પછી ખસેડો:
+ એ (B C) પછી → B C +
× એ (A ...) પછી → A B C + ×
- છેલ્લે → A B C + × D -
Postfix: A B C + × D -
જો તમે A B C + × D - લખ્યું હોય તો રીત તમને આવડે છે; જો + અને × અદલાબદલ થઈ ગયાં હોય, તો ફરી તપાસો કે કયો કૌંસ પહેલાં બંધ થાય છે (સૌથી અંદરનો જીતે છે).
Quiz
A + B × C નું postfix સ્વરૂપ શું છે, અને એ A B + C × કેમ **નથી**?
- A B C × +, કારણ કે × ની અગ્રતા વધારે છે એટલે B × C પહેલાં જૂથબદ્ધ થાય છે
- A B + C ×, કારણ કે રૂપાંતર હંમેશા ડાબેથી જમણે ચાલે છે
- × + A B C, કારણ કે operators આગળ ખસે છે
- A B C + ×, કારણ કે infix પદાવલિમાં + પહેલાં દેખાય છે
Show the answer
A B C × +, કારણ કે × ની અગ્રતા વધારે છે એટલે B × C પહેલાં જૂથબદ્ધ થાય છે
અગ્રતા બીજા કશા પહેલાં B × C ને જૂથબદ્ધ કરે છે: (A + (B × C)) → A B C × +. વિકલ્પ B એ અગ્રતાને બદલે વાંચવાના ક્રમે રૂપાંતર કરવાની જાણીતી ભૂલ છે: A B + C × નો ખરેખર અર્થ થાય છે (A + B) × C, જે જુદી પદાવલિ છે. વિકલ્પ C એ PREFIX સ્વરૂપનો તર્ક છે (ખોટી જગ્યાએ લગાડેલો), અને વિકલ્પ D એ ડાબેથી જમણેનો ફાંદો નવા પોશાકમાં દોહરાવે છે.
Watch out
Marks ક્યાં અદૃશ્ય થાય છે
અગ્રતાની અવગણના એ જીવલેણ છે: A + B × C ને ડાબેથી જમણે ફેરવવાથી ખોટો જવાબ મળે છે જે સુઘડ દેખાય છે. હંમેશા પહેલાં કૌંસ, પછી રૂપાંતર.
સરખી અગ્રતાવાળા operators ડાબેથી જમણે ચાલે છે: A - B + C ના કૌંસ ((A - B) + C) થાય છે, ક્યારેય (A - (B + C)) નહીં.
અને તમારા જવાબો પર નામ લખો: પરીક્ષકો postfix અને prefix બંને માંગે છે; સાચું postfix જો prefix લખીને આપ્યું હોય તો શૂન્ય marks.
Formula
આ કામ stack ના હાથમાં કેમ છે
યંત્રમાં, રૂપાંતર અને ગણતરી બંને stack પર ચાલે છે: operands પસાર થઈ જાય છે, operators ત્યાં સુધી stack પર રાહ જુએ છે જ્યાં સુધી નીચી અગ્રતાવાળો operator (કે બંધ થતો કૌંસ) એમને બહાર ન કાઢે. Postfix ગણવું તો એથીય સાદું છે: સંખ્યા દેખાય, push કરો; operator દેખાય, બે pop કરો, ગણો, પાછું push કરો. પરીક્ષા માટે stack ના ઉપયોગની આખી યાદી: પદાવલિનું રૂપાંતર/ગણતરી, function ના calls, undo/redo, browser નું back, કૌંસના સંતુલનની ચકાસણી.
Summary
Key takeaways
- Infix (A + B) ને અગ્રતા અને કૌંસ જોઈએ છે; postfix (A B +) અને prefix (+ A B) ને એકેય નહીં.
- અગ્રતા: કૌંસ, પછી ^, પછી × /, પછી + -, સરખા ક્રમ માટે ડાબેથી જમણે.
- રીત: પૂરા કૌંસ મૂકો, operators ને એમના કૌંસ પછી (postfix) કે પહેલાં (prefix) ખસેડો, કૌંસ ભૂંસો.
- A + B × C → postfix A B C × +, prefix + A × B C; (A + B) × C → A B + C ×.
- યંત્ર stack થી રૂપાંતર અને ગણતરી કરે છે: operands વહે છે, operators રાહ જુએ છે.
- Stack ના ઉપયોગ: પદાવલિઓ, call stack, undo, browser નું back, કૌંસની ચકાસણી.
- Memory hook: પહેલાં કૌંસ, પછી operators ખસેડો.