वीएचडीएल साक्षात्कार प्रश्न - यह पता लगाना कि क्या किसी संख्या को शेष के बिना 5 से विभाजित किया जा सकता है


24

मैंने वीएचडीएल के लिए एक अच्छा साक्षात्कार प्रश्न देखा - एक प्रणाली का निर्माण करें जो एक नंबर प्राप्त करता है और पता लगाता है कि क्या इसे 5 शेष द्वारा विभाजित किया जा सकता है। मैंने एक राज्य मशीन के साथ हल करने की कोशिश की (मुझे लगता है कि वे आपको मॉड या रेम का उपयोग नहीं करना चाहते हैं ) और जब मुझे शुरुआती सफलता मिली (संख्या 5, 10, 15, और संख्याएं जैसे कि 20, 40, 80 ने काम किया। ), अन्य संख्याएँ जैसे 130, 75 और इसी तरह मेरे लिए असफल रहे।

मैं अपनी स्टेट मशीन दिखाऊंगा लेकिन यह पूरी तरह गड़बड़ है (यह एक कोड नहीं है, यह एक ड्राइंग है), और जैसे मैंने कहा, काम भी नहीं कर रहा है।

मूल रूप से मैंने जो करने की कोशिश की वह बाइनरी संख्याओं में नीचे लिखी गई है जो 5 से विभाज्य हैं, और एक राज्य मशीन का निर्माण करें जो उनके लिए काम करेगा।

मुझे खुशी होगी अगर आप मुझे दिखा सकते हैं कि इस समस्या को कैसे हल किया जाए, और इस तरह से कुछ का सामना करने पर कैसे सोचा जाए।

धन्यवाद!


आपका मतलब है (संश्लेषण योग्य) हार्डवेयर कार्यान्वयन, परीक्षण करने के लिए सिर्फ कोड नहीं अगर एक पूर्णांक शाब्दिक 5 से विभाज्य है (उदाहरण के लिए testbench)।
एसएमसीआई

@smci मैं वास्तव में एक राज्य मशीन के एक योजनाबद्ध / ड्राइंग के लिए पूछ रहा था, लेकिन उस राज्य मशीन का एक कोड चोट नहीं पहुंचाएगा। डेव ट्वीड ने हालांकि इस सवाल का पूरी तरह से जवाब दिया।
एरन

तो मैं इसे फिर से बताऊंगा * "VHDL साक्षात्कार प्रश्न - अगर पता लगाने के लिए cct ..."
smci

Egreg math.stackexchange.com/a/2569882/213607 द्वारा यहां पर उत्तर देने से अधिक समानता के दृष्टिकोण के लिए कुछ प्रेरणा मिल सकती है।
गणितज्ञ

जवाबों:


37

सीरियल फैशन में एक शेष ऑपरेशन करना वास्तव में काफी आसान है। महत्वपूर्ण धारणा यह है कि डेटा MSB-first में आता है यदि यह धारावाहिक है। आपको केवल शेष अवस्थाओं की गणना करने के लिए N राज्यों की आवश्यकता है। "0" स्थिति में प्रारंभ करें और यदि आप अंतिम बिट के बाद "0" स्थिति में समाप्त होते हैं (इससे कोई फर्क नहीं पड़ता कि कितने बिट्स हैं), शेष है शून्य।

ढांच के रूप में

इस सर्किट का अनुकरण करें - सर्किटलैब का उपयोग करके बनाई गई योजनाबद्ध

इस बारे में सोचें कि आप लंबे समय तक विभाजन कैसे करेंगे यदि केवल एक चीज जिसे आपको ट्रैक करने की आवश्यकता है वह शेष थी:

process (clk)
begin
  if rising_edge(clk) then
    if reset = 1 then
      state <= 0;
    else
      if (state & din) >= N then
        state <= (state & din) - N;
      else
        state <= state & din;
      end if;
    end if;
  end if;
end process;

6
वाह, मैं देख रहा हूं कि यह काम करता है लेकिन आप बता सकते हैं कि आप राज्य मशीन के साथ कैसे आए? शुरुआती बिंदु क्या था? मैंने ऐसा पहले कभी नहीं देखा है कि मैं सिर्फ उत्सुक हूं कि तर्क यह है कि इसके साथ कैसे आना है?
राशि

7
N = 5 के विशिष्ट मामले के लिए VHDL कोड से राज्य का आरेख बस आपको मिलता है। दूसरे शब्दों में, यदि राज्य वर्तमान शेष का प्रतिनिधित्व करता है, तो अगला राज्य वह है जो आपको मिलता है जब आप राज्य को एक बिट छोड़ देते हैं, तो इसमें इनपुट बिट जोड़ें और यदि आवश्यक हो तो 5 घटाएं।
डेव ट्वीड

3
यदि यह सुंदर है, तो मैं वास्तव में प्रभावित होऊंगा यदि कोई व्यक्ति खुद एक साक्षात्कार में इसके साथ आता है। और फिर मैं ख़ुशी से उनसे टिप्पणी करने के लिए कहूँगा कि कैसे संश्लेषण परिणाम अलग-अलग होंगे, प्रत्येक घड़ी चक्र को पूरा करने के लिए रेम ऑपरेटर का उपयोग करने की तुलना में।
कैस्परव

8
@zoder राज्यों के मॉड 5 के अवशेष हैं; 0 तीर इंगित करता है 2n mod 5, और 1 तीर इंगित करता है (2n + 1) mod 5
हॉब्स

2
आप की घोषणाओं जोड़ सकता है state, dinऔर Nअपने कोड के लिए?
mkrieger1

15

यदि डेटा LSB-first आता है तो आप एक स्टेट मशीन भी डिजाइन कर सकते हैं:

परिशिष्ट में इस उत्तर के अंत में वर्णित डीएफए का एक ग्राफिक प्रतिनिधित्व।

इस तरह के एक नियतात्मक परिमित ऑटोमेटन (डीएफए) का अस्तित्व सीधे दूसरे उत्तर से होता है , जो एमएसबी-प्रथम के लिए डीएफए का वर्णन करता है। चूँकि DFA द्वारा स्वीकार की जाने वाली भाषाएं नियमित हैं और नियमित भाषाओं को उत्क्रमण के तहत बंद होने के लिए जाना जाता है (जैसे यहाँ देखें ), वहाँ एक DFA होना चाहिए जो निम्नलिखित भाषा को स्वीकार करता है:

एल={w{0,1}*| उलटा(w)10 द्वारा विभाज्य है 5}

निर्माण

  1. डेव ट्वीड के जवाब से MSB-पहला DFA कॉपी करें । मैंने ऑटोमेटन टूल JFLAP का उपयोग किया लिए ।

  2. DFA रिवर्सल के लिए स्पष्ट परिवर्तन एल्गोरिथ्म लागू करें, जैसे CS.SE पर वर्णित है: डीएफए और इसके विपरीत डिजाइन करना
    आप इस उत्तर के पुराने संशोधन में इस कदम के परिणाम को देख सकते हैं ।

  3. परिणामी DFA को कम से कम करें। दुर्भाग्य से, यह सुविधा नवीनतम जेएफएलएपी संस्करण में थोड़ी छोटी है, इसलिए मैंने इसे हाथ से कम करने के लिए खुद को इस्तीफा दे दिया।
    फिर से, वहाँ उनके लिए कई एल्गोरिदम और स्रोत हैं, मैंने ट्यूटोरियलस्पॉट.कॉम पर "डीएफए मिनिमाइजेशन" में वर्णित एक का उपयोग किया ।

    (वास्तव में, यदि आपकी आँखें डीएफए को देखने के साथ काफी अच्छी तरह प्रशिक्षित हैं, तो आप सीधे उस देख सकते हैंक्ष0क्ष1 डीएफए में समान अवस्थाएं हैं जैसा कि बिंदु 2 में प्राप्त किया गया है। मेरा ध्यान नहीं है, यह सुपरकैट की टिप्पणी पर जाने के लिए धन्यवाद !)

वास्तव में, परिणामस्वरूप ऑटोमेटन सही उत्तर देता है:

दो कॉलम "इनपुट" और "परिणाम" सूची के साथ तालिका कि क्या "स्वीकार" या "अस्वीकार" में विभिन्न संख्या परिणाम हैं।


आरv5=(क्यू,Σ,δ,क्ष0,एफ)क्यू={क्ष0,क्ष1,क्ष2,क्ष3,क्ष4}Σ={0,1}एफ={क्ष0}δ

δ(क्ष0,0)=क्ष0,δ(क्ष0,1)=क्ष1δ(क्ष1,0)=क्ष4,δ(क्ष1,1)=क्ष3δ(क्ष2,0)=क्ष1,δ(क्ष2,1)=क्ष2δ(क्ष3,0)=क्ष2,δ(क्ष3,1)=क्ष4δ(क्ष4,0)=क्ष3,δ(क्ष4,1)=क्ष0


यदि आपको DFA को उलटने में कठिनाई हो रही है, तो आप समीकरण को उल्टा भी कर सकते हैं: new_state = state * 2 + input के बजाय, आप (new_state - input) / 2 = राज्य का उपयोग कर सकते हैं, फिर राज्य और new_state को स्वैप कर सकते हैं। नए समीकरण के लिए DFA को LSB-पहली समस्या का समाधान करना चाहिए।
ईयाल

क्यू 3 और क्यू 4 को ऐसा क्यों कहा गया है और इसके विपरीत नहीं है? लेबल q3 & q4 स्वैप करें, और मशीन एल्गो "आधा (मॉड 5) और इनपुट इनपुट जोड़ें" को लागू करती है।
रोजी एफ

2
@RosieF: वाक्यांश "आधा (mod 5)" शायद असतत गणित से परिचित नहीं लोगों के लिए कुछ और स्पष्टीकरण का उपयोग कर सकता है। इस संदर्भ में डिवीजन संख्या को समान रूप से विभाजित करने के लिए आधार के जितने भी आधार की आवश्यकता होगी, जोड़ते हैं, इसलिए 3/2 (मॉड 5) होगा (3 + 5) / 2, अर्थात 4.
सुपरकैट

7

(MSB पहले) राज्य मशीन के साथ आने का एक तरीका इस प्रकार है:

  1. अब तक प्राप्त संख्या है N। आप शेष को मान लें M = N mod 5

  2. इसमें एक नया बिट आ रहा है और अब नया मूल्य है N' = N*2 + b

  3. नया शेष तो है M' = (N*2 + b) mod 5 = (M*2 + b) mod 5

यह हाथ से सारणीबद्ध करने के लिए काफी आसान है:

    एम बी | एम '
------------------
    0 0 | 0
    1 0 | 2
    2 0 | 4
    ३ ० | 1
    4 0 | 3
    0 1 | 1
    1 1 | 3
    2 1 | 0
    ३ १ | 2
    4 1 | 4

जो डेव ट्वीड के उत्तर में राज्य मशीन से मेल खाता है।


5

एक उम्मीद है कि साक्षात्कार का प्रश्न यह था कि आप VHDL या वेरिलॉग के ins और outs के बजाय समस्या को कैसे हल करेंगे। एक बार एल्गोरिथ्म होने के बाद भाषा का विवरण सीधा होता है।

एस=0एस(2एस+) आधुनिक 5 एसएस,एस=0,,4

एस=0,कश्मीर=0एस(एस+2कश्मीर) आधुनिक 5,कश्मीरकश्मीर+1कश्मीर24=1 आधुनिक 5एस(एस+2कश्मीर) आधुनिक 5,कश्मीर(कश्मीर+1) आधुनिक 4 । फिर से, जब सेएस,कश्मीर, बाध्य हैं, अद्यतन समीकरण को राज्यों के साथ एक साधारण राज्य मशीन के रूप में लिखा जा सकता है (एस,कश्मीर) कहा पे एस=0,,4, कश्मीर=0,,3


3

वीएचडीएल के लिए क्या लिखा जा रहा है, इसके आधार पर, आप एक दृष्टिकोण लेना चाहते हैं जो इसे प्रत्यक्ष, दहनशील गणना के रूप में वर्णित करता है। एक संख्या प्राप्त करने का मतलब यह हो सकता है कि संपूर्ण संख्या एक घड़ी चक्र के लिए एक रजिस्टर में होगी।

उदाहरण के लिए, आप प्रत्येक बिट का प्रतिनिधित्व करने वाले मान के मॉड 5 को नोट कर सकते हैं, इन्हें एक साथ जोड़ सकते हैं, और फिर प्रक्रिया को तब तक दोहरा सकते हैं जब तक आप 5 से कम किसी चीज़ के साथ नहीं छोड़ते हैं। या तो सभी कमी चरणों के लिए इस संयोजन को लागू करें, या कुछ छोटी संख्या के चक्रों के लिए तर्क का फिर से उपयोग करें।

लेकिन अगर आप VHDL रेम ऑपरेटर का उपयोग करते हैं, तो यह सही जवाब हो सकता है। यह मानते हुए कि कंपनी में सभ्य संश्लेषण उपकरण हैं, जो आपको काफी कुशल कार्यान्वयन देगा - राज्य-मशीन समाधानों की तुलना में थोड़ा अधिक क्षेत्र, लेकिन पूर्ण थ्रूपुट और इसलिए शायद प्रति गणना में अच्छी ऊर्जा। यह विकल्प है जिसे लागू करने में कम से कम समय लगेगा और इसलिए नियोक्ता के लिए शायद कम से कम पैसा होगा!

निष्पक्ष होना, यह शायद ऐसा जवाब नहीं है जो वे इस तरह के सवाल के साथ देख रहे हैं - लेकिन यह किसी भी वास्तविक डिजाइन अनुभव को दिखाने का एक अवसर भी है।


3

यदि संख्या एक बिट से बड़ी मात्रा में प्रस्तुत की जाती है, तो अवशेषों मॉड 15 की गणना करने के लिए कुछ समानांतर संगणनाओं का उपयोग करने के लिए सहायक हो सकता है, एक प्रोविज़ो के साथ गणना हो सकती है कि गणना 15 हो सकती है यदि अवशेष शून्य है। Mod-15 अवशेषों की गणना करने का एक सरल तरीका यह है कि N> = 1 के किसी भी मूल्य के लिए, किसी संख्या के भाग में सबसे बाईं ओर 4N बिट्स जोड़ने से एक मान प्राप्त होगा जो मूल mod 15. के अनुरूप है। उपलब्ध संसाधनों के आधार पर समस्या को कई अलग-अलग तरीकों से उप-विभाजित किया जा सकता है।

उदाहरण के लिए, यदि कोई 32-बिट मान से शुरू होता है, तो इसे आठ 4-बिट मान के रूप में माना जा सकता है। चार 5-बिट मानों को प्राप्त करने के लिए जोड़े को एक साथ जोड़ा जा सकता है, जिसे बदले में दो 6-बिट मान या एक 7-बिट मान में जोड़ा जा सकता है। उस 7-बिट मान के ऊपरी तीन बिट्स को निचले 4-बिट्स में जोड़ने से 5-बिट मान प्राप्त होगा जो कि अधिकतम 21 पर है। इस प्रकार यह निर्धारित किया जा सकता है कि अंतिम मान है या नहीं, यह देखते हुए कि मूल मूल्य 5 का गुणक है या नहीं 0, 5, 10, 15, या 20 में से एक।


... या आप 4-बिट योजक का उपयोग कर सकते हैं, और बस सुनिश्चित करें कि प्रत्येक कैरी-आउट एक सर्किट में बाद में एड-इन के लिए कैरी-इन हो जाता है। जोड़ने की तीन परतों के बाद आपके पास एक एकल 4-बिट परिणाम और चार अभी तक अप्रयुक्त कैर्री हैं। पिछले 4-बिट के साथ समानांतर में तीन कैर्री को एक साथ जोड़ें और कैरी-इन के रूप में अंतिम कैरी के साथ परिणाम में अपनी राशि जोड़ें। यह अधिक से अधिक 19 की पैदावार देता है, इसलिए आपको 20 के बाद के मैच की आवश्यकता नहीं है।
हेनिंग मैखोलम

@HenningMakholm: वांछित परिणाम प्राप्त करने के लिए योजक को व्यवस्थित करने के कई तरीके हैं। किसी दिए गए स्थिति में कौन सा दृष्टिकोण बेहतर है यह संभवतः परियोजना-विशिष्ट मार्ग या संसाधन उपयोग के मुद्दों पर निर्भर करेगा। एक और तरकीब एक कैरी-सेव एडर्स का उपयोग करना होगा, लेकिन इस तथ्य का फायदा उठाएं कि स्थानांतरित आउटपुट के शीर्ष बिट को नीचे की ओर ले जाया जा सकता है। इस प्रकार, एक परत 8 इनपुट को 6 में बदल सकती है, फिर 6 को 4 में, फिर 4 को 3 और 3 को 2 में। प्रत्येक परत का एक आउटपुट बस और गेट्स और दूसरा एक XOR गेट होगा, इसलिए एक तक पहुंचने के लिए प्रचार समय के लिए 4-बिट मानों की जोड़ी ...
सुपरकैट

... एक और केवल कैरी चेन चार एक्सोर गेट्स की होगी। जैसे कि क्या 19 से नीचे उत्पादन प्राप्त करना बेहतर है, या क्या संभव अवशेषों के रूप में 20 के लिए जांचना बेहतर है, यह संभवतः संसाधन उपलब्धता और उपयोग पर निर्भर करता है। एक संख्या को देखते हुए जो 30 से अधिक नहीं है, ऊपरी और निचले निबल्स को जोड़ने से एक मूल्य प्राप्त होगा जो कि अधिकतम 15 (या तो 16 + 14-> 1 + 14, या 0 + 15-> 0 + 15), लेकिन स्पष्ट जोड़ देगा कुछ (या 20, 25, 30) के सभी चेक सस्ते हो सकते हैं।
सुपरकाट

2

मैं अपने VHDL को याद नहीं कर सकता, लेकिन यहाँ इस विचार का एक स्केच है जो पहले मन में आया था:

दो की पहली शक्तियों का अंतिम अंक (आधार 10 में) 1, 2, 4, 8, 6, 2, ... और चक्र दोहराता है। इसलिए, दो की शक्तियां 5 हैं 1, 2, 4, 3, ....

इसका उपयोग करते हुए, हम एलएसबी से बिट्स में शिफ्ट हो सकते हैं, और जब भी 1थोड़ा सा देखा जाता है, तब स्थिति के अनुरूप अवशेष 5 मोड जमा कर सकते हैं । संचय मॉड 5 भी करें, और यह जांचने के लिए पर्याप्त है कि क्या राशि अंत में शून्य है।


1

हम यहां उत्तर से विचार का उपयोग कर सकते हैं , कि आधार 4 में हम यह प्राप्त कर सकते हैं कि एक संख्या 5 से विभाज्य है यदि प्रत्यावर्ती अंक योग है। इसलिए हम

  1. अंकों को समूह 2 से 2,
  2. विषम राशि और सम बिट बिट्स घटाएँ।
  3. यदि परिणाम उदाहरण के लिए कुछ बिट्स के दो पूरक क्षेत्र में है [-4,3] (यह मानने के लिए आसान है कि हम दो बस्तियों का उपयोग करते हैं) तो हम समाप्त हो गए हैं और हम मूल संख्या को 5 से विभाजित कर सकते हैं यदि परिणाम केवल सारांश 0 है जो जांचने के लिए एक बहुत ही सरल तार्किक अभिव्यक्ति है (मूल रूप से सिर्फ एक बड़ा और न ही सभी परिणामी बिट्स पर, नहीं?)
  4. अन्यथा हम नए (बहुत कम संख्या) पर पुनरावृति करते हैं।

आइए हम 166 = (10) (10) (01) (10): 2,2,1,2 पर प्रयास करें

2-2 + 1-2 = -1

जो कि पूर्ण मूल्य में <= 3 है और न कि हम केवल एक पुनरावृत्ति में यह निष्कर्ष निकाल सकते हैं कि 166 को 5 से समान रूप से विभाजित नहीं किया गया है।

यह हो सकता है कि एक छोटी सी मेमोरी, गेटिंग की तुलना में फाटकों की गति / एनआर के मामले में सस्ती / बेहतर हो सकती है। एक निश्चित रूप से सबसे खराब (सबसे बड़ा संभावित परिणाम दिए गए इनपुटों को देखते हुए) पूर्व निर्धारित कर सकता है और तदनुसार डिजाइन की योजना बना सकता है।


1

एमएसबी दृष्टिकोण निश्चित रूप से आसान है, लेकिन मैं एमएसबी समाधान उत्पन्न करने की आवश्यकता के बिना एलएसबी राज्य आरेख करने में कामयाब रहा ... मुझे सिर्फ कुछ घंटे लगे। यह @ComFreek द्वारा दिखाए गए एक के बराबर निकला, बस अलग तरीके से एनोटेट किया गया।

हम दो नंबर ट्रैक करने जा रहे हैं। सबसे पहले, हम चल रहे योग, modulo 5 ("SUM") को ट्रैक करने जा रहे हैं। दूसरा, हम 2 की अगली शक्ति के मान को ट्रैक करेंगे, जिसे modulo 5 ("NEXT") में स्थानांतरित किया जाएगा। मैं शीर्ष पर "SUM" के लिए संभावित मानों के साथ प्रत्येक राज्य का प्रतिनिधित्व करता हूं, और उनके नीचे उनके संबंधित "NEXT" मान।

हम उस मामले से शुरू करेंगे जहां "SUM" मोडुलो 5 0 है:

प्रारंभिक

ध्यान दें कि ऐसा राज्य जो दिखता है:
3,2,4,1
1,4,3,2

के बराबर है:
1,3,4,2
2,1,3,4

क्योंकि दोनों अवस्थाएँ यह दर्शाती हैं कि:
SUM = 1 और NEXT = 4 OR
SUM = 2 और NEXT = 3 OR
SUM = 3 और NEXT = 2 OR
SUM = 4 और NEXT = 1।

ठीक है, इसलिए अब हमें अतिरिक्त राज्यों को विकसित करने की आवश्यकता है, क्योंकि अधिकांश साक्षात्कारकर्ता केवल एक राज्य वाले राज्य आरेख से प्रभावित होने वाले नहीं हैं। हम कर रहे हैं जब हर राज्य में दो संक्रमण होते हैं।

जब भी आप एक नए राज्य में संक्रमण करते हैं, "NEXT" में प्रत्येक संख्या दोगुनी हो जाती है, तो modulo'd 5. "SUM" के लिए इन नियमों का पालन करें:

  • यदि आपने 0 के साथ संक्रमण किया है, तो शीर्ष पंक्ति अपने मूल्यों को बनाए रखती है।
  • यदि आपने 1 के साथ संक्रमण किया है, तो प्रत्येक कॉलम पुराने राज्य का "SUM" + "NEXT" मॉडुलो 5 है।

तो, चलो आने वाले बिट 1 है जब संक्रमण भरने से शुरू करते हैं।

सभी 1 के

सब ठीक है, अब हम शून्य को भरते हैं। केवल एक राज्य जोड़ा गया है, इसलिए हम आगे बढ़ेंगे और इसके संक्रमण भी भरेंगे।

पूर्ण

और वोइला! हमें एक राज्य मशीन मिली है जो MSB समाधान उत्पन्न करने के बिना, LSB को पहले स्वीकार करती है।


1

उपरोक्त सभी इतना जटिल लगता है! बाइनरी पूर्णांक पांच से विभाज्य है या नहीं, यह पता लगाने का एक आसान गणित तरीका है। बाहर शुरू करने के लिए, क्या आपको याद है कि साधारण दशमलव अंकगणित में "नाइन आउट कास्टिंग" कैसे करें? दशमलव पूर्णांक का अवशेष मोडुलो 9 अपने अंकों के योग के अवशेष मोडुलो 9 के समान है। यह काम करता है क्योंकि 9 संख्या आधार से एक कम है।

एक समान प्रक्रिया है, "कास्टिंग आउटलेन्स", जहां वैकल्पिक अंकों के संकेत नकारात्मक सेट हैं। यह काम करता है क्योंकि ग्यारह संख्या आधार से एक अधिक है।

इसलिए अगर हम "फाइव आउट" करना चाहते हैं, तो हम संख्या चार में अपने पूर्णांक का प्रतिनिधित्व कर सकते हैं। फिर हम प्रारंभिक योग के रूप में सबसे कम अंकों की जोड़ी के साथ शुरू करते हैं, और अगली राशि प्राप्त करने के लिए इसे अगले जोड़े के अंकों से घटाते हैं। इस तरह से हमारे उम्मीदवार पूर्णांक के माध्यम से जाने के बाद, अंतिम योग शून्य या 5 से विभाज्य होगा यदि हमारा मूल पूर्णांक 5 से विभाज्य है।

उदाहरण 70: 01 00 01 10 -> 01 00 -1 -> 01 01 -> 00, 5 से विभाज्य उदाहरण 49: 11 00 01 -> 11 -1 -> 1 00 -> 1, नहीं 5 से विभाज्य

ध्यान दें कि संचित अंतर के संकेत के लिए और ले जाने के मामलों के लिए आपको एक अतिरिक्त बिट ले जाना चाहिए।

जाने का एक और तरीका है, केवल हेक्स अंक जोड़ने के लिए अवशेष modulo 15. प्राप्त करने के लिए निश्चित रूप से आपको शून्य, पांच, और दस के तीन स्वीकार्य परिणामों की पहचान करने के लिए एक अंतिम तर्क कदम की आवश्यकता है।

उदाहरण 70: 4 6 -> ए, इसलिए 70 5 से विभाज्य है (लेकिन 15 से नहीं) उदाहरण 49: 3 1 -> 4, इसलिए 70 5 से विभाज्य नहीं है।

ध्यान दें कि आप बहुत से विभाज्यता परीक्षणों के निर्माण के लिए विभिन्न संख्या आधारों का उपयोग कर सकते हैं, हालांकि कंप्यूटर लॉजिक में 2 +/- 1 की शक्तियों के लिए लागू करना आसान है।

दशमलव अंकगणित में, मेरे पसंदीदा में से एक अवशेषों मॉड 7 के लिए मेरा परीक्षण है। ध्यान दें कि 100 7 के एक बहु से दो अधिक है, इसलिए अंकों को जोड़े में काम करें (संख्या आधार 100 में काम करें) और इकाइयों से सैकड़ों TWICE जोड़ें। यहां हम बाएं से दाएं काम करते हैं ...

उदाहरण: 98 76 -> 2 72 -> 76, इसलिए 9876 7 से विभाज्य नहीं है। यह 6 आधुनिक है। 7. उदाहरण: 03 45 67 -> 51 67 -> 1 69 -> 71 तो यह 1 मॉड 7।

बेशक, बाइनरी में, बस अष्टक अंकों (3 बिट्स के समूह) का योग लेते हैं।

क्षमा करें, मेरी इच्छा है कि मैं एक वेरिलोग गुरु था, लेकिन अंकगणित वह सब है जो मैं जीवन के इस चरण में पेश कर सकता हूं। रॉन डॉयलर की "डेड रेकनिंग" को इस तरह के कई ट्रिक्स के लिए देखें।


मुझे आश्चर्य है कि अगर हमारे कनाडा के चचेरे भाई कुछ विशेष एल्गोरिदम हो सकते हैं। चूँकि उन्होंने कनाडाई पैसे की घोषणा की, सभी कीमतें निकटतम $ 0.05 के बराबर हैं।
richard1941

1

एक VHDL साक्षात्कार प्रश्न कुछ VHDL कोड में परिणाम होना चाहिए।

मेरे पास डेव ट्वीड के राज्य संक्रमण तालिका के कार्यान्वयन के साथ एक ghdl llvm बैकएंड बग को खोजने का अवसर था, जहां ghdl के लेखक ने एक समारोह में 17 लाइनों में कार्यान्वयन को आसवित किया:

type remains is (r0, r1, r2, r3, r4); -- remainder values

    function mod5 (dividend: bit_vector) return boolean is
        type remain_array is array (NBITS downto 0) of remains;
        type branch is array (remains, bit) of remains;
        constant br_table:  branch := ( r0 => ('0' => r0, '1' => r1),
                                        r1 => ('0' => r2, '1' => r3),
                                        r2 => ('0' => r4, '1' => r0),
                                        r3 => ('0' => r1, '1' => r2),
                                        r4 => ('0' => r3, '1' => r4)
                                      );
        variable  remaind:    remains := r0;
        variable tbit:        bit_vector (NBITS - 1 downto 0) := dividend;
    begin
        for i in dividend'length - 1 downto 0 loop
            remaind := br_table(remaind,tbit(i));
        end loop;
        return remaind = r0;
end function;

संबद्ध परीक्षण मामला काफी आसान डिबगिंग की अनुमति देता है और एनुमरेटेड प्रकार में VHDL के साथ संगत राज्य नामों का उपयोग करता है:

dave_tweed.png (दीया के साथ बनाया गया)

यहां विचार यह है कि एक साक्षात्कार के दौरान VHDL उत्तर लिखने के लिए फ़ंक्शन (या यहां तक ​​कि 27 लाइनों का एक उदाहरण VHDL कार्यक्रम) पर्याप्त है। ज्ञान और कौशल दोनों के प्रदर्शन की आवश्यकता वाले साक्षात्कार प्रश्न को खराब करने के बारे में चिंता करने की कोई आवश्यकता नहीं है, एक साक्षात्कारकर्ता से यह उम्मीद की जाएगी कि वह एक कार्यान्वयन का बचाव करेगा।

(Llvm बैकएंड बग को आज पहले 1f5df6e प्रतिबद्ध किया गया है।)

ध्यान देने योग्य बातों में से एक यह है कि राज्य संक्रमण तालिका हमें यह भी बताती है कि लाभांश से 5 घटाते समय एक अवमानक बिट एक '1' होगा जो एक राज्य द्वारा कम शेष मान (या r4 के लिए दोनों संक्रमण) के साथ दिखाया जाएगा। जिसे एक अलग तालिका (या रिकॉर्ड प्रकार की तालिका जो बोझिल लगती है) में एन्कोड किया जा सकता है। हम इसे ग्राफ़िक्स हार्डवेयर में क्षैतिज स्क्रीन रिज़ॉल्यूशन से निपटने के लिए ऐतिहासिक रूप से करते हैं जो 5 पिक्सेल के गुणकों में होता है।

ऐसा करने से हमें एक div / mod5 एक भागफल और शेष उत्पादन देता है:

library ieee;
use ieee.std_logic_1164.all;

entity divmod5 is
    generic (
        NBITS:  natural := 13 
    );
    port (
        clk:        in  std_logic;
        dividend:   in  std_logic_vector (NBITS - 1 downto 0);
        load:       in  std_logic;
        quotient:   out std_logic_vector (NBITS - 3 downto 0);
        remainder:  out std_logic_vector (2 downto 0);
        remzero:    out std_logic
    );
end entity;

architecture foo of divmod5 is
    type remains is (r0, r1, r2, r3, r4); -- remainder values
    type remain_array is array (NBITS downto 0) of remains;
    signal remaindr:    remain_array := (others => r0);
    signal dividendreg: std_logic_vector (NBITS - 1 downto 0);
    signal quot:        std_logic_vector (NBITS - 3 downto 0);
begin

parallel:
    for i in NBITS - 1 downto 0 generate
        type branch is array (remains, bit) of remains;
        -- Dave Tweeds state transition table:
        constant br_table:  branch := ( r0 => ('0' => r0, '1' => r1),
                                        r1 => ('0' => r2, '1' => r3),
                                        r2 => ('0' => r4, '1' => r0),
                                        r3 => ('0' => r1, '1' => r2),
                                        r4 => ('0' => r3, '1' => r4)
                                      );

        type qt is array (remains, bit) of std_ulogic;
    -- Generate quotient bits from Dave Tweeds state machine using q_table.
    -- A '1' when a remainder goes to a lower remainder or for both branches
    -- of r4. A '0' for all other branches.

        constant q_table:   qt :=     ( r0 => (others => '0'),
                                        r1 => (others => '0'),
                                        r2 => ('0' => '0', '1' => '1'),
                                        r3 => (others => '1'),
                                        r4 => (others => '1')
                                      );
        signal tbit:    bit;
    begin
        tbit <= to_bit(dividendreg(i));
        remaindr(i) <= br_table(remaindr(i + 1),tbit);
do_quotient:
        if i < quot'length generate   
            quot(i) <= q_table(remaindr(i + 1),tbit);
        end generate;
    end generate;

dividend_reg:
    process (clk)
    begin
        if rising_edge(clk) then
            if load = '1' then
                dividendreg <= dividend;
            end if;
        end if;
    end process;

quotient_reg:
    process (clk)
    begin
        if rising_edge (clk) then
            quotient <=  quot;
        end if;
    end process;

remainders:
    process (clk)
    begin
        if rising_edge(clk) then 
            remzero <= '0';
            case remaindr(0) is
                when r0 =>
                    remainder <= "000";
                    remzero <= '1';
                when r1 =>
                    remainder <= "001";
                when r2 =>
                    remainder <= "010";
                when r3 =>
                    remainder <= "011";
                when r4 =>
                    remainder <= "100";
            end case;
        end if;
    end process;

end architecture;

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity divmod5_tb is
end entity;

architecture foo of divmod5_tb is
    constant NBITS:    integer range 0 to 13 := 8;
    signal clk:        std_logic := '0';
    signal dividend:   std_logic_vector (NBITS - 1 downto 0);
    signal load:       std_logic := '0';

    signal quotient:   std_logic_vector (NBITS - 3 downto 0);
    signal remainder:  std_logic_vector (2 downto 0);
    signal remzero:    std_logic;
    signal psample:    std_ulogic;
    signal sample:     std_ulogic;
    signal done:       boolean;
begin
DUT:
    entity work.divmod5
        generic map  (NBITS)
        port map (
            clk => clk,
            dividend => dividend,
            load => load,
            quotient => quotient,
            remainder => remainder,
            remzero => remzero
        );
CLOCK:
    process
    begin
        wait for 5 ns;
        clk <= not clk;
        if done'delayed(30 ns) then
            wait;
        end if;
    end process;
STIMULI:
    process
    begin
        for i in 0 to 2 ** NBITS - 1 loop
            wait for 10 ns;
            dividend <= std_logic_vector(to_unsigned(i,NBITS));
            wait for 10 ns;
            load <= '1';
            wait for 10 ns;
            load <= '0';
        end loop;
        wait for 15 ns;
        done <= true;
        wait;
    end process;

SAMPLER:
    process (clk)
    begin
        if rising_edge(clk) then
            psample <= load;
            sample <= psample after 4 ns;
        end if;
    end process;

MONITOR:
    process (sample)
        variable i:     integer;
        variable div5:  integer;
        variable rem5:  integer;
    begin
        if rising_edge (sample) then
            i := to_integer(unsigned(dividend));
            div5 := i / 5;
            assert div5 = unsigned(quotient)
                report LF & HT &
                    "i = " & integer'image(i) &
                    " div 5 expected " & integer'image(div5) & 
                    " got " & integer'image(to_integer(unsigned(quotient)))
                SEVERITY ERROR;
            rem5 := i mod 5;
            assert rem5 = unsigned(remainder)
                report LF & HT &
                    "i = " & integer'image(i) &
                    " rem 5 expected " & integer'image(rem5) & 
                    " got " & integer'image(to_integer(unsigned(remainder)))
                SEVERITY ERROR;
        end if;
    end process;

end architecture;

यहां एक जेनरेट स्टेटमेंट के साथ कार्यान्वित किया गया, एक आंतरिक जेनरेट करने वाला स्टेटमेंट है, जिसमें भागफल बिट्स है। रिडर सरणी राज्य संक्रमण का पता लगाता है:

divmod5_tb.png

एक अंकगणितीय ऑपरेशन के बिना सभी।

सभी रजिस्टरों के बिना मोड के साथ मापदंडों का लाभ उठाते हुए एक प्रक्रिया को लागू करना भी संभव है। कि एक साक्षात्कार के लिए लाइनों की एक न्यूनतम संख्या दृष्टिकोण होगा।

एक क्रमबद्ध अनुक्रम कार्यान्वयन के लिए थोड़ा काउंटर और प्रवाह नियंत्रण (एक जेके फ्लिप फ्लॉप और कुछ द्वारों) की आवश्यकता होगी।

लाभांश आकार के आधार पर एक समय / जटिलता व्यापार बंद होता है जो आपको एक साक्षात्कार में बचाव करने की भी आवश्यकता होगी।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.