रेटिना , 530 220 210 202 201 193 191 187 185 (184) बाइट्स
3 बाइट बचाने के लिए यादृच्छिक के लिए क्रेडिट! (और एक जोड़े के लिए मार्ग प्रशस्त करता है।)
+`\.(\d)(.+)( .+)
$1.$2_$3_
\b
#
+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#
\d
11
(?=(1*)\1)[^.]
$1
^(1+)\.\1{90000}1+
Retina!
1.+
Trash!
बाइट-काउंटिंग उद्देश्यों के लिए, प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है, लेकिन आप ऊपर दिए गए कोड को चला सकते हैं, जैसा कि एक फ़ाइल से -sध्वज के साथ रेटिना को शामिल करके किया जाता है।
यह पहले घनत्व की उम्मीद करता है (जिसमें एक दशमलव बिंदु होना चाहिए , भले ही यह एक अनुगामी हो), इसके बाद चौड़ाई और ऊंचाई, यानी d w h।
यह थोड़ा धीमा है। मैं दिए गए अधिकांश परीक्षण मामलों की कोशिश नहीं करूंगा, क्योंकि यह उम्र के लिए चलेगा। हालांकि, आप जांच सकते हैं कि यह परीक्षण के मामलों के साथ सही ढंग से काम करता है
19. 4096 2160 -> Trash!
1. 180 240 -> Trash!
1. 181 240 -> Retina!
1. 180 241 -> Retina!
0.04 10 10 -> Retina!
मूल रूप से, घनत्व को पूर्णांक बनाने के लिए सभी संख्याओं को गुणा करने के बाद, आप नहीं चाहते कि चौड़ाई और ऊंचाई 4 अंकों से अधिक हो।
हालांकि यह धीमा है, यह पूरी तरह से सटीक है ... कोई फ्लोटिंग पॉइंट इश्यू या ऐसा कुछ भी नहीं है। सभी अंकगणित (एकात्मक) पूर्णांक का उपयोग कर रहे हैं।
सिद्धांत रूप में, मैं एक और बाइट दाढ़ी कर सकता हूं: ^छोड़ा जा सकता है, लेकिन यह Trash!अत्यधिक मात्रा में बैकट्रैकिंग के कारण परीक्षण के मामलों को बहुत धीमा कर देगा ।
व्याख्या
पहले, चल बिन्दु संचालन से बचने के लिए असमानता को पुन: व्यवस्थित करें:
√(w2 + h2) / d > 300
√(w2 + h2) > 300 d
w2 + h2 > 90000 d2
हम यह भी नोटिस कर सकते हैं कि यह बहुसंख्या के तहत अपरिवर्तनीय है w, hऔर dएक ही संख्या से x:
w2 + h2 > 90000 d2
(x w)2 + (x h)2 > 90000 (x d)2
x2 (w2 + h2) > 90000 x2 d2
w2 + h2 > 90000 d2
एक अनेरी संख्या को वर्गाकार करने के कई तरीके हैं, लेकिन हम पहचान का उपयोग करेंगे
n2 = Σi=1..2n ⌊i/2⌋
यह हमें केवल पूर्णांक अंकगणित (यूनीरी में पूर्णांक का प्रतिनिधित्व) का उपयोग करके समस्या को हल करने का एक तरीका देता है।
कोड के माध्यम से चलते हैं। लाइनों की प्रत्येक जोड़ी एक रेगेक्स प्रतिस्थापन है।
+`\.(\d)(.+)( .+)
$1.$2_$3_
यह चौड़ाई और ऊंचाई को 10 ( xऊपर) से गुणा करते हुए बार-बार घनत्व में दशमलव बिंदु को दाईं ओर ले जाता है । यह सुनिश्चित करना है कि सभी संख्या पूर्णांक हैं। शून्य को जोड़ने के बजाय, मैं अपील कर रहा हूं _, जिसे मैं बाद में शून्य मानूंगा। (यह एक गोल्फ चाल है, क्योंकि अन्यथा मुझे ...${3}0अस्पष्टता से बचने के लिए लिखना होगा $30।) +रेगेक्स के सामने रेटिना को इस प्रतिस्थापन को दोहराने के लिए कहता है जब तक कि परिणाम बदलना बंद न हो जाए (जो कि तब होता है जब पैटर्न अब मेल नहीं खाता) ।
\b
#
अब हम यूनीरी में रूपांतरण के लिए तीन नंबर तैयार कर रहे हैं। सिद्धांत रूप में, हमें #प्रत्येक संख्या के सामने एक मार्कर ( ) की आवश्यकता होती है , लेकिन यह प्रत्येक संख्या के अंत में एक को जोड़ने के लिए भी छोटा होता है, जो रूपांतरण चरण को प्रभावित नहीं करेगा।
+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#
यह d1111 द्वारा विकसित किए गए एक ट्रिक का उपयोग करके यूनरी में रूपांतरण है । अनिवार्य रूप से मैं प्रत्येक अंक को स्वयं के पुन: अंकों में अनुवाद कर रहा हूं, जबकि मौजूदा अंकों को 10 से गुणा करना ( #प्रक्रिया में मार्कर को दाईं ओर ले जाना)। यह द्विआधारी प्रतिनिधित्व विभिन्न अंकों का एक गड़बड़ी होगा, लेकिन कुल संख्या मूल पूर्णांक के मूल्य के बराबर होगी। \wअंत में ध्यान दें - आम तौर पर यह सिर्फ होता है 0, लेकिन हम _शून्य के रूप में भी इलाज करना चाहते हैं (जिसे रेगेक्स में एक शब्द चरित्र माना जाता है)।
\d
11
हम प्रत्येक अंक को दो 1s में बदल देते हैं , जिससे a) यह सुनिश्चित करना कि सभी अंक समान हैं (जो बाद में आवश्यक होंगे) और b) प्रत्येक संख्या को दोगुना करना।
(?=(1*)\1)[^.]
$1
यह दो काम करता है: यह सभी संख्याओं (या प्रत्येक संख्या के आधे हिस्से पर एक राशि की गणना करके 2n) को बढ़ाता है, और चौड़ाई और ऊंचाई के परिणामस्वरूप वर्गों को जोड़ता है। सूचना जो s, मार्कर और रिक्त स्थान से [^.]मेल खाती है । यदि यह एक या एक स्थान है, तो लुकहेड कुछ भी कैप्चर नहीं करेगा, जिसका अर्थ है कि उन सभी को बस हटा दिया जाता है, अर्थात चौड़ाई और ऊंचाई के परिणाम संक्षिप्त / जोड़े जाते हैं। दशमलव बिंदु उन लोगों के लिए परिणाम को अलग करने के लिए रहता है । यदि इसके बजाय मेल खाता है , तो लुकहेड यह सुनिश्चित करता है कि हम समूह में इसके बाद आधे हिस्से पर कब्जा कर लें । यह मेरे द्वारा ऊपर उल्लिखित योग की गणना करता है, जो तब मूल संख्या के वर्ग का उत्पादन करेगा।1##.d[^.]111
^(1+)\.\1{90000}1+
Retina!
स्ट्रिंग अब (एकात्मक में) है, फिर , तब (एकात्मक में)। हम जानना चाहते हैं कि क्या पहली यूनरी संख्या बार दूसरी से छोटी है। हम एक कैप्चरिंग समूह और पुनरावृत्ति सिंटैक्स का उपयोग करके इस गुणन को आसानी से कर सकते हैं । हम यह सुनिश्चित करने के लिए ( बाद में ) का उपयोग करते हैं कि दूसरी संख्या वास्तव में उससे अधिक है और न के बराबर है। यदि हां, तो हम उस सब को बदल देते हैं ।d2.w2 + h290000{n}1+1*Retina!
1.+
Trash!
यदि दूसरा नंबर पर्याप्त बड़ा नहीं था, तो पिछले चरण में कुछ भी नहीं बदला है और स्ट्रिंग अभी भी एक के साथ शुरू होगी 1। अगर ऐसा है, तो हम पूरे स्ट्रिंग को बदल देते Trash!हैं और कर देते हैं।
