क्या आप मेटा क्वाइन कर सकते हैं?

Question

अन्य क्विन पज़ल्स (अधिक विशेष रूप से, यह एक ) के समान, एक प्रोग्राम लिखें जो स्वयं के लिए स्रोत का निर्माण करता है।

यहां नया मोड़ है: उत्पादित कोड स्रोत के समान नहीं होना चाहिए । बल्कि, यह एक अलग प्रोग्राम को आउटपुट करना चाहिए जो पहले बनाएगा।

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

---

नियम

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

---

स्कोरिंग

आपका अंतिम स्कोर आपके सभी कार्यक्रमों की औसत लंबाई होगी, जो कार्यक्रमों की संख्या से विभाजित होगा।

उदाहरण 1:

A (B का स्रोत) = 50 वर्ण
B (A का स्रोत) = 75 वर्ण
अंतिम स्कोर = 31.25

उदाहरण 2:

A (B का स्रोत) = 50 वर्ण
B (C ​​का स्रोत) = 75 वर्ण
C (A का स्रोत) = 100 वर्ण
अंतिम स्कोर = 25

Comments

मैं मेटा क्वीन एक बार।

— मेलमोकब

@ ममलमोक हर हर; ;-)

— गफ़ी

यह वास्तव में इस क्वीन चुनौती का सिर्फ एक सामान्य संस्करण है , और वहां दिए गए उत्तर यहां भी जीतेंगे।

— बंद हो गया

@leftractionabout, वाक्य-विन्यास के अंतर की आवश्यकता एक 'घूर्णन क्वीन' को अमान्य कर देती है, इसलिए यह अधिक सामान्य नहीं है।

— बूथबी

कभी मेटा क्वीन मुझे पसंद नहीं थी।

— स्टैक ट्रेसर

Answer 1

अजगर, 0 (सीमा (68 + 3 n ) / (16 ⁿ ))

यदि दो सार वाक्यविन्यास पेड़ अलग-अलग होते हैं, तो वे अलग-अलग होते हैं,

r='r=%r;n=(0x%XL+1)%%0x10...0L;print r%%(r,n)';n=(0xF...FL+1)%0x10...0L;print r%(r,n)

सबसे अधिक 68 + 3 ^एन में लंबाई के 16 ^एन कार्यक्रम हैं, जिससे एसिम्प्टोटिक स्कोर 0 है।

यदि आप परिवर्तनशील संरचना वाले कार्यक्रम चाहते हैं, तो हम n बिट्स पर एक बाइनरी योजक लागू कर सकते हैं । यहाँ, लंबाई O ( n ² ) के 2 ^एन कार्यक्रम हैं । गिरा हुआ सा होने के कारण एक चक्र में चला जाता है।

s="""
print 's='+'"'+'"'+'"'+s+'"'+'"'+'"'
n=lambda m:reduce(lambda (s,c),y:(s+(c^y,),c&y),m,((),1))[0]
print s[:112]
t=n(t)
print "t=(%s,)+(0,)*%s"%(t[0],len(t)-1)
for i in range(len(t)-1):
    print i*' '+'for i in range(2):'
    print ' '+i*' '+['pass','t=n(t)'][t[i+1]]
print s[113:-1]
"""

print 's='+'"'+'"'+'"'+s+'"'+'"'+'"'
n=lambda m:reduce(lambda (s,c),y:(s+(c^y,),c&y),m,((),1))[0]
print s[:112]
t=(0,)+(0,)*10
for i in range(2):
 t=n(t)
 for i in range(2):
  t=n(t)
  for i in range(2):
   t=n(t)
   for i in range(2):
    t=n(t)
    for i in range(2):
     pass
     for i in range(2):
      t=n(t)
      for i in range(2):
       pass
       for i in range(2):
        pass
        for i in range(2):
         pass
         for i in range(2):
          t=n(t)
t=n(t)
print "t=(%s,)+(0,)*%s"%(t[0],len(t)-1)
for i in range(len(t)-1):
    print i*' '+'for i in range(2):'
    print ' '+i*' '+['pass','t=n(t)'][t[i+1]]
print s[113:-1]

Comments

क्या मैं भ्रमित हो सकता हूँ? ऐसा लगता है कि आउटपुट स्रोत के समान है (इस चुनौती का उद्देश्य नहीं)?

— गफ्फि

नेस्टेड ब्लॉक में देखें। सभी 2 ^ n संयोजनों में और वापस passबदल जाएगा t=n(t)।

— बूथबी

मैं अब वही देखता हूं। आपने मुझे सब दोहराव के साथ भ्रमित कर दिया!

— गफी

किसी कारण से, मुझे छोटे स्कोर के साथ बहुत लंबे गोल्फ समाधान पसंद हैं।

— बूथबी

वाह, आप पूरी तरह से स्वामित्व! बहुत अच्छा।

— क्लाउडी मारू

Answer 2

पर्ल, स्कोर 110.25

मुझे मानना ​​पड़ेगा, मैं बहुत अच्छा नहीं हूँ। मैं 100% निश्चित हूं कि सुधार की गुंजाइश है। समाधान नीचे दिए गए तत्व समाधान के एक ही सिद्धांत पर आधारित है।

पहला कार्यक्रम 264 वर्णों का है।

$s='$a=chr(39);print"\$s=$a$s$a;";$s=reverse$s;for(1..87){chop$s}$s=reverse$s;print$s;$f++;if($f==0){$a=chr(39);print"\$s=$a$s$a;$s"}';$a=chr(39);print"\$s=$a$s$a;";$s=reverse$s;for(1..87){chop$s}$s=reverse$s;print$s;$f++;if($f==0){$a=chr(39);print"\$s=$a$s$a;$s"}

दूसरा कार्यक्रम 177 वर्णों का है।

$s='$a=chr(39);print"\$s=$a$s$a;";$s=reverse$s;for(1..87){chop$s}$s=reverse$s;print$s;$f++;if($f==0){$a=chr(39);print"\$s=$a$s$a;$s"}';if($f==0){$a=chr(39);print"\$s=$a$s$a;$s"}

मैं इस प्रविष्टि के लिए एएसटी (और तत्व प्रविष्टि) पर काम कर रहा हूं।

---

एलिमेंट , 47.25 का स्कोर

पहला कार्यक्रम 105 वर्णों का है।

\ \3\:\$\'\[\\\\\`\(\`\]\#\2\1\'\[\(\#\]\`\ \3\:\$\'\[\\\\\`\(\`\]\#\` 3:$'[\\`(`]#21'[(#]` 3:$'[\\`(`]#`

दूसरा कार्यक्रम 84 वर्णों का है।

\ \3\:\$\'\[\\\\\`\(\`\]\#\2\1\'\[\(\#\]\`\ \3\:\$\'\[\\\\\`\(\`\]\#\` 3:$'[\\`(`]#`

मुझे यकीन है कि सुधार के लिए बहुत जगह है।

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

दूसरा कार्यक्रम एक ही स्ट्रिंग है जिसके बाद भाग बी। भाग बी एक साधारण क्वीन से आधारित है; यह एक तार को प्रिंट करता है, जो इसके एक बचते हुए संस्करण से पहले होता है। इसका मतलब यह स्ट्रिंग को प्रिंट करता है, और दोनों भागों ए और बी।

Comments

मुझे लगता है कि यह निश्चित रूप से, किसी भी संदेह से परे, एक प्रोग्रामिंग भाषा के रूप में तत्व की वैधता साबित करता है। इसका उपयोग करना इतना आसान है कि मैं, इतना अनुभवहीन कि मैं केवल एलीमेंट के लिए एक पूर्ण दुभाषिया लिखने में कामयाब रहा, 7,000,000,000 लोगों के इस पूरे ग्रह पर किसी भी अन्य व्यक्ति के समक्ष इस प्रश्न का उत्तर देने में सक्षम है। तत्व का "एक चरित्र, एक कार्य, हर समय" प्रतिमान का अर्थ है कि सभी कोड पूरी तरह से अस्पष्ट हैं। भाषा बहुमुखी है: सिवाय []{}एक वाक्य रचना त्रुटि के बिना पूरे कार्यक्रम में किसी भी आदेश को कहीं भी रखा जा सकता है। ये बिलकुल सही है।

— PhiNotPi

थोड़ा पक्षपाती, हम हैं? ;-)

— गफ़ी

Answer 3

VBA: (251 + 216) / 2/2 = 116.75

251

Sub a()
r=vbCrLf:c="If b.Lines(4, 4) = c Then"&r &"b.InsertLines 8, d"&r &"b.DeleteLines 4, 4"&r &"End If":d="b.InsertLines 6, c"&r &"b.DeleteLines 4, 2"
Set b=Modules("Q")
If b.Lines(4, 4) = c Then
b.InsertLines 8, d
b.DeleteLines 4, 4
End If
End Sub

216

Sub a()
r=vbCrLf:c="If b.Lines(4, 4) = c Then"&r &"b.InsertLines 8, d"&r &"b.DeleteLines 4, 4"&r &"End If":d="b.InsertLines 6, c"&r &"b.DeleteLines 4, 2"
Set b=Modules("Q")
b.InsertLines 6,c
b.DeleteLines 4,2
End Sub

यह ऑब्जेक्ट का उपयोग करने के लिए MSAccess में चलाया जाता है Module। मॉड्यूल को "Q"गोल्फिंग के लिए नामित किया गया है। सिंटैक्स में अंतर If ... Thenछोटे संस्करण से गायब होने से आता है ।

Comments

आप सबसे अधिक संभावना बदल vbCrLFसकते हैंvbCr

— टेलर स्कॉट

Answer 4

C ++, 0.734194 का स्कोर

निम्न स्रोत कोड कंसोल में मेटा 999 के ऑर्डर को प्रिंट करता है (नीचे स्पष्टीकरण):

#define X 1*(1+1)
#include<iostream>
#include<vector>
#define Q(S)auto q=#S;S
Q( \
  main() \
  { \
      using namespace std; \
      cout<<"#define X 1"; \
      int x=X==2?1000:X-1; \
      vector<int> factors; \
      for ( int p = 2; p <= x; ++p) \
      { \
        while ( x % p == 0 ) \
        { \
          factors.push_back( p ); \
          x /= p; \
        } \
      } \
      for ( int factor : factors ) \
      { \
        cout<<"*(1"; \
        for ( int i=1;i<factor;++i) \
          cout<<"+1"; \
        cout<<")"; \
      } \
      cout<<"\n#include<iostream>\n#include<vector>\n#define Q(S)auto q=#S;S\nQ("<<q<<")"; \
  })

एकमात्र ऐसी रेखा है जो पहली पंक्ति है। X1000, 999, 998, ..., 3, 2 का मान होगा और फिर यह फिर से शुरू होगा। हालांकि, हर बार अलग-अलग वाक्यविन्यास पेड़ प्राप्त करने के लिए, Xइसके प्रमुख कारक के रूप में प्रतिनिधित्व किया जाता है, जहां हर प्राइम को 1s के योग के रूप में लिखा जाता है । एएसटी अलग-अलग हैं, क्योंकि पूर्णांक का मुख्य कारक हर मूल्य के लिए अलग है।

कार्यक्रम खुद ही प्रिंट करेगा, सिवाय इसके कि पहली पंक्ति को बदल दिया गया है और बैकस्लैश, लाइन ब्रेक और इंडेंटेशन जो भीतर हैं Q(...)उन्हें हटा दिया जाएगा।

निम्नलिखित कार्यक्रम मेरे उत्तर के स्कोर की गणना करता है:

#include <iostream>

const int n = 1000;

int getProgramLength( int n )
{
  int sum = 442;
  for ( int p = 2; p*p <= n; ++p )
  {
    while ( n % p == 0 )
    {
      sum += 2 * ( 1 + p );
      n /= p;
    }
  }
  if ( n > 1 )
    sum += 2 * ( 1 + n );
  return sum;
}

int main()
{
  int sum = 0;
  for ( int i = 2; i <= n; ++i )
    sum += getProgramLength( i );
  std::cout << (double)sum/(n-1)/(n-1) << '\n';
}

इसने 0.734194 कंसोल को मुद्रित किया। जाहिर है, 1000 को बड़े पूर्णांकों द्वारा प्रतिस्थापित किया जा सकता है और स्कोर इसकी सीमा के रूप में 0 पर पहुंच जाएगा। गणितीय प्रमाण में रीमैन का जेटा फ़ंक्शन शामिल है जो कुछ हद तक जटिल है। मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ता हूं। ;)

Answer 5

जावास्क्रिप्ट, 84.5 64 61

दो कार्यक्रम, दोनों की लंबाई 169 128 122।

(function c(){alert(/*
2/*/1/**/);return ('('+c+')()').replace(/\/([/\*])/,function(m,a){return a=='*'?'/\/':'/\*'});
})()

इससे पहले कि मैंने इसे देखा, आपके आनंद के लिए:

(function c() {
    var r = /\/([/\*])/;
    var f = function(m, a) { return a === '*' ? '/\/' : '/\*' };
    var p = '(' + c + ')();';
    p = p.replace(r, f);
    /* This is just a comment!
    console.log('Quine, part two!'); /*/
    console.log('Quine, part one!'); /**/
    return p;
})();

नया प्रोग्राम लौटाता है और वर्तमान भाग को आउटपुट करता है! मैं शायद इसे फंक्शन रेगेक्स के बिना छोटा बना सकता था, लेकिन ... मैं नहीं चाहता।

Comments

नहीं, वे क्रमिक रूप से अलग हैं। एक बार जब आप newlines जोड़ते हैं, तो यह है।

— Ry-

Answer 6

जे - (24 + 30) / 2/2 = 13.5 पीटी

ध्यान दें कि J में तार बैकस्लैश-एस्केप नहीं हैं, लेकिन कोट-एस्केप ए ला पास्कल 'I can''t breathe!':।

30$(,5#{.)'''30$(,5#{.)'         NB. program 1, 24 char
'30$(,5#{.)''''''30$(,5#{.)'''   NB. program 2, 30 char

प्रोग्राम 1 में एएसटी noun verb hook nounऔर प्रोग्राम 2 में एएसटी है noun। प्रोग्राम 2 प्रोग्राम 1 का एक उद्धृत संस्करण है, जो बस चलने पर प्रोग्राम 1 को वापस कर देगा, इसलिए इस विधि को तीन प्रतियों तक आसानी से नहीं बढ़ाया जा सकता है: पी।

कार्यक्रम 1 स्रोत के कोड भाग की एक प्रति लेकर, एक उद्धरण के साथ आगे की ओर, और अंत में ( (,5#{.)) में उन उद्धरणों में से पांच को जोड़कर संचालित होता है । फिर, यह इस 16-वर्ण स्ट्रिंग से 30 वर्ण लेता है, जो परिणाम के रूप में बिल्कुल प्रोग्राम 2 देता है।