Quat। काफी + बिल्ली

Question

एक क्वाट एक क्वीन और लोकप्रिय एसोलंग बिल्ली कार्यक्रम का एक संयोजन है ।

चुनौती

एक मानक बिल्ली कार्यक्रम लिखना चुनौती है। उपयोगकर्ता इनपुट जो भी हो, प्रोग्राम इनपुट को stdout में प्रतिध्वनित करेगा।
हालांकि, जब इनपुट की लंबाई 0 और 4 के एक से अधिक है, तो प्रोग्राम को अपने स्वयं के स्रोत कोड का उत्पादन करना चाहिए। क्वाट पुर्तगाली क्वात्रो से आता है , जिसका अनुवाद 'चार' में होता है।

नियम

• मानक खामियां लागू होती हैं
• आप फ़ाइल से स्रोत कोड नहीं पढ़ सकते हैं
• एक खाली इनपुट को एक खाली आउटपुट का उत्पादन करना चाहिए

बोनस

यदि आपकी इनपुट लंबाई 4 से अधिक है, तो आप क्विन length/4बार प्रिंट करके 25% बोनस कमा सकते हैं । एक और 5% बोनस यदि आप रिक्त स्थान द्वारा आउटपुट को अलग करते हैं (कोई अनुगामी स्थान की अनुमति नहीं है)।

परीक्षण के मामलों

निम्नलिखित परीक्षण मामले कार्यक्रम के लिए लागू होते हैं in%4=0?cat:self(वास्तविक भाषा नहीं)।

<empty input> -> <empty output>
input -> input
1234 -> in%4=0?cat:self
12345678 -> in%4=0?cat:self 0% बोनस
12345678 -> in%4=0?cat:selfin%4=0?cat:self 25% बोनस
12345678 -> in%4=0?cat:self in%4=0?cat:self 30% बोनस

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स में सबसे छोटा कोड जीतता है।

Comments

क्या इनपुट में कई लाइनें हो सकती हैं?

— लीजनमोनमाल 978

@ LegionMammal978 ofcourse, \n1 पंक्ति के इनपुट के लिए नई लाइन कैरेक्टर होने दें

— बैसड्रुप कम्बरबुबवबूब

ठीक है, यह सिर्फ मेरी भाषा में इनपुट को जटिल करता है, जिसे एक बार में एक पंक्ति में पढ़ा जाना चाहिए।

— लीजनमोनमल 978

क्या द्वारों के लिए बिल्ट-इन की अनुमति है? (देखें: गंभीरता से )

— Addison Crump

@FlagAsSpam मुझे कोई आपत्ति नहीं है, लेकिन मुझे लगता है कि यहाँ एक मेटा-पोस्ट अधिक उपयुक्त है।

— बैसड्रॉप कंबरवुबवबूब

Answer 1

सीजाम, 23 * 0.75 = 17.25 बाइट्स

मानक सामान्यीकृत क्वीन ...

{`"_~"+q:Q,4md@@*Q\?}_~

या

{`"_~"+q_,4md@@]:\*?}_~

इसका परीक्षण यहां करें।

व्याख्या

{`"_~"+  e# Generalised quine framework. Leaves the source code on the stack.
  q:Q    e# Read input and store it in Q.
  ,      e# Get its length.
  4md    e# Divmod 4.
  @      e# Pull up the source code.
  @      e# Pull up the div.
  *      e# Repeat the source code that many times.
  Q\     e# Push the input and swap it below the repeated source.
  ?      e# Pick the right output based on the modulo.
}_~

अन्य संस्करण स्टैक-रोटेशन ट्रिक का उपयोग करके एक चर के उपयोग से बचा जाता है ]:\।

Answer 2

गंभीरता से, 8 9 बाइट्स

Q,ó;l4@%I

इसे ऑनलाइन आज़माएं

(मारो खाली इनपुट का परीक्षण करने के लिए इनपुट बॉक्स में एक बार दर्ज करें।)

पहला बोनस 12 बाइट्स (16 * .75) में किया जा सकता है:

Q,ó;l;4@\(*)4@%I

स्पष्टीकरण:

Q                   Push program source to stack
 ,ó                 Push input string, and terminate if it's empty
   ;l               Push length of input
     4@%            Take the length mod 4.
        I           Pick the next stack element (input) if nonzero,
                    else the next next (program source)

चूंकि कुछ लोग सीरियसली क्विनिंग बिल्ट-इन का उपयोग पसंद नहीं करते हैं, मैं इस 22 बाइट संस्करण को प्रदान करता हूं जो Qसंदर्भ के लिए उपयोग नहीं करता है :

`è";ƒ"(+,ó;l4@%I`;ƒ

यदि आप उन लोगों में से एक हैं, तो इस निश्चित संस्करण पर विचार करें (अभी के लिए) और फिर quines में बिल्ट-इन के उपयोग के बारे में एक मेटा थ्रेड शुरू करें।

Comments

एक क्वीन चुनौती में, मेरा मानना ​​है कि आप प्रोग्राम स्रोत को नहीं पढ़ सकते हैं।

— कॉनर ओ'ब्रायन

निर्देश कहते हैं कि आप इसे किसी फ़ाइल से नहीं पढ़ सकते हैं। क्यू एक अंतर्निहित कमांड है जो स्रोत को स्टैक के खाली होने पर धकेलता है। मुझे लगता है कि यह "भाषा की ताकत के लिए खेल" के तहत आता है

— क्विंटोपिया

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

— मार्टिन एंडर

तकनीकी रूप से - रैम इंटरप्रेटर द्वारा संग्रहित है, क्यू एक फ़ाइल से प्रोग्राम के स्रोत को नहीं पढ़ता है। चूंकि नियम विशेष रूप से "एक फ़ाइल से" बताता है, यह मान्य होना चाहिए।

— मेघो

मुझे वास्तव में समझ में नहीं आता है कि यह अंतर्निहित क्वीन ऑपरेटरों के साथ किसी भी पिछली भाषा की तुलना में अधिक लोकप्रिय क्यों है, जिसमें HQ9 + और इस्माईल का मारियो हॉल्फ शामिल हैं। लेकिन किसी भी स्थिति में आपका प्रोग्राम खाली इनपुट के लिए सही तरीके से काम नहीं करता है।

— मार्टिन एंडर

Answer 3

पायथ, 33 * .75 = 24.75

?%lz4z*/lz4jN*2]"?%lz4z*/lz4jN*2]

परीक्षण सूट

शामिल होने का उपयोग करते हुए मानक पायथ क्वाइन यह केवल ऑनलाइन दुभाषिया पर एक सच्ची बात है, जो एक अंतिम अनुगामी न्यूलाइन नहीं जोड़ता है।

39 * .7 = 27.3 के स्कोर में अंतिम बोनस प्राप्त होता है:

?%lz4zjd*/lz4]jN*2]"?%lz4zjd*/lz4]jN*2]

Answer 4

विटसी , 18 17 बाइट्स

इतना करीब । Yus। मैं अब गैर-निर्मित क्वीनरों के बीच जीत रहा हूं! गंभीरता से चमकता है

zl4M([&'rd3*8\}]Z
z                 Grab ALL THE INPUT! :D
 l4M([         ]  If the input is a multiple of four, do the stuff in brackets.
      &           Generate a new stack and move to it.
       'rd3*      Standard quine.
            8\}   Push the bottom 8 items of the stack to the top.
                Z Output the current stack.

मुझे बोनस के बाद जाने का कोई कारण नहीं है - वे बहुत अधिक बाइट्स पर चक देंगे।

चीटिंग का वर्जन, 12 बाइट्स:

zl4M([&iG`]Z
zl4M([&   ]Z  Same as above.
       i      Push -1.
        G     Get the name of the file with this index of use (-1 is self)
         `    Read the file with the given name and push its contents to the stack.

Comments

G` शांत है! यह एक साधारण Qकमांड की तुलना में अधिक वैध लगता है ।

— कॉनर ओ'ब्रायन

मुझे कम कानूनी लगता है, यह देखते हुए कि इसे फ़ाइल I / O की आवश्यकता कैसे है।

— क्विंटोपिया

@ C @O'Bʀɪᴇɴ क्विंटोपिया सही है - क्योंकि मुझे फ़ाइल संदर्भ मिलता है इसका मतलब यह नहीं है कि यह किसी भी बेहतर है। : पी

— एडिसन क्रम्प

Answer 5

एमएसीएस लिस्प (323 * 0.75 = 242.25)

((lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s))))))) (quote (lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s)))))))))

यह अपने आप को इनपुट के रूप में स्रोत कोड देने के लिए लिस्प के उद्धृत मैकेनिक का उपयोग करता है।

पुराना धोखा संस्करण

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args))(set'b(buffer-string))(set's(read-string""))(set'l(string-bytes s))(if(>(% l 4)0)(message s)(dotimes(v(/ l 4))(message"%s"b)))

Ungolfed:

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args)) ; open self
(set'b(buffer-string))               ; read own code to string
(set's(read-string""))               ; read input
(set'l(string-bytes s))              ; length of input
(if(>(% l 4)0)                       ; l % 4 > 0 ?
    (message s)                      ; output input
  (dotimes(v(/ l 4))                 ; (implicit else) repeat l/4 times
    (message"%s"b)))                 ; output own code

Comments

क्या यह नियम का उल्लंघन नहीं करता है कि "आप फ़ाइल से स्रोत कोड नहीं पढ़ सकते हैं"?

— ThisSuitIsBlackNot

@ThisSuitIsBlackNot आप सही कह रहे हैं ... लगता है कि मुझे एलिसा में नॉन-चीटिंग क्वीन के लिए देखना होगा

— लॉर्ड

Answer 6

जावास्क्रिप्ट, 57 56 72 बाइट्स * 0.75 = 54

एक बाइट बचत के लिए @ नील को धन्यवाद!

(f=_=>alert(!(p=prompt())||(l=p.length)%4?p:`(f=${f})()`.repeat(l/4)))()

सबसे छोटा समाधान जो मुझे मिल सकता था, वह बहुत सीधा था।

तो, यहाँ कुछ बोनस (अधिक दिलचस्प) समाधान है:

जावास्क्रिप्ट, 82 81 बाइट्स * 0.75 = 60.75

f=_=>{try{p=prompt();a=`f=${f};f()`.repeat(p.length/4)}catch(e){a=p}alert(a)};f()

यह एक repeatगैर-पूर्णांक पारित होने पर अपवाद को फेंकने की कार्यक्षमता का हनन करता है।

जावास्क्रिप्ट, 83 बाइट्स * 0.70 = 58.1

(f=_=>alert((a=(p=prompt()).split(/.{4}/)).pop()?p:a.fill(`(f=${f})()`).join` `))()

यह आखिरी निश्चित रूप से मेरा पसंदीदा है, रेगेक्स का उपयोग करके हर चार वर्णों पर इनपुट को विभाजित करना /.{4}/। यदि स्ट्रिंग के अंत में कोई अक्षर बचे हैं, तो हम pop4 से विभाज्य नहीं हैं, इसलिए इनपुट को सचेत करें। अन्यथा, popसरणी की लंबाई एक से कम हो जाती है, इसलिए इस बिंदु पर सरणी की लंबाई इनपुट लंबाई / 4 के बराबर होती है। इस मामले में, fillयह केवल क्वीन और joinरिक्त स्थान के साथ है।

Comments

मुझे लगता है कि आप हालत को भांप कर एक बाइट बचा सकते हैं; करने के लिए बदलने के &&लिए ||, एक !से पहले डाल दिया है (p=prompt()), को हटाने <1और pअंदर के पर होने के लिए कदम ?:।

— नील

Answer 7

पर्ल, 68 65 * 0.75 = 48.75 बाइट्स

perl -e'$_=q{print+($l=($~=<>)=~y///c)%4?$~:"\$_=q{$_};eval"x($l/4)};eval'

ऑनलाइन टेस्ट सूट यहाँ देखें ।

टूटा

perl -e'
    $_=q{                      # store source code in $_
        print+(
            $l=($~=<>)=~ y///c # read STDIN into $~, assign length to $l
        )%4 ?                  # if length is a multiple of 4
             $~ :              # print $~
             "\$_=q{$_};eval"  # otherwise, print source code
             x($l/4)           # length/4 times
    };
    eval'                      # eval $_ to execute its contents

Answer 8

गणितज्ञ, 229 बाइट्स

($RecursionLimit = Infinity; WriteString[$Output, If[Mod[StringLength[a = (If[(a = InputString[]) === EndOfFile, "", StringJoin["\n", a, #0[]]] & )[]], 4] == 1, ToString[#0, InputForm][], If[a == "", "", StringDrop[a, 1]]]]) & []

व्हाट्सएप के सभी InputFormप्रोग्राम अपने वास्तविक कोड से मेल खाने वाले प्रोग्राम के लिए हैं।

Answer 9

जावास्क्रिप्ट ईएस 6, 45 बाइट्स

$=(_=prompt())=>_.length%4?_:`$=${$};$()`;$()

मेरे 21-बाइट ब्लिंग क्वीन का विस्तार। आशा है कि मिश्रण promptऔर फ़ंक्शन आउटपुट की अनुमति है।

Answer 10

जावास्क्रिप्ट, 33 बाइट्स

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(l/4)

• +44 बाइट्स
• -25% बोनस

अन्य उपाय:

44 36 बाइट्स

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(!!l)

f=(i,l=i.length)=>l%4?i:l?("f="+f):i

38.5 बाइट्स

f=(i,l=i.length)=>l%4?i:Array(l/4).fill("f="+f).join` `

• +55 बाइट्स
• -25% बोनस
• -5% बोनस