अनुवाद को पूर्ववत करें


19

यह साप्ताहिक चुनौती # 2 है। थीम: अनुवाद

एक प्रोग्राम या समारोह है कि में एक कार्यक्रम के लिए स्रोत कोड में लेता लिखें प्रस्तावना में एक समान कार्यक्रम के लिए और आउटपुट कोड Befunge-93 । कार्यक्रम के समतुल्य होने के लिए, इसे किसी भी इनपुट के लिए, प्रोल्यूड प्रोग्राम के समान आउटपुट का उत्पादन करना चाहिए, और यदि केवल और केवल प्रील्यूड प्रोग्राम रुकता है तो रोकें।

इनपुट भाषा: प्रस्तावना

अजगर दुभाषिया:

एक प्रस्तावना कार्यक्रम में कई "आवाज़ें" होती हैं जो एक साथ निर्देशों को निष्पादित करती हैं। प्रत्येक आवाज के निर्देश एक अलग लाइन पर हैं। प्रत्येक आवाज में एक अलग स्टैक होता है, जिसे अनंत राशि के शून्य के साथ आरंभ किया जाता है। निष्पादन सबसे बाएं स्तंभ पर शुरू होता है, और एक कॉलम को दाईं ओर प्रत्येक टिक को आगे बढ़ाता है, सिवाय इसके जब )या (निर्देश प्रभावित होते हैं । अंतिम कॉलम पर पहुंचने पर प्रोग्राम समाप्त हो जाता है।

इस चुनौती के लिए कल्पना को छोड़ें:

Digits 0-9      Push onto the stack a number from 0 to 9. Only single-digit
                    numeric literals can be used.
^               Push onto the stack the top value of the stack of the above 
                    voice.
v               Push onto the stack the top value of the stack of the below 
                    voice.
#               Remove the top value from the stack.
+               Pop the top two integers from the stack and push their sum.
-               Pop the top two integers from the stack, subtract the topmost 
                    from the second, and push the result.
(               If the top of the stack is 0, jump to the column after the 
                    matching `)` after the current column executes.
)               If the top of the stack is not 0, jump to the column after 
                    the matching `(` after the current column executes.
?               Read an integer from STDIN.
!               Pop one value from the stack and print it to STDOUT as an
                    integer.
<space>         No-op

टिप्पणियाँ

  • vऔर ^चक्रीय रूप से कार्य करें, इसलिए vनीचे की आवाज़ ऊपर की आवाज़ के स्टैक तत्व को कॉपी करेगी, और ^नीचे की आवाज़ को नीचे की आवाज़ से कॉपी करेगी। कोरोलरी: एकल-आवाज कार्यक्रम में दोनों vऔर ^स्टैक के शीर्ष को डुप्लिकेट करें।
  • A (और उसका मिलान )विभिन्न रेखाओं पर स्थित हो सकता है। हालांकि , )वसीयत हमेशा उस आवाज के ढेर पर लगेगी, जहां संगत (को रखा गया था, न कि उस स्टैक को जहां )खुद को रखा गया था।
  • एक ही कॉलम में किसी भी अन्य संचालन के पूरा होने से पहले मौजूद मूल्यों ^और vनिर्देशों द्वारा उत्पादित मूल्य संचालित होते हैं।
  • ?और !esolangs.org पर पाए गए विनिर्देश से अलग तरीके से काम करते हैं, इसलिए इस पोस्ट में प्रदान किए गए थोड़ा संशोधित दुभाषिया के साथ परीक्षण करना सुनिश्चित करें।

इनपुट की गारंटी है:

  • कोष्ठक मिलान
  • एक कॉलम में एक से अधिक कोष्ठक नहीं
  • प्रत्येक पंक्ति पर समान वर्ण
  • कम से कम एक लाइन
  • एक से अधिक I / O ( !या ?) निर्देश के साथ कोई कॉलम नहीं
  • प्रत्येक आवाज के निर्देशों के बाद एक लाइनफीड चरित्र
  • ऊपर वर्णित लोगों के अलावा कोई वर्ण नहीं

आउटपुट भाषा: Befunge-93

Befunge एक स्टैक-आधारित भाषा है जिसका प्रोग्राम काउंटर (PC; वर्तमान निर्देश का सूचक) दो-आयामी ग्रिड पर स्वतंत्र रूप से चलता है। यह शीर्ष बाएं कोने में शुरू होता है, दाईं ओर बढ़ते हुए। प्लेफील्ड टॉरॉयडल है, यानी पीसी मूवमेंट दोनों किनारों पर घूमता है। Befunge में एक स्टैक भी होता है जिसे अनंत संख्या में शून्य से आरंभ किया जाता है। Befunge के निम्नलिखित कार्य हैं:

आप Befunge-93 संकलक / दुभाषिया की निम्नलिखित विशेषताओं को मान सकते हैं:

  • पूर्णांक असीमित-सटीक हैं।
  • यह किसी भी आकार के ग्रिड की अनुमति देता है।
  • ग्रिड निर्देशांक (के लिए gऔर p) 0-आधारित हैं।

स्कोरिंग

सबमिशन को रोकने के लिए जो कि बस Befunge में एक Prelude दुभाषिया का उत्पादन करते हैं और इसमें Prelude स्रोत को हार्डकोड करते हैं, लक्ष्य परिणामस्वरूप Befunge स्रोत कोड के आकार को कम करना होगा।

नीचे कई प्रस्ताव कार्यक्रम प्रदान किए गए हैं। आपका अनुवादक इन सभी पर चलाया जाएगा। आपका स्कोर Befunge कार्यक्रमों के आकार का योग है, बशर्ते कि सभी वैध हों।

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

नमूना इनपुट

n-1नीचे प्रिंट करें 0:

?(1-^!)

तार्किक और:

?  (0)  
 ?(0  ) 
    1  !

तार्किक या:

 ?   (0) 
? (0)    
   1  1 !

नॉनगेटिव नंबर के इनपुट (यानी मोडुलो 2) की समता की जाँच करें:

?(1-)   
 ^  v   
 v1-^^-!

इनपुट वर्ग:

 ^    
  ^+ !
?(1-) 

N वें फाइबोनैचि संख्या को प्रिंट करें , जहां n = 00 से n = 1मेल खाती है और 1 से मेल खाती है:

0 v+v!
1   ^ 
?(1-) 

पासवर्ड:

  1) v #  - !
 vv (##^v^+) 
?(#   ^   ## 

गैर-नकारात्मक इनपुट के लिए प्रभाग:

1 (#  1) v #  - 1+)   
     vv (##^v^+)      
?  v-(0 # ^   #       
 ?                    
   1+              1-!

बेशक, आपके कार्यक्रम को सभी मामलों के लिए समान व्यवहार प्रदर्शित करना चाहिए, भले ही नकारात्मक संख्याओं के लिए नमूना कार्यक्रम का व्यवहार निर्दिष्ट न हो।

अंत में, आपके अनुवादक को अनुचित रूप से लंबा नहीं होना चाहिए:

  • यह एक स्टैक एक्सचेंज पोस्ट के अंदर होना चाहिए
  • यह एक सामान्य डेस्कटॉप कंप्यूटर पर 10 मिनट के भीतर नमूना आदानों को संसाधित करना चाहिए।

ध्यान दें कि Prelude या Befunge के लिए एक संख्यात्मक इनपुट को एक वैकल्पिक ऋण चिह्न के रूप में दिया जाता है, जिसके बाद एक या एक से अधिक दशमलव अंक होते हैं, उसके बाद एक नई रेखा। अन्य इनपुट अपरिभाषित व्यवहार है।

आप अपने अनुवादक को किसी भी भाषा में लिख सकते हैं। सबसे कम अनुवाद किए गए Befunge कोड जीतता है।

लीडरबोर्ड

  • Sp3000 : 16430 बाइट्स

मुझे समझ में नहीं आता: "ऊपर की आवाज़ के ढेर पर शीर्ष मूल्य पर पुश करें।" "ऊपर मूल्य ढेर पर पुश: क्या यह हो गया है नहीं की ऊपर आवाज के ढेर।"
डिफेंस

इसमें कहा गया है कि आवाज़ों को एक साथ निष्पादित करें, इसका मतलब यह है कि वे वास्तव में एक अलग धागे पर निष्पादित होते हैं या क्या मैं सभी आवाज़ों (ऊपर से नीचे) और फिर दूसरी आज्ञाओं पर पहले आदेशों को निष्पादित कर सकता हूं।
डेफ

@Deformyer मैंने इसे "on" से "to" में बदल दिया, लेकिन मुझे लगा कि "stack पर शीर्ष मूल्य" गलत नहीं था। एक साथ समानता के लिए, नहीं, आपको वास्तव में उन्हें समानांतर में व्याख्या करने की आवश्यकता नहीं है। यह महत्वपूर्ण है कि वे सभी स्टैक की पिछली स्थिति पर कार्य करते हैं, और किसी दिए गए कॉलम में कोई भी ऑपरेशन उस कॉलम में किसी अन्य ऑपरेशन को प्रभावित नहीं कर सकता है।
मार्टिन एंडर

परीक्षण के कई मामलों का उल्लंघन न करें "एक से अधिक I / O ((?) निर्देश) के साथ कोई कॉलम नहीं?"
फुवजैक्स

@proudhaskeller यह 1एक लूप के अंदर है, इसलिए इसे धक्का नहीं दिया जा सकता है। 0 0 अनंत राशि से आ सकता है जो स्टैक पर शुरू होता है।
feersum

जवाबों:


10

पायथन 3, बाद में स्कोर करेगा

from collections import defaultdict
from functools import lru_cache
import sys

NUMERIC_OUTPUT = True

@lru_cache(maxsize=1024)
def to_befunge_num(n):
    # Convert number to Befunge number, using base 9 encoding (non-optimal,
    # but something simple is good for now)

    assert isinstance(n, int) and n >= 0

    if n == 0:
        return "0"

    digits = []

    while n:
        digits.append(n%9)
        n //= 9

    output = [str(digits.pop())]

    while digits:
        output.append("9*")
        d = digits.pop()

        if d:
            output.append(str(d))
            output.append("+")

    output = "".join(output)

    if output.startswith("19*"):
        return "9" + output[3:]

    return output

def translate(program_str):
    if program_str.count("(") != program_str.count(")"):
        exit("Error: number of opening and closing parentheses do not match")

    program = program_str.splitlines()
    row_len = max(len(row) for row in program)
    program = [row.ljust(row_len) for row in program]
    num_stacks = len(program)


    loop_offset = 3
    stack_len_offset = program_str.count("(")*2 + loop_offset
    stack_offset = stack_len_offset + 1
    output = [[1, ["v"]], [1, [">"]]] # (len, [strings]) for each row
    max_len = 1 # Maximum row length so far

    HEADER_ROW = 0
    MAIN_ROW = 1
    FOOTER_ROW = 2
    # Then stack lengths, then loop rows, then stacks

    # Match closing parens with opening parens
    loop_map = {} # {column: (loop num, stack number to check, is_start)}
    loop_stack = []
    loop_num = 0

    for col in range(row_len):
        col_str = "".join(program[stack][col] for stack in range(num_stacks))

        if col_str.count("(") + col_str.count(")") >= 2:
            exit("Error: more than one parenthesis in a column")

        if "(" in col_str:
            stack_num = col_str.index("(")

            loop_map[col] = (loop_num, stack_num, True)
            loop_stack.append((loop_num, stack_num, False))
            loop_num += 1

        elif ")" in col_str:
            if loop_stack:
                loop_map[col] = loop_stack.pop()

            else:
                exit("Error: mismatched parentheses")


    def pad_max(row):
        nonlocal max_len, output

        while len(output) - 1 < row:
            output.append([0, []])

        if output[row][0] < max_len:
            output[row][1].append(" "*(max_len - output[row][0]))
            output[row][0] = max_len


    def write(string, row):
        nonlocal max_len, output

        output[row][1].append(string)
        output[row][0] += len(string)

        max_len = max(output[row][0], max_len)


    def stack_len(stack, put=False):
        return (to_befunge_num(stack) + # x
                str(stack_len_offset) + # y
                "gp"[put])


    def get(stack, offset=0):
        assert offset in [0, 1] # 1 needed for 2-arity ops

        # Check stack length
        write(stack_len(stack) + "1-"*(offset == 1) + ":0`", MAIN_ROW)

        pad_max(HEADER_ROW)
        pad_max(MAIN_ROW)
        pad_max(FOOTER_ROW)

        write(">" + to_befunge_num(stack + stack_offset) + "g", HEADER_ROW)
        write("|", MAIN_ROW)
        write(">$0", FOOTER_ROW)

        pad_max(HEADER_ROW)
        pad_max(MAIN_ROW)
        pad_max(FOOTER_ROW)

        write("v", HEADER_ROW)
        write(">", MAIN_ROW)
        write("^", FOOTER_ROW)


    def put(stack, value=""):
        put_inst = (value +
                    stack_len(stack) +
                    to_befunge_num(stack + stack_offset) +
                    "p")

        post_insts.append(put_inst)


    def pop(stack):
        put(stack, "0")


    def inc_stack_len(stack):
        post_insts.append(stack_len(stack) + "1+")
        post_insts.append(stack_len(stack, put=True))


    def dec_stack_len(stack):
        post_insts.append(stack_len(stack) + ":0`-") # Ensure nonnegativity
        post_insts.append(stack_len(stack, put=True))


    # Technically not necessary to initialise stack lengths per spec, but it makes it
    # more portable and easier to test against other Befunge interpreters

    for stack in range(num_stacks):
        write("0" + stack_len(stack, put=True), MAIN_ROW)

    for col in range(row_len):
        post_insts_all = []

        loop_start = False
        loop_end = False

        if col in loop_map:
            if loop_map[col][2]:
                loop_start = True
            else:
                loop_end = True

        if loop_start:
            loop_row = loop_offset + 2*loop_map[col][0]
            get(loop_map[col][1])

        elif loop_end:
            get(loop_map[col][1])
            write("!", MAIN_ROW)


        for stack in range(num_stacks-1, -1, -1):
            char = program[stack][col]
            post_insts = [] # Executed after the gets in reverse order, i.e. last added first

            if char in " ()":
                continue

            # Pre-inc, post-dec
            elif char.isdigit():
                inc_stack_len(stack)
                put(stack, char)

            elif char == "?":
                inc_stack_len(stack)
                put(stack, "&")

            elif char == "!":
                get(stack)
                post_insts.append(".91+," if NUMERIC_OUTPUT else ",")
                pop(stack)
                dec_stack_len(stack)

            elif char == "#":
                pop(stack)
                dec_stack_len(stack)

            elif char in "+-":
                get(stack, 1)
                get(stack)
                post_insts.append(char)
                pop(stack) # This one first in case of ! or 1!
                post_insts.append(stack_len(stack) + ":1`-:1\\`+") # Ensure >= 1
                post_insts.append(stack_len(stack, put=True))
                put(stack)                

            elif char in "^v":
                offset = -1 if char == "^" else 1

                get((stack + offset) % num_stacks)
                inc_stack_len(stack)
                put(stack)

            else:
                exit("Error: invalid character " + char)

            post_insts_all.append(post_insts)


        while post_insts_all:
            write("".join(post_insts_all.pop()), MAIN_ROW)

        if loop_start or loop_end:
            loop_row = loop_offset + 2*loop_map[col][0]

            pad_max(HEADER_ROW)
            pad_max(MAIN_ROW)
            pad_max(loop_row)
            pad_max(loop_row + 1)

            write(">v", HEADER_ROW)
            write("|>", MAIN_ROW)

            if loop_start:
                write(" ^", loop_row)
                write(">", loop_row + 1)

            else:
                write("<", loop_row)
                write(" ^", loop_row + 1)


    write("@", MAIN_ROW)
    return "\n".join("".join(row) for row_len, row in output)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        exit("Usage: py -3 prefunge.py <input filename> <output filename>")

    with open(sys.argv[1]) as infile:
        with open(sys.argv[2], "w") as outfile:
            outfile.write(translate(infile.read()))

दौड़ो ऐसे py -3 prefunge.py <input filename> <output filename>

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

सवाल एक Befunge -93 दुभाषिया प्रदान नहीं करता है, तो मैं इस्तेमाल किया यह एक है, जो कल्पना से थोड़ा अलग है। दो प्रमुख अंतर हैं:

  • यदि प्रोग्राम की दी गई पंक्ति में कोई चार मौजूद नहीं है, तो आप उस पंक्ति को नहीं लिख सकते। इसका मतलब है कि अंत में पर्याप्त नई सुर्खियाँ लाने के लिए आपको कई बार एंटर करना होगा । यदि आप NaNआउटपुट में s देखते हैं , तो यह सबसे संभावित कारण है।

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

आउटपुट कार्यक्रमों का मुख्य लेआउट यह है:

v [header row]
> [main row]
  [footer row]
  ---
   |
   | rows for loops (2 per loop)
   |
  ---
  [stack length row]
  ---
   |
   | rows for stack space (1 per voice)
   |
  ---

स्टैक स्पेस प्रोग्राम के बाहर है, इसलिए नईलाइन पहले से दर्ज करें।

मुख्य विचार प्रत्येक आवाज को एक पंक्ति प्रदान करना है जो उसके स्टैक के रूप में कार्य करता है। इन ढेरों को बनाए रखने के लिए, हमारे पास एक विशेष स्टैक लंबाई पंक्ति है जहां प्रत्येक स्टैक की लंबाई पंक्ति के साथ एक सेल में दर्ज की जाती है। यह कार्यक्रम बहुत सारे gईट्स और pईट्स हैं, जैसे प्रक्रिया को प्रिंट करने के लिए:

  • सेल पर जाओ y = stack_row[stack], x = stack_length[stack]
  • प्रदर्शन .91+,, यानी पूर्णांक के रूप में प्रिंट करें फिर एक नई रेखा प्रिंट करें
  • सेल को उपरोक्त कोर्ड्स पर 0 से बदलें (पॉपिंग अनुकरण करने के लिए)
  • घटती stack_length[stack]

किसी स्तंभ का एक साथ मूल्यांकन करने के लिए, सभी आवश्यक कोशिकाओं को पढ़ा जाता है और किसी भी कोशिकाओं को लिखे जाने से पहले उनके मूल्यों को स्टैक पर रखा जाता है (जैसे मुद्रण उदाहरण के लिए, पहले और दूसरे चरणों के बीच अधिक निर्देश हो सकते हैं)।

`, जो अधिक से अधिक है, यह सुनिश्चित करने के लिए नियोजित किया जाता है कि स्टैक की लंबाई कभी भी नकारात्मक न हो, और स्टैक खाली होने पर 0s को धक्का देने के लिए। यह वह जगह है जहां स्पष्ट रूप से दिखाई देने वाली शाखाएं आती हैं, लेकिन मुझे एक विचार मिला है कि मैं शाखा को हटा दूंगा, जिसमें पहली और तीसरी पंक्तियों से व्हॉट्सएप का एक बड़ा सौदा हटा देना चाहिए।

छोरों के लिए, क्योंकि Prelude loops दोनों तरह से कूद सकते हैं, हम एक कॉन्फ़िगरेशन में दो पंक्तियों प्रति लूप का उपयोग करते हैं:

       >v                     >v
(cond) |>  (program)  (cond) !|>

        ^                     <
       >                       ^

ये लूप वर्तमान में अधिकांश बाइट्स बनाते हैं, लेकिन आसानी से कोडबॉक्स में रखने से इन्हें आसानी से नीचे उतारा जा सकता है p, जिसकी मुझे योजना है कि मैं खुश हूं कि अनुवादक सही तरीके से काम कर रहा है।

यहां कुछ उदाहरण आउटपुट के लिए दिए गए हैं ?(1-^!), अर्थात n-1नीचे प्रिंट करें 0:

v                        >6gv>v                      >6gv      >6gv                                 >6gv                   >6gv                           >6gv >v
>005p05g1+05p&05g6p05g:0`|  >|>05g1+05p105g6p05g1-:0`|  >05g:0`|  >-005g6p05g:1`-:1\`+05p05g6p05g:0`|  >05g1+05p05g6p05g:0`|  >.91+,005g6p05g:0`-05p05g:0`|  >!|>@
                         >$0^                        >$0^      >$0^                                 >$0^                   >$0^                           >$0^
                              ^                                                                                                                                <
                             >                                                                                                                                  ^

वर्ग-इनपुट:

v                                >8gv      >8gv             >v      >6gv                                   >8gv      >8gv        >7gv      >7gv                                                            >8gv >v      >7gv
>005p015p025p25g1+25p&25g8p25g:0`|  >25g:0`|  >05g1+05p05g6p|>05g:0`|  >15g1+15p15g7p25g1+25p125g8p25g1-:0`|  >25g:0`|  >15g1-:0`|  >15g:0`|  >+015g7p15g:1`-:1\`+15p15g7p-025g8p25g:1`-:1\`+25p25g8p25g:0`|  >!|>15g:0`|  >.91+,015g7p15g:0`-15p@
                                 >$0^      >$0^                     >$0^                                   >$0^      >$0^        >$0^      >$0^                                                            >$0^         >$0^
                                                             ^                                                                                                                                                  <
                                                            >                                                                                                                                                    ^

प्रभाग (छोटे इनपुट अनुशंसित हैं):

v                                                                          >91+gv>v      >94+gv                                                         >95+gv      >95+gv        >93+gv      >93+gv                                                                    >93+gv      >93+gv               >v      >93+gv                                                     >93+gv >v      >92+gv                  >v      >92+gv                                       >92+gv                                       >91+gv                                       >93+gv                     >91+gv                       >92+gv      >92+gv        >91+gv      >91+gv                                                                                      >92+gv >v                        >91+gv      >91+gv                                     >91+gv >v                        >95+gv      >95+gv                                     >95+gv
>009p019p029p039p049p09g1+09p109g91+p29g1+29p&29g93+p39g1+39p&39g94+p09g:0`|    >|>39g:0`|    >009g91+p09g:0`-09p29g1+29p29g93+p49g1+49p149g95+p49g1-:0`|    >49g:0`|    >29g1-:0`|    >29g:0`|    >-029g93+p29g:1`-:1\`+29p29g93+p+049g95+p49g:1`-:1\`+49p49g95+p29g:0`|    >29g:0`|    >19g1+19p19g92+p|>29g:0`|    >09g1+09p109g91+p19g1+19p19g92+p29g1+29p029g93+p29g:0`|    >!|>19g:0`|    >029g93+p29g:0`-29p|>19g:0`|    >09g1+09p09g91+p019g92+p19g:0`-19p19g:0`|    >019g92+p19g:0`-19p29g1+29p29g93+p09g:0`|    >009g91+p09g:0`-09p19g1+19p19g92+p29g:0`|    >19g1+19p19g92+p09g:0`|    >19g1+19p19g92+p19g1-:0`|    >19g:0`|    >09g1-:0`|    >09g:0`|    >-009g91+p09g:1`-:1\`+09p09g91+p+019g92+p19g:1`-:1\`+19p19g92+p029g93+p29g:0`-29p19g:0`|    >!|>09g1+09p109g91+p09g1-:0`|    >09g:0`|    >+009g91+p09g:1`-:1\`+09p09g91+p09g:0`|    >!|>49g1+49p149g95+p49g1-:0`|    >49g:0`|    >-049g95+p49g:1`-:1\`+49p49g95+p49g:0`|    >.91+,049g95+p49g:0`-49p@
                                                                           >$0  ^        >$0  ^                                                         >$0  ^      >$0  ^        >$0  ^      >$0  ^                                                                    >$0  ^      >$0  ^                       >$0  ^                                                     >$0  ^         >$0  ^                          >$0  ^                                       >$0  ^                                       >$0  ^                                       >$0  ^                     >$0  ^                       >$0  ^      >$0  ^        >$0  ^      >$0  ^                                                                                      >$0  ^                           >$0  ^      >$0  ^                                     >$0  ^                           >$0  ^      >$0  ^                                     >$0  ^
                                                                                  ^                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^
                                                                                                                                                                                                                                                                                                          ^                                                                        <
                                                                                                                                                                                                                                                                                                         >                                                                          ^
                                                                                                                                                                                                                                                                                                                                                                                                                    ^                                                                                                                                                                                                                                                                                                                                              <
                                                                                                                                                                                                                                                                                                                                                                                                                   >                                                                                                                                                                                                                                                                                                                                                ^

वहाँ भी अन्य छोटे अनुकूलन कि मन में, जगह की तरह आते हैं का एक समूह है 07p07gके साथ :07pहै, लेकिन मैं एक समय में इस एक कदम ले रहा हूँ :)


इसलिए। बहुत। नि: शुल्क। समय।
ऑप्टिमाइज़र

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