J को पढ़ा जा सकता है

टिन! यह नियमित अभिव्यक्ति के माध्यम से प्रोग्रामिंग की तरह है ...

नहीं, तुम मुझे मजबूर मत करो! फिर कभी!

मैं कोड को देखता हूं और एक बेवकूफ की तरह महसूस करता हूं। क्या यह वास्तव में दिमाग की तरह एक गूढ़ भाषा नहीं है? क्या कोई वास्तव में इसका उपयोग करता है? और फिर उन्होंने इन कार्यक्रमों को पढ़ा?

quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)

Perl नसों पर जोर से धूम्रपान करता है।

हबरहाब के बारे में जे



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



जे में लिखने वालों में से कुछ संक्षिप्तता की खोज में किसी भी कोड को लिखने या बस दूर ले जाने के लिए सरल नियमों को भूल जाते हैं। ये नियम नए नहीं हैं, लेकिन वे एपीएल जैसी भाषाओं के संबंध में महत्वपूर्ण हो जाते हैं, क्योंकि जब निर्माण पढ़ते हैं जैसे ((]i.~[:{.[){([:{:[),]`([:<[$:[:>])@.([:32&=[:3!:0[:>]))"2 0



एक प्रशिक्षित मस्तिष्क भी एक ट्यूब में तह करता है।



तो, एक बिल्ली के नीचे पठनीय जे कोड लिखने के लिए सरल नियम।



कट के तहत एक शब्दावली के बिना यह ध्यान न देना बेहतर है। आपको चेतावनी दी गई थी।

और याद रखें, यहां उपयोगी लिंक की एक सूची।

महामारियों का प्रयोग करें

यदि यह असुविधाजनक है या बस अक्सर झांकने के लिए शब्दकोश में नहीं जाना चाहते हैं, तो इस या उस फ़ंक्शन का क्या अर्थ है, या उस निर्माण का क्या अर्थ है - इसे क्रिया में लपेटें:

  head =: {. tail =: {: head 9 8 3 0 6 1 2 5 4 7 9 tail 9 8 3 0 6 1 2 5 4 7 7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फूट डालो और जीतो

कभी-कभी एक जटिल, जटिल डिजाइन को कई सरल लोगों में तोड़ना बेहतर होता है।

  logistic =: dyad : '(^ - y % x) % x * *: >: ^ - y % x' exp =: dyad : '^ - y % x' logistic =: dyad : '(x exp y) % x * *: >: x exp y
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

टिप्पणियाँ

J में टिप्पणियाँ NB.



शुरू होती हैं NB.



, और यह सिर्फ मामला है जब कई नहीं हो सकते हैं ! यदि आप मानक पुस्तकालयों या औद्योगिक कोड में आते हैं, तो आप टिप्पणियों के टन पर ठोकर खा सकते हैं; अक्सर वे स्वयं कोड की तुलना में कई गुना अधिक होते हैं: स्व-दस्तावेजीकरण जे कोड लिखना मुश्किल है, और प्रयास आमतौर पर खुद को औचित्य नहीं देते हैं।

अधिक रिक्त स्थान, अच्छा और अलग

जे पर औसत एक-लाइनर में पहले से ही बीस कमजोर रूप से जुड़े हुए पात्र होते हैं, पढ़ने को एक बार फिर से जटिल करने की कोई आवश्यकता नहीं है। सही ढंग से फैले हुए स्थान और कोष्ठक यहां तक ​​कि सबसे भ्रमित क्रिया की संरचना को समझने में मदद करेंगे।

  (]%[**:@>:@])[:^[:-%~ (] % [ * *:@>:@]) [: ^ [: - %~
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

छिपी की तुलना में स्पष्ट बेहतर है

जटिल अभिव्यक्तियों के लिए, टैसीट के बजाय स्पष्ट संकेतन का उपयोग करना अक्सर बेहतर होता है।

  (] % [ * *:@>:@]) [: ^ [: - %~ dyad : '(] % (x * *:@>:@])) ^ -y%x'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हुक और कांटे आपके मित्र हैं

उन लोगों के लिए जो नहीं जानते थे या भूल गए थे:

  (fg) y ⇔ yf (gy) x (fg) y ⇔ xf (gy) (fgh) y ⇔ (fy) g (hy) x (fgh) y ⇔ (xfy) g (xhy)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ये सरल निर्माण अक्सर कोड की मात्रा को आधा करने में मदद करते हैं, लगभग पठनीयता से समझौता किए बिना।

शासी संरचनाएं

जे में सभी सामान्य नियंत्रण संरचनाएं हैं, लेकिन आप उन्हें केवल स्पष्ट क्रिया के अंदर उपयोग कर सकते हैं।



शाखाएं किसी अन्य भाषा की तरह ही काम करती हैं: यदि T



स्थिति 1 है, तो B



को ब्लॉक करें, अन्यथा हम अगले पर जाते हैं else./elseif.



ब्लॉक else./elseif.



अगर वह है

 if. T do. B end. if. T do. B else. B1 end. if. T do. B elseif. T1 do. B1 elseif. T2 do. B2 end.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

while.



और whilst.



T



1 तक ब्लॉक B



निष्पादित करें, whilst.



अंतर के साथ whilst.



पहले पास के लिए जाँच की जाती है, इसलिए B



हमेशा कम से कम एक बार चलता है।

 while. T do. B end. whilst. T do. B end.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

for.



बस B



को कई बार निष्पादित करता है क्योंकि T



में तत्व हैं; for_i.



क्रमशः चर i



और i_index



- तत्व और उसके सूचकांक बनाता है।

 for. T do. B end. for_i. T do. B end.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

select.



संबंधित ब्लॉक को निष्पादित करते हुए, पहले Ti



मिलान T



जाता है। fcase.



- case.



"असफल" के साथ।

 select. T case. T0 do. B0 case. T1 do. B1 fcase.T2 do. B2 case. T3 do. B3 end.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि ब्लॉक B



विफल हुआ, तो ब्लॉक B1



निष्पादित करें, अन्यथा इसे अनदेखा करें।

 try. B catch. B1 end.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

---

आइए इस पोस्ट से सुडोकू सॉल्वर के लिए इन नियमों को लागू करने का प्रयास करें।

स्रोत कोड:

  i =: ,((,|:)i.9 9),,./,./i.4$3 c =: (#=[:#~.)@-.&0 t =: [:(([:*/_9:c\])"1#])i&{+"1 1(>:i.9)*/[:i&=i.&0 r =: [:,`$:@.(0:e.,)[:;(<@t)"1 s =: 9 9&$@r@,
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिवर्तनों का परिणाम:

  cells =: ,./^:2 i. 4 # 3 rows_cols =: ((, |:) i. 9 9) indices =: , rows_cols, cells no_errors =: verb : '(-: ~.) y -. 0' substitutions =: verb : '(indices { y) +"1 1 ((>:i.9) */ indices = y i. 0)' remove_wrong =: verb : 'y #~ */"(1) _9 no_errors\"1 y' try =: remove_wrong @ substitutions solve =: verb define variants =: y whilst. 0 e. ,variants do. variants =: ; (<@try)"1 variants end. ,variants ) sudoku =: verb : '9 9 $ solve , y'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब कोड दिखाता है कि वह क्या कर रहा है! मेरा मानना ​​है कि यह एक सफलता है।