तीन-तीन-तीन!

66

एक प्रोग्राम लिखें जो एक आउटपुट का उत्पादन करता है जैसे:

  1. कम से कम तीन अलग-अलग वर्ण दिखाई देते हैं।
  2. प्रत्येक वर्ण की घटनाओं की संख्या 3 की एक बहु है।

उदाहरण के लिए, A TEA AT TEEएक वैध उत्पादन के बाद से 4 अलग पात्रों में से प्रत्येक, है A, E, Tऔर (space), तब होता है 3 बार।

बेशक, संख्या 3 के बारे में एक चुनौती के लिए तीसरी आवश्यकता है। इसलिए:

  1. कार्यक्रम को पहले दो आवश्यकताओं का भी पालन करना चाहिए। (इसका मतलब है कि आपका कार्यक्रम कम से कम 9 बाइट्स लंबा होगा।)

आपको फुल प्रोग्राम लिखना चाहिए, फंक्शन नहीं। अपने उत्तर में अपने कार्यक्रम का आउटपुट दिखाना सुनिश्चित करें।

इसके अलावा, चीजों को दिलचस्प बनाए रखने के लिए, आपको अत्यधिक प्रोत्साहित किया जाता है:

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

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

code-golf  restricted-source 
— darrylyeo
स्रोत
5
क्या नई सूचियों की गणना (एक अलग चरित्र के रूप में) की जाती है?
— ज़ेप्लेन
4
क्या ऐसे कार्यक्रम हैं जो पूरी तरह से शाब्दिक हैं? (बहुत सारी भाषाएँ हैं जहाँ 123123123काम करेंगे, जैसा कि वर्तमान में लिखा गया है।)
2
@zeppelin हां, नए अंक एक अलग चरित्र के रूप में गिने जाते हैं।
— 1927 में darrylyeo
2
मेरे कहने का मतलब यह है कि क्या एक प्रोग्राम आउटपुट उदा abcabcabcएक अनुगामी न्यूलाइन के साथ हो सकता है?
— ETHproductions
1
@ETHproductions आह, मैं देख रहा हूं। नहीं, इसकी अनुमति नहीं है। हालांकि तीन अनुगामी न्यूक्लियर स्वीकार्य होंगे।
— darrylyeo

जवाबों:

59

ब्रेन-फ्लैक , फ्लैकैट्स , ब्रेन-फ्ल्यू , ब्रेन-फ्लैक क्लासिक , मिनीफ्लाक और फेलो 18 बाइट्स

सिद्ध इष्टतम!

((([()][()][()])))

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

व्याख्या

ब्रेन-फ्लैक, ब्रेन-फ्ल्यू, मिनिफ्लक और फेनकैक

   ([()][()][()]) Push -3
  (              ) Copy
 (                ) Copy

यह प्रिंट:

-3
-3
-3

(एक अनुगामी न्यूलाइन है)

ब्रेन-फ्लैक क्लासिक

ब्रेन-फ्लैक क्लासिक ब्रेन-फ्लैक का मूल संस्करण है और आधुनिक ब्रेन-फ्लैक से कुछ महत्वपूर्ण अंतर हैं। BFC [...]इसकी सामग्री को नकारने के बजाय प्रिंट करता है।

   [()] Print 1
       [()] Print 1
           [()] Print 1
  (            ) Push 3
 (              ) Push 3
(                ) Push 3

स्टैक की सामग्री को निष्पादित करने के अंत में ( 3 3 3) मुद्रित किया जाता है।

यह प्रिंट:

1
1
1
3
3
3

(एक अनुगामी न्यूलाइन है)

Flakcats

फ्लैक्कट अन्य 4 फ्लैक्स से काफी अलग है और मुझे आश्चर्य है कि यह फ्लैकट्स में काम करता है। ब्रेन-फ्लैक का उपयोग करने वाले यहां के तीन ऑपरेटर लगभग समान हैं।

Flakcats के बीच इस विशेष कार्यक्रम में मुख्य अंतर (...)ऑपरेटर है जो Flakcats ([{}]...)में ब्रेन-फ्लैक के बराबर है । हालाँकि इससे हमें कोई फर्क नहीं पड़ता क्योंकि यह शून्य को चुनता है और इस तरह उसी तरह से संचालित होता है जैसा ब्रेन-फ्लैक करता है।

यहाँ वह कार्यक्रम ब्रायन-फ्लैक में संकलित है:

([{}]([{}]([{}][()][()][()])))

यह प्रिंट:

-3
-3
-3

(एक अनुगामी न्यूलाइन है)

में optimality का प्रमाण ब्रेन-आलोचना और Miniflak

यह एक औपचारिक प्रमाण नहीं है, बल्कि एक अनौपचारिक प्रमाण है जिसे और अधिक कठोर बनाने के लिए विस्तार करना होगा

प्रतिबंधों के कारण कि ब्रेन-फ्लैक प्रोग्राम एक संतुलित-स्ट्रिंग होना चाहिए और प्रोग्राम की लंबाई 3 से अधिक होनी चाहिए किसी भी मान्य सबमिशन की लंबाई 6 में से कई होनी चाहिए। इसका मतलब है कि 18 से छोटे किसी भी समाधान की लंबाई 12 होनी चाहिए।

न्यूलाइन को पीछे छोड़ते हुए आउटपुट की वजह से स्टैक की अंतिम ऊंचाई तीन से अधिक होनी चाहिए या हम आउटपुट पर प्रतिबंध तोड़ देंगे।

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

यह हमें हमारे ब्रेसिज़ के दूसरे सेट को चुनने के लिए छोड़ देता है। विकल्प हैं:

<...>/<>

यह विफल हो जाता है क्योंकि हमें शून्य के अलावा किसी भी संख्या को बनाने के लिए "मूल्य" उत्पन्न करने की आवश्यकता होती है हमें एक ()बनाने के लिए एक छोड़ देना चाहिए जो दो बार से अधिक धक्का देना असंभव बनाता है।

[...]/[]

यह उसी कारण से विफल हो जाता है जब अंतिम विफल हो जाता है। वर्गाकार ब्रेसिज़ वास्तव में मूल्य बनाने में खराब हैं। []इकाई कर सकते हैं मूल्य बनाने, लेकिन हम पहले नंबर पुश करने के लिए की जरूरत है और हम तो पर्याप्त कोष्ठक बचे तीन बार पुश करने के लिए नहीं है।

{...}/{}

यह एक आशाजनक है, हम एक लूप बना सकते हैं और एक ()का उपयोग कई बार पुश करने के लिए कर सकते हैं, लेकिन अफसोस यह संभव नहीं है।

लूप को समाप्त करने के लिए कुछ बिंदु पर स्टैक पर एक शून्य होना चाहिए और सही आउटपुट के लिए हमारे पास कार्यक्रम के अंत में स्टैक पर शून्य के अलावा कुछ और होना चाहिए। चूँकि हमारे पास लूप के अंत में []न <>तो शून्य है और न ही स्टैक के नीचे से एक निहित शून्य होना चाहिए। इसका मतलब यह है कि लूप किसी भी नए नंबर को जोड़ नहीं सकता है ताकि यह बेकार हो जाए।

चूंकि ब्रेस विकल्पों में से कोई भी लंबाई 12 का कार्यक्रम नहीं बना सकता है, इसलिए कोई भी मौजूद नहीं हो सकता है।

चूंकि मिनिफ्लक ब्रेन-फ्लैक का सबसेट है, इसलिए कोई भी छोटा मिनिफलाक प्रोग्राम भी छोटा ब्रेन-फ्लैक प्रोग्राम होगा और इस प्रकार इसका अस्तित्व नहीं है।

ब्रेन-फ्ल्यू में ऑप्टिमलिटी का सबूत

ब्रेन-फ्ल्यू ब्रेन-फ्लाक से हटकर एक मजाक भाषा है। दोनों समान हैं, उनके व्याख्याकार हर जगह समान हैं लेकिन दो लाइनें हैं। दोनों के बीच का अंतर है, जैसा कि उनके नाम से पता चलता है, ब्रेन-फ्ल्यू अपने डेटा को कतारों में संग्रहीत करता है जबकि ब्रेन-फ्लैक अपने डेटा को ढेर में संग्रहीत करता है।

शुरू करने के लिए हमारे पास ब्रेन-फ्लैक द्वारा बनाए गए कार्यक्रम के आकार पर समान प्रतिबंध हैं, इस प्रकार हम आकार 12 के एक कार्यक्रम की तलाश कर रहे हैं। इसके अलावा हमें (...)किसी भी आउटपुट और एक अन्य जोड़ी बनाने के लिए आवश्यकता है । <>और []जोड़े में ठीक उसी कारण वे ब्रेन-आलोचना में काम नहीं करते के लिए ब्रेन-Flueue में काम नहीं करते।

अब हम जानते हैं कि हमारे कार्यक्रम में पात्रों का समावेश होना चाहिए ((())){{{}}}।

पिछले प्रमाण में उपयोग की गई समान विधियाँ हम प्रदर्शित कर सकते हैं कि अंतिम कार्यक्रम में एक लूप होना चाहिए।

अब यहां वह जगह है जहां साक्ष्यों में अंतर होता है, क्योंकि ब्रेन-फ्लेयू स्टैक के बजाय कतारों में संचालित होता है, प्रोग्राम कतार पर मानों के साथ एक लूप से बाहर निकल सकता है।

लूप से बाहर निकलने के लिए हमें कतार में एक शून्य की आवश्यकता होगी (या एक खाली कतार लेकिन अगर कतार खाली है तो हमें ब्रेन-फ्लैक जैसी ही समस्या आती है) इसका मतलब यह होगा कि हमें अपना प्रोग्राम खोलने के ({})लिए इसे बनाना होगा शून्य। हमें आवश्यक संख्याओं को कतार में धकेलने के लिए लूप के अंदर एक पुश की आवश्यकता होगी। हमें लूप से पहले एक गैर शून्य संख्या को भी धक्का देना होगा ताकि हम लूप में प्रवेश कर सकें; यह हमें कम से कम पर खर्च करेगा (())। हमारे पास अब हमारे मुकाबले अधिक पार्न्स का उपयोग किया गया है।

इस प्रकार 12 बाइट्स वाले कार्य को करने के लिए कोई ब्रेन-फ्ल्यू कार्यक्रम नहीं है, और इसके अलावा हमारा कार्यक्रम इष्टतम है।

फ्लैकाट्स और ब्रेन-फ्लैक क्लासिक में इष्टतम समाधान

निम्नलिखित समाधान फ्लैकाट्स और ब्रेन-फ्लैक क्लासिक में इष्टतम है।

((([][][])))

व्याख्या

    [][][] -3
 (((      ))) push 3 times

वैकल्पिक 24 बाइट ब्रेन-फ्लैक समाधान

(<((<((<(())>)())>)())>)

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

((<((<((<>)())>)())>)())

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

((((((()()()){}){}){})))

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

— गेहूं का जादूगर
स्रोत
2
सबूत के लिए भी +1।
— हाइपरन्यूट्रिनो
3
Polyglot के लिए +1, esp। सभी आउटपुट समान नहीं होते हैं।
— शायरु असाकोतो
27

जेली , 9 बाइट्स

**‘‘‘888*

एक पूर्ण कार्यक्रम जो 700227072 प्रिंट करता है , जो 888 घन है।

TryItOnline!

कैसे?

**‘‘‘888* - Main link: no arguments
          - implicit L=R=0
*         - power       A = L ^ R = 1
  ‘       - increment   B = L + 1 = 1
 *        - power       C = A ^ B = 1
   ‘      - increment   D = C + 1 = 2
    ‘     - increment   E = D + 1 = 3
     888  - literal     F = 888
        * - power           F ^ E = 700227072
— जोनाथन एलन
स्रोत
5
888^3है 700227072? यह बहुत चालाक है, शायद अन्य भाषाएं इस चाल का उपयोग कर सकती हैं।
— ETHproductions
23

विशुद्ध रूप से शाब्दिक उत्तर के बहुभुज, 9 बाइट्स

333111222

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

इस कार्यक्रम में काम करता है:

  • पीएचपी
  • HTML (यकीनन कोई भाषा नहीं)
  • जेली (और एम )
  • 7 (अधिक दिलचस्प है, क्योंकि प्रोग्राम की व्याख्या डेटा और कोड दोनों के रूप में की जाती है ; पहला 3डेटा प्रिंट करता है, बाकी प्रोग्राम बेकार स्टैक मैनप्युलेशन है)
  • CJam
  • Japt
  • गाजर
  • आर (आर डिस्प्ले भी मेटाडेटा के रूप में [1] आउटपुट करता है)
  • RProgN
  • वास्तव में (हालांकि यह वास्तव में प्रिंट करता है 2\n2\n2\n1\n1\n1\n3\n3\n3\n)
  • ///
  • Noodel
  • TI-बेसिक
  • SimpleTemplate
  • ReRegex
  • भूसी
  • संसाधन (हालांकि यह स्ट्रिंग को उलट देता है)

अंतिम न्यूलाइन को अनदेखा करना, यह कुछ और भाषाओं में मान्य है:

अधिकांश लिंक इसे ऑनलाइन आज़माने के लिए जाते हैं!

— ETHproductions
स्रोत
3
यह 2\n2\n2\n1\n1\n1\n3\n3\n3\nवास्तव में प्रिंट करता है, जो पूरी तरह से मान्य है। क्या उसे पोस्ट में जोड़ा जाना चाहिए?
— ETHproductions
@ETHproductions मुझे वास्तव में लगता है कि वास्तव में पोस्ट में जोड़ा जाना चाहिए क्योंकि यह एक ही कोड का उपयोग करता है;)
— Kritii Lithos
जैसा कि वास्तव में बनाया गया व्यक्ति, मैं मानता हूं कि यह इस पद से संबंधित है। नई कहानियों में वास्तव में कोई फर्क नहीं पड़ता।
— मेगो
यह मेरे द्वारा लिखी गई भाषा पर भी काम करता है: SimpleTemplate । यह इसे एक ओवर-किल echo '333111222';(PHP में) में संकलित करेगा लेकिन यह काम करता है।
— इस्माइल मिगुएल
4
@IsmaelMiguel: यह एक सामुदायिक विकि उत्तर है; यह केवल 29% ETHproductions द्वारा लिखा गया था (और वास्तव में, यह मैं था जिसने मूल रूप से उत्तर बनाया था, जैसा कि आप संशोधन इतिहास से देख सकते हैं; ETHproductions में किसी और की तुलना में उत्तर के वर्तमान संस्करण में अधिक पाठ है, लेकिन निश्चित रूप से '.n' पूरी बात के लिए जिम्मेदार टी)। इसका संपूर्ण उद्देश्य उपयोगकर्ताओं की एक बड़ी संख्या को सहयोगी प्रयास के रूप में संपादित करना है। (यह सामान्य उत्तरों से अलग है, जिन्हें संपादित करने के लिए डिज़ाइन नहीं किया गया है।)
21

सी #, 114 111 118 102 बाइट्स

अगर हम उचित शब्दों का उपयोग करने से गुरेज नहीं करते हैं: (102 बाइट्स)

class CCcddiilMMmmnrrSSsttvvWWyy{static void Main(){{System.Console.Write(("A TEA AT TEE"));;;}}}///".

अगर हम उचित शब्दों की परवाह करते हैं: (120 बाइट्स)

class erebeWyvern{static void Main(){int embedWildbanana;{System.Console.Write(("A TEA AT TEE"));;}}}///CC Myst mvcSMS".

मेरा मूल सबमिशन - केस असंवेदनशील: (113 बाइट्स)

class EreBeWyvern{static void Main(){int embedwildbanana; {System.Console.Write(("A TEA AT TEE"));;}}}/// vyt".

मुझे पता है कि टिप्पणी वास्तव में सीजी की भावना में नहीं है, लेकिन यह सब मैं सीमित समय के साथ कर सकता हूं, मैं देखूंगा कि क्या मैं इसे दिन के माध्यम से सुधार सकता हूं। निश्चित रूप से मुझे साहसी होने के लिए कम से कम कुछ बोनस अंक मिलना चाहिए।

संपादित करें: लापता पत्रों को पकड़ने के लिए roberto06 के लिए धन्यवाद!

— Dmihawk
स्रोत
1
मैं C ++ का लड़का हूं, C # नहीं, लेकिन क्या आप इसे प्रभावित किए बिना {()} में लिखी कॉल को लपेट नहीं सकते?
— Sparr
1
आप संपूर्ण के रूप में कॉल के बजाय, कोष्ठक को तर्क के आसपास रखने में सक्षम हो सकते हैं।
7
ब्राउनी जंगली केले के लिए इशारा करती है।
— darrylyeo
6
अच्छा! मुझे चर नाम पसंद हैं। +1
— MildlyMilquetoast 1
1
आपको Vअपनी टिप्पणी से हटा देना चाहिए , और जोड़ना चाहिए vyt, क्योंकि Vकेवल vदो बार मौजूद है (टाइपो, मुझे लगता है) yमौजूद है, दो बार भी मौजूद है, और t5 बार मौजूद है। यहाँ देखें । फिर भी, बहुत बढ़िया काम!
— रोजबेरो ०६
18

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

alert(((alert|alert||333111222)))

अलर्ट करता है 333111222। यह काम करता है क्योंकि |इसके दोनों ऑपरेंड को 32-बिट पूर्णांक में कनवर्ट करता है , और ऐसा कोई भी मान जो पूर्णांक की तरह कुछ भी नहीं दिखता है (जैसे फ़ंक्शन alert) में परिवर्तित हो जाता है 0। 0|0है 0, तो ||ऑपरेटर अपने अधिकार संकार्य लौटाता है, या333111222

कुछ और रोचक संस्करण:

(a="(trelalert)\\\"")+alert(a+=a+=a)

आउटपुट (trelalert)\"(trelalert)\"(trelalert)\"।

एक समाधान का उपयोग .repeatसमान लंबाई होगा, साझा करने के लिए धन्यवाद aert:

alert("(trpp.all)\\\"".repeat(3.33))

जो आउटपुट देता है (trpp.all)\"(trpp.all)\"(trpp.all)\"।

छुटकारा पाने के लिए lऔर p लगभग काम करने के लिए अतिरिक्त बैकस्लैश का लाभ लेना :

a\x6cert("(trax.cc)\"".re\x70eat(6.00677))

यह एक आउटपुट है (trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"।

— ETHproductions
स्रोत
1
दशमलव का अच्छा दुरुपयोग!
— darrylyeo
2
@darrylyeo हे, धन्यवाद। मैं आसानी से स्ट्रिंग में उन अटक सकता है, लेकिन यह उतना मज़ा नहीं होगा ;-)
— ETHproductions
सोचा था कि मैं तुम्हें पता है कि तुम एक ES6 जवाब द्वारा सबसे ऊपर थे ।
— darrylyeo 3
14

CJam , 9 बाइट्स

10,10,10,

आउटपुट 012345678901234567890123456789

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

व्याख्या

10,       The range from 0 to 9
   10,    The range from 0 to 9
      10, The range from 0 to 9
— बिजनेस कैट
स्रोत
3,3,3 नहीं है, 7 बाइट्स के लिए काम करते हैं?
— चिम
आह! हाँ, तीसरे आवश्यकता :)
— चिम
अर्घ, उपयोग करने के लिए एक गलत अवसर है 99,99,99,, क्योंकि क्यों नहीं?
— वर्कओवरफ्लो
@workoverflow क्योंकि वह तीसरी आवश्यकता के साथ काम नहीं करता है। कार्यक्रम में तीन अलग-अलग वर्णों की आवश्यकता होती है।
— DLosc
@ डलास टौच, मैं उसके बारे में भूल गया!
— वर्कओवरफ्लो
11

ब्रेनफक , 12 बाइट्स

++[+...][][]

किसी ने नहीं कहा कि आउटपुट कम होना था। यह पहले 2 को छोड़कर हर आस्की चरित्र की 3 प्रतियों का उत्पादन करेगा।

आप साबित कर सकते हैं कि यह जितना मिलेगा उतना कम है। आपको आउटपुट की जरूरत है इसलिए आपको 3 की जरूरत है। ' अलग-अलग आउटपुट होने की आवश्यकता है इसलिए आपको 3 [+ -] की आवश्यकता है अब हम 6. 9 अक्षर तक प्रिंट करना चाहते हैं, जिसका अर्थ है कि या तो 6 और जोड़ना '।' या एक लूप जोड़ना, जो एक और 6 अक्षर जोड़ देगा।

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

— बिजन
स्रोत
10

पायथन 2, 36 30 बाइट्स

चूंकि एक अनुगामी न्यूलाइन की अनुमति नहीं है, यह संभवतः उतना ही छोटा है जितना इसे मिल सकता है:

print"\\\""*3;print;print;3**3

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

आउटपुट \"तीन बार, उसके बाद तीन न्यूलाइन आए।

नीचे दिए गए कार्यक्रम अनुगामी न्यूलाइन की गणना नहीं करते हैं, इसलिए वे मान्य नहीं हैं।

27 बाइट्स :

print"""printprint"""*3*3*3

प्रत्येक वर्ण के 54 प्रिंट करता है print।

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

एक ही लंबाई, कम उत्पादन:

print"""printprint*3*3"""*3

आउटपुट printprint*3*3printprint*3*3printprint*3*3

24 बाइट्स:

print~9;print~9;print~9;
— mbomb007
स्रोत
आप print"""printprint*3*3"""*3बहुत छोटे आउटपुट के लिए कर सकते हैं ;-)
— ETHproductions 20
क्या आप print 123;print 123;print 123;भोले समाधान के लिए नहीं कर सकते थे ?
— ETHproductions
ओपी ने स्पष्ट किया है कि एकल अनुगामी न्यूलाइन की अनुमति नहीं है (टिप्पणियां देखें)।
— फ्लिपकैक
1
@ETHproductions ज़रूर। यह निर्भर करता है कि हम कितने भोले हैं।
— mbomb007
3
और भी भोली:print~9;print~9;print~9;
— Sp3000
9

पर्ल 6 , 15 बाइट्स

.say;.say;.say;

छह अलग-अलग वर्णों को प्रिंट करता है, तीन बार प्रत्येक:

(कोई भी)
(कोई भी)
(कोई भी)

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

यह काम किस प्रकार करता है

  • वर्तमान विषय पर एक नंगी विधि कॉल संचालित होती है $_।
  • $_के रूप में बाहर शुरू होता है प्रकार वस्तु प्रकार का Anyहै, जो sayके रूप में प्रिंट (Any)।
— SMLS
स्रोत
1
अब मुझे हाँ में हाँ मिलाने वाला गाना मेरे सिर में अटक गया है।
— स्टुअर्ट पी। बेंटले
9

सी, 66 बाइट्स

main(i){{for(i=0;i<3;i++){printf("""poop+fart=<3<3at0m=m0n""");}}}

उत्पादन

poop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0n

पुराने संस्करण 72 बाइट्स

main(i){for(i=0;i<3;i++){printf("poop+fart=<3<3 at {\"0m=m0\"}" "\n");}}
— जियाकोमो गारबेलो
स्रोत
2
न केवल आपके कोड ने जो कुछ किया उससे बहुत छोटा है, बल्कि इसमें वास्तविक कटोरे और फ़ार्ट्स भी हैं। वाहवाही।
— मंद
9

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

+alert((({alert}+{alert}+{})))

आउटपुट [object Object][object Object][object Object]।

तीन ऑब्जेक्ट्स बनाकर काम करता है:

  • पहले दो { "alert" : alert }ES6 संकेतन का उपयोग करते हुए फॉर्म के हैं{alert}

  • तीसरा एक साधारण खाली वस्तु है

फिर यह +उन्हें एक साथ समेटने के लिए उपयोग करता है, और तीनों एक स्ट्रिंग के रूप में एक समान अभिव्यक्ति है [object Object]।

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

— apsillers
स्रोत
अन्य जेएस जवाब को हरा करने का तरीका!
— darrylyeo
आपको (ES6)शीर्षक भी जोड़ना चाहिए ।
— darrylyeo
@darrylyeo धन्यवाद! :) और मैंने
— ईएस 6
8

पीकेओडी , 9 बाइट्स

sonsonson

आउटपुट: 111222333

स्पष्टीकरण:

Background: PKod has only one variable that you mess with, with the code
This variable starts with default value of 0

s  -  Add next char to the variable, and jump over it. 
n  -  Print numeric value of variable

o दशमलव में ascii char कोड "111" है। इस प्रकार s चर में 111 जोड़ देता है, फिर संख्या को प्रिंट करता है। पहले "बेटा" इसे 111 बनाता है और 111 प्रिंट करता है। अगला इसे 222 बनाता है और 222 प्रिंट करता है, अंतिम रूप से इसे 333 और प्रिंट 333 बनाता है।

— पी। केटिनो
स्रोत
7

माइक्रोसेप्टिक II, 9 बाइट्स

{{{~~~}}}

स्पष्टीकरण: एक कोड ब्लॉक बनाता है, लेकिन इसे लागू नहीं करता है। जब निष्पादन समाप्त होता है, तो मुख्य रजिस्टर (IE यह कोड ब्लॉक) की सामग्री को स्पष्ट रूप से मुद्रित किया जाता है।

— SuperJedi224
स्रोत
क्या आपने क्वीन चैलेंज में भी कुछ ऐसा ही पोस्ट किया है?
— wizzwizz4
@ wizzwizz4 {}तकनीकी रूप से एक क्वीन होगा, लेकिन मुझे नहीं लगता कि यह "उचित क्वीन" की हमारी परिभाषा से मिलता है। कार्यक्रम "q"q(जो मैंने क्वीन चुनौती के लिए प्रस्तुत किया था), हालांकि।
— SuperJedi224
@ wizzwizz4: यह एक उचित क्वीन नहीं होगा , क्योंकि प्रत्येक चरित्र खुद का प्रतिनिधित्व करता है।
7

हेक्सागोनी , 9 बाइट्स

x!!xx@@!@

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

प्रिंट आउट लें 120120120। xद्वारा प्रतिस्थापित किया जा सकता है f-m(102-109)

व्याख्या

  x ! ! 
 x x @ @
! @ . . .

xx@@केवल एक नियमों का पालन करने भराव है। मुख्य प्रवाह xमेमोरी में बचत कर रहा है (एएससीआईआई 120 मूल्य के साथ) और फिर इसे 3 बार नंबर के रूप में प्रिंट करें।

— सनी पुं ०
स्रोत
7

सी, 111 बाइट्स

(ध्यान दें कि बाइट की गिनती भी तीन समान संख्याएं हैं। वाह। आप इससे अधिक मेटा नहीं कर सकते।)

#include<stdio.h>
#define b "<acdhlmoprsu>."
#define t "en"
main(){{{printf(("<acdhlmoprsu>." b b t t t));;;}}}

प्रिंटों:

<acdhlmoprsu>.<acdhlmoprsu>.<acdhlmoprsu>.enenen
— धुंधला
स्रोत
5

99 , 15 बाइट्स

9 9  9999
9
9
9

वह नौ नाइन, तीन स्पेस और तीन लाइन फीड है, आउटपुट -1110-1110-1110 है ।

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

कैसे?

9 9  9999 - V(9)=V(9)-V(9999)=1-1111=-1110
9         - print V(9)
9         - print V(9)
9         - print V(9)

दो स्थानों को एक के रूप में माना जाता है, यह तीसरा स्थान किसी भी रेखा पर एक अनुगामी स्थान हो सकता है।

— जोनाथन एलन
स्रोत
5

बैश + कोरुटिल्स, 15 9 बाइट्स

id;id;id;

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

नमूना आउटपुट:

uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211

(यदि आप इसे आज़माते हैं, तो यह आपके uid, gid, आदि को 3 बार प्रिंट करेगा।)

यदि आप एक ही स्ट्रिंग को 3 बार दोहराने से बचना चाहते हैं (और मेरे पहले उत्तर के विपरीत हर किसी के लिए एक ही आउटपुट भी है), मैंने बैश + यूनिक्स उपयोगिताओं के लिए जो सबसे अच्छा पाया है वह 15 बाइट्स लंबा है:

dc<<<cczdzfzfdf

ऑनलाइन इस दूसरे संस्करण की कोशिश करो!

आउटपुट:

2
0
0
3
2
0
0
3
3
2
0
0

(कार्यक्रम में कोई नई कहानी नहीं, आउटपुट में 12 नए अंक।)

इस उत्तर में डीसी कार्यक्रम की व्याख्या:

c Clears the stack.
Stack: (empty)

c Clears the stack.
Stack: (empty)

z Pushes the current size of the stack (0) onto the stack.
Stack: (top) 0

d Duplicates the item at the top of the stack.
Stack: (top) 0 0

z Pushes the current size of the stack (2) onto the stack.
Stack: (top) 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the first 3 lines of the output, 2 / 0 / 0 /)

z Pushes the current size of the stack (3) onto the stack.
Stack: (top) 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the next 4 lines of the output, 3 / 2 / 0 / 0 /)

d Duplicates the item at the top of the stack.
Stack: (top) 3 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the final 5 lines of the output, 3 / 3 / 2 / 0 / 0 /)
— मिशेल स्पेक्टर
स्रोत
दूसरा काम कैसे करता है?
— 14
@therealfarfetchd मैंने उत्तर में एक स्पष्टीकरण जोड़ा है।
— मिशेल स्पेक्टर
लानत है, डीसी जितना मैंने सोचा था उससे कहीं अधिक शक्तिशाली है। अच्छी नौकरी!
— 15
@therealfarfetchd धन्यवाद मुझे dc पसंद है। Btw, स्पष्टीकरण में टाइपोस के एक जोड़े थे जो मैंने अभी तय किया था।
— मिशेल स्पेक्टर
5

LOLCODE , 273 240 ( 360 286) बाइट्स

HAI 1.2
I HAS A U
IM IN YR M UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "Y SUB.EK"
IM OUTTA YR M
IM IN YR T UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "Y SUB.EK"
IM OUTTA YR T
IM IN YR X UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IM"
IM OUTTA YR X
KTHXBYE

अनुगामी नई लाइन नोट करें और इसे ऑनलाइन आज़माएं । दूसरी पंक्ति अधिक या कम मनमानी थी और संभवतः इसे एक छोटी कमांड द्वारा प्रतिस्थापित किया जा सकता है, लेकिन मैंने अभी इस पहेली के लिए LOLCODE सीखा है । चूंकि पहली पंक्ति में संस्करण संख्या आवश्यक है, इसलिए मैंने वर्णों की सही संख्या मुद्रित करने के लिए लंबाई 1, 2 और 0 mod 3 के छोरों को जोड़ने के लिए संख्याओं का उपयोग किया। इससे मैंने बस प्रत्येक चरित्र (इस टूल के साथ ) को गिना । यदि यह 0 मॉड 3 बार दिखाई देता है, तो कोई कार्रवाई आवश्यक नहीं थी। यदि यह 1 मॉड 3 बार दिखाई दिया, तो इसे 1- और 2-लूप में जोड़ा गया ताकि यह आउटपुट में तीन बार दिखाई दे। यदि यह 2 मॉड 3 बार दिखाई देता है, तो चरित्र को 12-लूप में जोड़ा गया था। EDIT: पहले को बदलकरVISIBLE एक असाइनमेंट के साथ (अभी भी बेकार है लेकिन 11 नई लाइनों के बजाय 12 के लिए आवश्यक है), मैं 33 बाइट्स काटने में सक्षम था।

आउटपुट (60 बाइट):

Y SUB.EK
Y SUB.EK
Y SUB.EK
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM

अनुगामी नई लाइन पर ध्यान दें।

अन्य उत्तरों की तुलना में इस समाधान के बारे में अच्छी बात यह है कि आउटपुट आसानी से कुछ सार्थक पाठ के उत्पादन में हेरफेर कर सकता है। उदाहरण (नई लाइन के साथ 286 बाइट्स):

HAI 1.2
I HAS A U
IM IN YR MW UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR MW
IM IN YR STA UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR STA
IM IN YR XURG UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IMO U R SWAG! "
IM OUTTA YR XURG
KTHXBYE

इसे ऑनलाइन आज़माएं। आउटपुट (नई पंक्ति के साथ 222 बाइट्स):

YO SUB. EEEEK!
YO SUB. EEEEK!
YO SUB. EEEEK!
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG!

अफसोस की बात है, मैं एंग्राम के साथ उतना अच्छा नहीं हूं जितना मैंने सोचा था: ')

— SK19
स्रोत
1
साइट पर आपका स्वागत है!
— DJMcMayhem
@DJMcMayhem धन्यवाद कुछ भी करने की आवश्यकता है जो मैं अन्य पोस्ट से कॉपी करके एक अच्छा स्वचालित लिंकिंग प्राप्त कर सकता हूं? (# [भाषा] शैली) स्रोत कोड का लिंक उत्तर में निहित है।
— SK19
सबसे आसान तरीका है, जब आपने अपना कार्यक्रम TIO में डाला है, लिंक मेनू का उपयोग करने के लिए और "कोड गोल्फ सबमिशन" के लिए विकल्प चुनें (या कॉपी करें)। जो आपको एक नई पोस्ट के लिए एक टेम्पलेट देता है। मैंने उस हिस्से की नकल की जो आपको वहां से गायब लग रहा था।
— अर्जन जोहान्सन
5

शेल

मजाक करने के लिए :) ( 9 बाइट्स )

ls;ls;ls;

या अधिक गंभीरता से ( 24 बाइट्स )

sed s/./sed.g./g <<< edg

नतीजा :

sed.g.sed.g.sed.g.
— अली ISSA
स्रोत
5

PHP, 24 बाइट्स

<?=111?><?=222?><?=333?>
— junkfoodjunkie
स्रोत
1
यह आउटपुट क्या करता है? यह कैसे काम करता है?
— डीजेएमकेम
यह PHP शॉर्टटैग का उपयोग 123 स्टेटमेंट को आउटपुट करने के <?लिए तत्काल echoस्टेटमेंट के साथ करता <?=है।
— जंकफूडजंकरी
आपके द्वारा संपादित किया गया छोटा संस्करण अमान्य है क्योंकि <= ?>वर्ण 3 से अधिक बार दिखाई नहीं देते हैं।
— DJMcMayhem
आह, ठीक है, मुझे पता था कि मूल संस्करण के होने का एक कारण यह था - मैं पूरी तरह से आवश्यकता पर भड़क गया था - मैं इसे वापस बदल दूंगा।
— जंकफूडजंकरी
4

बैच, 36 21 बाइट्स

@echo
@echo
@echo

आउटपुट

ECHO is on.
ECHO is on.
ECHO is on.

संपादित करें: @ P.Ktinos के लिए सहेजे गए 15 बाइट्स।

— नील
स्रोत
2
3 अकेले काम नहीं करेगा? echo \ necho \ necho - एक नई लाइन के साथ \ n बदलें - यह मुझे छवि के लिए मान्य दिखता है ।prntscr.com / image / ef96173169eb41168815203387d4975b.png , यह 14 बाइट्स बनाता है।
— पी। केटिनो
बहिर्गमन: codegolf.stackexchange.com/a/108180/63033
— P. Ktinos
4

जाप, 9 बाइट्स

000OoOoOo

प्रिंट करता है undefinedundefinedundefined। इसे ऑनलाइन टेस्ट करें!

व्याख्या

इस कोड को निम्नलिखित जावास्क्रिप्ट में ट्रांसपोंड किया जाता है:

000,O.o(O.o(O.o()))

O.oएक फ़ंक्शन है जो एक अनुगामी न्यूलाइन के बिना कुछ आउटपुट करता है। जब कोई तर्क नहीं दिया जाता है, तो यह प्रिंट करता है undefined, जिसे बग माना जा सकता है, लेकिन यहां काम आता है। यह भी लौटता है undefined, इसलिए सभी तीन कॉल प्रिंट करते हैं undefined।

मुझे यकीन है कि ऐसा करने के लिए बहुत सारे अन्य तरीके हैं ...

— ETHproductions
स्रोत
1
O_O दिलचस्प :)
— geisterfurz007
4

05AB1E , 9 बाइट्स (मुझे लगता है कि आप कह सकते हैं कि यह पीआई का एक टुकड़ा था)

-0 बाइट्स Emigna / ETHProductions के लिए धन्यवाद, समाधान को और अधिक सही बनाया।

žqžqžq???

वैकल्पिक संस्करण:

ž[g-Q]ž[g-Q]ž[g-Q]???

[g-Q] - किसी भी अक्षर aQ को यहाँ रख सकते हैं, जब तक वे सभी मेल खाते हैं (नीचे देखें)।

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

व्याख्या की:

PI,PI,PI,SORT,JOIN,SORT,JOIN,SORT,JOIN.

नतीजा:

...111111222333333333444555555555666777888999999999

इसका कारण केवल 9 बाइट्स है क्योंकि आपको इस प्रकार की आवश्यकता नहीं है, मैं सिर्फ उदाहरण के लिए उन्हें बताने में मदद करता हूं।

परिणाम w / o {कोड में:

3.1415926535897933.1415926535897933.141592653589793

वैकल्पिक संशोधन:

पीआई के स्थान पर निम्न आदेशों का उपयोग किया जा सकता है:

ž 23  > žg       push current year
        žh       push [0-9]
        ži       push [a-zA-Z]
        žj       push [a-zA-Z0-9_]
        žk       push [z-aZ-A]
        žl       push [z-aZ-A9-0_]
        žm       push [9-0]
        žn       push [A-Za-z]
        žo       push [Z-Az-a]
        žp       push [Z-A]
        žq       push pi
        žr       push e
        žu       push ()<>[]{}
        žy       push 128
        žz       push 256
        žA       push 512
        žB       push 1024
        žC       push 2048
        žD       push 4096
        žE       push 8192
        žF       push 16384
        žG       push 32768
        žH       push 65536
        žI       push 2147483648
        žJ       push 4294967296
        žK       push [a-zA-Z0-9]
        žL       push [z-aZ-A9-0]
        žM       push aeiou
        žN       push bcdfghjklmnpqrstvwxyz
        žO       push aeiouy
        žP       push bcdfghjklmnpqrstvwxz
        žQ       push printable ASCII character set (32-128)
— जादू ऑक्टोपस Urn
स्रोत
2
सजा के लिए बाहर निकलो; हालांकि चाल के लिए एक :)
— geisterfurz007
अच्छा है! मुझे नहीं लगता žv, žwया žxमान्य हैं , हालांकि उनमें से प्रत्येक में केवल 2 अलग-अलग अंक हैं।
— ETHproductions
हम्म, पिछड़े चरित्र वर्गों की बात क्या है?
— ETHproductions
@ETHproductions आह, के बारे में भूल गया at least 3था, बस जब मैं इसे लिखा था तो पहले पीआई था। पिछड़े चरित्र वर्ग से आपका क्या तात्पर्य है?
— मैजिक ऑक्टोपस Urn
1
ध्यान दें कि यह केवल तभी मान्य होता है जब आप उस नई लाइन को नहीं गिनते हैं जो संक्षेप में मुद्रित होती है। यही कारण है कि आसानी से बदलकर इसे ठीक किया जा सकता है JJJके साथ ???यद्यपि।
— इमीना
4

क्यूबिक्स , 12 बाइट्स

थोड़ा उबाऊ जवाब वास्तव में। आउटपुट तीन 10एस के बाद न्यूलाइन्स

N@N@NOoOoOo@

इसे ऑनलाइन आज़माएं! घन के नक्शे

    N @
    N @
N O o O o O o @
. . . . . . . .
    . .
    . .

Nस्टैक
Oox3 आउटपुट 10 पर 10 पुश करता है और न्यूलाइन
@प्रोग्राम को रोक देता है

प्रारंभिक N@N@हिट नहीं है।

— MickyT
स्रोत
मैं 34 स्थानों की गिनती करता हूं: /
— SK19
@ SK19 कोड है N@N@NOoOoOo@और इसमें कोई स्पेस शामिल नहीं है।
— मिक्यट
आह, ठीक है, मैंने सोचा कि क्यूब को आवश्यकता को पूरा करने की आवश्यकता है,
— SK19
4

पेपे , 24 बाइट्स

rEeEEeeEEErreEErreEEreEE

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

कार्यक्रम में 6 आर, 6 ई और 12 ई शामिल हैं।

स्पष्टीकरण:

rEeEEeeEEErreEErreEEreEE # full program

rEeEEeeEEE               # push '103' to the stack
          rreEErreEE     # output as int (r flag: preserve)
                    reEE # output as int

आउटपुट:

103103103
— u_ndefined
स्रोत
3

बेफुज 93 , 9 बाइट्स

...,,,@@@

TIO

प्रिंट 0 0 0(ट्रेलिंग स्पेस, उसके बाद 3 नल बाइट्स)

क्योंकि Befunge का स्टैक गद्देदार होता है 0 s के , हम ASCII वर्ण को उस मान और पूर्णांक दोनों के साथ प्रिंट कर सकते हैं। क्योंकि एक पूर्णांक के बाद Befunge स्वचालित रूप से एक स्पेस प्रिंट करता है, हमें 3 अलग-अलग वर्णों के साथ छोड़ दिया जाता है।

.प्रिंट 0(अनुगामी स्थान), ,एक शून्य बाइट प्रिंट करता है, और @कार्यक्रम को समाप्त करता है

— MildlyMilquetoast
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.