ब्रेनफक - 617 616 604 बाइट्स
+>>>>,[>++++[<-------->-]<[>>>>],]<<<<[>+<<+<+>>-]<[>+<-]+<+<<[>+>-<<-]>[<+>-]>[,+++++[>+++++<-]>>[<->-]<[>>>>>[>>>>]+[<<<<]<-]>>[<+>-]<<<]>[>>[,<]<<+++++++++<]<<<[-[+>>-<]>[>>[<+<+>>-]<<<<[>+>-<<-]>[<+>-]>[<<[<<<<]>>>>[[<<<<+>>>>-]>>>>]<<<<+>>-]>[>+<-]]<<<[-[+>]+<<<<]>>>>-<<<<<]>>>>>+++++[>----<-]>->[<+>>+<-]<[<<<[<<<<]+[>>>>]<-]>>[<+>-]<[<<<<]>>>++++[<-------->-]>[-[,+++>]+>>>[<<<->>]>]<<<<<[>-]>[>>]>>+[<++++[<++++++++>-]<]>>[+++++++++++++>>>>]<<<<----<+++[<<+<<[<<+<<]+[>>>>]<<<<-]<<<<[-<<<<]>[.,>>]<<<<<[<<<<]<++++++++++<<.<+<<+<<+<<+<<+<[.,>>]<<<<<[<<]>++++++++++<+<<+<<+<..<+<[.,>>]<[<<]<...<<.
इसने मुझे दो दिनों का बेहतर हिस्सा दिया। मुझे लगता है कि यह इसके लायक था। वहाँ शायद भागों है कि क्या सेल कुछ में संग्रहीत किया जाता है या जो कुछ भी बदलकर और अधिक गोल्फ हो सकता है, लेकिन अभी मैं सिर्फ खुश हूँ मैं इसे काम कर रहा हूँ।
यदि यह प्रश्न निर्दिष्ट नहीं करता है कि इनपुट सॉर्ट किया जाएगा तो यह कार्यक्रम पूरी तरह से अलग होगा। जिस तरह से यह काम करता है वह इनपुट के आसपास 10 पिन की एक सूची का निर्माण करता है। यह भ्रामक है लेकिन शायद यह इसे बेहतर तरीके से समझाएगा:
If you input these pins: [2, 3, 6, 8, 9]
First, the program does this: [2, 3, 6, 8, 9] + [10]
Then this: [2, 3, 6] + [7] + [8, 9, 10]
Then this: [2, 3] + [4, 5] + [6, 7, 8, 9, 10]
Finally, this: [1] + [2, 3, 4, 5, 6, 7, 8, 9, 10]
To build this: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
यह करते समय, यह याद रखता है कि उपयोगकर्ता ने कौन सा पिन वहां रखा है और कौन सा इसे वहां रखा है। यदि इनपुट सॉर्ट नहीं किया गया था, तो इस रणनीति का उपयोग करना बहुत मुश्किल होगा।
एक और बात जो छांटना आसान बनाती है, वह है संख्या 10 का पता लगाना। क्योंकि ब्रेनफक अलग-अलग बाइट्स के साथ काम करता है, न कि "नंबर" प्रति से, यह गधे में दर्द हो सकता था, लेकिन हल किए गए इनपुट ने मुझे सौदा करना बहुत आसान बना दिया। साथ में। इसका कारण यह है कि मैंने कार्यक्रम में डेटा कैसे संग्रहीत किया है। मैं समय पर इनपुट एक चरित्र लेता हूं और परिणाम से 32 घटाता हूं। यदि कोशिका उसके बाद गैर-शून्य है, तो मैं 4 कोशिकाओं को आगे बढ़ाता हूं। दोहराने से पहले। इसका मतलब यह है कि मुझे हर 4 सेल में नॉन-स्पेस बाइट मिलती है, और मैं प्रभावी रूप से पिन को उनकी संख्या + 16 के रूप में संग्रहीत करता हूं। हालांकि, 10 को दो बाइट्स टाइप करने में लगते हैं, इसलिए मुझे इसे विशेष मामला बनाना पड़ा। यदि इनपुट सॉर्ट नहीं किया गया था, तो मुझे पिंस के माध्यम से देखना होगा, लेकिन जब से यह सॉर्ट किया गया है, यह दिखाई देने पर हमेशा अंतिम पिन होगा। मैं जांचता हूं कि क्या (इनपुट के अंतिम बाइट + 1) == (इनपुट के दूसरे अंतिम बाइट) और यदि ऐसा है, तो यह 10 होना चाहिए। मुझे अंतिम बाइट से छुटकारा मिलता है और दूसरा अंतिम सेट करता है जो मेरे सिस्टम को समझता है "10"। किरदार'1'और '0'एक भी बाइट में फिट नहीं है, लेकिन संख्या 26 सुनिश्चित करता है!
बस कुछ काम करने के लिए ट्रिक्स के साथ आना इस भाषा का उपयोग करने का मेरा पसंदीदा हिस्सा है। :)
यदि आप रुचि रखते हैं कि यह कार्यक्रम और अधिक विस्तार से कैसे काम करता है, तो आप इस कार्यक्रम को उन टिप्पणियों के साथ देख सकते हैं जो मैंने इसे लिखने के लिए उपयोग किया था, यह सुनिश्चित करने के लिए कि मुझे याद है कि सब कुछ क्या किया था। यहां तक कि ब्रेनफॉक में टिप्पणियां लिखना कठिन है, क्योंकि कोई टिप्पणी वाक्य रचना नहीं है। इसके बजाय, हर चरित्र को छोड़कर जो <[+.,-]>बिना ऑप्स हैं। गलती से .या ,अपनी टिप्पणी सहित बग को लागू करना आसान है ! यही कारण है कि व्याकरण इतना विस्की है और अर्धविराम हर जगह हैं।
संपादित करें: यह कितना आसान है कि इसे पेंच करना एक उदाहरण के रूप में: मैंने टिप्पणियों में "गैर-स्थान" का उपयोग किया! जब मैंने स्रोत से सभी गैर-बीएफ वर्णों को छीन लिया, तो जो कार्यक्रम मैं करता था वह अंदर रखा गया था -। सौभाग्य से यह कुछ भी नहीं टूटा, लेकिन अब मैंने इसे बाइट बचाने के लिए हटा दिया है। :)
संपादित करें II: जब से मैंने इस एक, हाहा को छुआ है, यह एक समय हो गया है। इस साइट पर एक अन्य ब्रेनफक जवाब में, मैंने देखा कि मैंने गलती से टिप्पणी संस्करण में एक अल्पविराम का उपयोग किया था। चूंकि इनपुट पहले ही समाप्त हो चुका था, इसलिए यह वर्तमान सेल को 0 पर सेट करता है (यह कार्यान्वयन पर निर्भर है, लेकिन मेरे अनुभव में यह सबसे आम व्यवहार है)। मैंने बग को ठीक कर दिया, लेकिन यह मुझे सोच में पड़ गया। सेल को 0 पर सेट करने का मुहावरेदार तरीका है [-](लगभग while (*p) { *p--; }), जो दो बाइट्स लंबा है। किसी भी समय सभी इनपुट पढ़ा गया है, मैं ,इसके बजाय उपयोग कर सकता हूं । इसने मुझे उस उत्तर में 2 बाइट्स बचाए, और इस एक में 12!
one flag at the very left; will be important later
+>>>>
all nonspace bytes of input separated by 3 empty cells; pin number `n` stored with value `n` plus 16
,[>++++[<-------->-]<[>>>>],]<<<<
test if last pin is 10
[>+<<+<+>>-]<[>+<-]+<+<<[>+>-<<-]>[<+>-]>
[
if not: find 10 minus the number it is; put that many placeholder pins (cells with value 1) at the end
,+++++[>+++++<-]>>[<->-]<[>>>>>[>>>>]+[<<<<]<-]>>[<+>-]<<<
]>
[
if so: get rid of '0' byte; convert '1' byte to 26 (10 plus 16)
>>[,<]<<+++++++++<
]<<<
pointer now sitting on the cell with the second greatest pin that was inputted (ie not a placeholder)
;;;;;;;
[
check for flag placed at the very beginning of the program; if present: break
-[+>>-<]>
[
find ((pin to our right) minus 1) minus pin to our left
move all pins left of us 4*(that value) cells and insert placeholder pins
>>[<+<+>>-]<<<<[>+>-<<-]>[<+>-]>[<<[<<<<]>>>>[[<<<<+>>>>-]>>>>]<<<<+>>-]>[>+<-]
]
find first non placeholder pin to our left
there has to be one because we haven't hit the flag yet
<<<[-[+>]+<<<<]>>>>-<<<<<
]>>>>>+
we have now added placeholder pins at the end and in the middle; all that's left is the beginning
subtract 17 from lowest pin and put that many placeholders to the left
++++[>----<-]>->[<+>>+<-]<[<<<[<<<<]+[>>>>]<-]>>[<+>-]
subtract 32 from an empty cell 2 to the left of the lowest pin; will be useful later
<[<<<<]>>>++++[<-------->-]>
placeholder pins have the value 1; real pins have a value somewhere between 17 and 26
normalize it by stepping through and setting every pin with value != 1 to 3 (0's ascii code is 2 higher than period so this will make it easier to print later)
[-[,+++>]+>>>[<<<->>]>]<<<<<[>-]>[>>]>>
start writing 32s across the board; hitting every second cell
that's every pin and the cell 2 to the right of each pin
this is done in such a way that it will only halt if adding 32 to a cell sets it to 0; which is why we subtracted 0 from an empty cell earlier
it will catch us and prevent an infinite loop
+[<++++[<++++++++>-]<]
now write 13 to each pin; this adds up to 46 or 48; which are exactly the ascii values we want
>>[+++++++++++++>>>>]
we happen to have made a 14; turn it into a 10 for a newline
<<<<----
we're so close now; i can taste it
we have a list of 10 pins; each one with the ascii value that needs to be written
we have 32 everywhere because we'll need spaces
we even have a newline
the only problem now is that our list looks like this:
;;;;;;;;;;;;;;;;;;;;;;;;
;;1 2 3 4 5 6 7 8 9 10;;
;;;;;;;;;;;;;;;;;;;;;;;;
and we need to print in this order:
;;;;;;;;;;;;;;;;;;;;;;;;
;;7 8 9 10 4 5 6 2 3 1;;
;;;;;;;;;;;;;;;;;;;;;;;;
it's a pretty simple fix
once we print a pin we obviously don't need to remember it any more
so we simply print the last 4 pins on the list; destroying them on the way
then we print the last 3; which have become the ones we want
then two; then one
<+++[<<+<<[<<+<<]+[>>>>]<<<<-]<<<<[-<<<<]
print pins 7 8 9 10
>[.,>>]
print pins 4 5 6
<<<<<[<<<<]<++++++++++<<.<+<<+<<+<<+<<+<[.,>>]
print pins 3 2
<<<<<[<<]>++++++++++<+<<+<<+<..<+<[.,>>]
print the final pin!! :)
<[<<]<...<<.