71

यदि आपको यह पसंद है, तो इसमें भाग लेने पर विचार करें:

12 स्निपेट / भाव बनाएंएक ही भाषा में , जिसका परिणाम 0 में क्रमशः 10 और 42 के माध्यम से होता है, लेकिन बिना किसी शाब्दिक संख्यात्मक, स्ट्रिंग या वर्ण डेटा को लिखे।

बिल्ड-इन डेटा, लाइक PI()औरALPHABET() , ठीक हैं, और इसलिए CJam के U, X, Y, Z और A स्थिरांक हैं, और प्रसंस्करण के BLEND, CHORD, CENTER, BREAK, और LINES हैं।

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

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

वैध स्निपेट के उदाहरण

3: INT(LOG10(YEAR(TODAY()))) क्योंकि यह निकट भविष्य में सच रहता है
4: CUBICROOT(LEN(CHARACTERSET())) क्योंकि एक 256 अक्षर वर्ण सेट बहुत आम है
8: SQRT(SYSTEMTYPE()) क्योंकि 64-बिट सिस्टम बहुत आम हैं

अमान्य स्निपेट के उदाहरण

5: LEN(USERNAME()) क्योंकि अधिकांश लोग लॉगिन के रूप में "व्यवस्थापक" का उपयोग नहीं करते हैं :-)
9: LOG10(SYSTEMMEMORY()) क्योंकि यह केवल 1 जीबी मेमोरी वाले सिस्टम पर काम करता है
: 42CODE("*") क्योंकि इसमें एक स्ट्रिंग / वर्ण शाब्दिक है

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

केवल चरित्र आधारित भाषाओं की अनुमति है।

संयुक्त स्कोर सभी 12 स्निपेट्स की कुल बाइट गिनती है। स्निपेट्स को अलग करने वाले न्यूलाइन्स की गिनती नहीं की जाती है।

ध्यान दें कि उपरोक्त नियम कुछ भाषाओं को भाग लेने से रोक सकते हैं, भले ही वे ट्यूरिंग पूर्ण हों।

सामान्य प्रश्न

Q क्या प्रोग्राम किसी इनपुट को स्वीकार कर सकते हैं?
एक हाँ, पर तुम सिर्फ इनपुट के लिए पूछने के लिए और प्रासंगिक नंबर दर्ज नहीं कर सकते।

Q क्या भौतिक अंकों (गैर-डेटा) अंकों की अनुमति है?
ए हाँ, उदा LOG10()।

क्यू रूबी में प्रतीक शाब्दिक के रूप में गिना जाता है?
अ हां।

Q क्या प्रत्येक स्निपेट के बीच स्कोर में नए अंक शामिल हैं?
A नहीं।

Q क्या TI-BASIC "चरित्र आधारित" वैध होने के लिए पर्याप्त है?
अ हां।

Q क्या संख्या शाब्दिक के रूप में गलत और सही गणना है?
ए नहीं, वे स्वीकार्य हैं।

Q क्या हम किसी फ़ंक्शन को कॉल करने के लिए नंबर शाब्दिक का उपयोग कर सकते हैं यदि वह एकमात्र तरीका है और नंबर फ़ंक्शन के आउटपुट को प्रभावित नहीं करता है?
एक हाँ, अगर है कि अपनी भाषा में कोड लिखने के लिए सामान्य तरीका है।

क्यू मेरी भाषा मानती है कि प्रत्येक कार्यक्रम / अभिव्यक्ति की शुरुआत में एक [कुछ] है। क्या मुझे इसे शामिल करना चाहिए, या क्या मेरे स्निपेट को केवल एक कार्यक्रम / अभिव्यक्ति के बीच में रखा जाना चाहिए?
A उन्हें बस एक कार्यक्रम / अभिव्यक्ति के बीच में काम करना चाहिए।

क्यू रेगेक्स शाब्दिक के बारे में क्या?
एक निषिद्ध, केवल उन भाषाओं को छोड़कर जो रेगेक्स करते हैं।

प्रश्न क्या एक ऐसा कोड है जो सभी निर्दिष्ट संख्याओं को स्वीकार्य कर सकता है?
ए नहीं, उन्हें अलग और परस्पर स्वतंत्र होना होगा।

Q क्या मैं एक बॉयलरप्लेट की तरह int main() {}...या समकक्ष मान सकता हूं ?
अ हां।

क्यू क्या आउटपुट डेटाटाइप की अनुमति है?
कोई भी संख्यात्मक डेटाटाइप, जैसे इंट, फ्लोट, आदि।

Q क्या मुझे प्रत्येक स्निपेट के परिणाम को प्रिंट करने की आवश्यकता है?
ए नहीं, परिणाम को बाद के उपयोग के लिए उपलब्ध कराना पर्याप्त है।

क्यू पूर्व निर्धारित चर की अनुमति है?
एक हाँ, और वे हर टुकड़ा के लिए रीसेट (यदि परिवर्तित) हो जाते हैं।

Q क्या liter और ई नंबर शाब्दिक हैं?
A नहीं, आप उनका उपयोग कर सकते हैं।

Q क्या मैं 42 के लिए विभिन्न कोशिकाओं में 4 और 2 वापस कर सकता हूं?
ए नहीं, उन्हें एक नंबर के रूप में जोड़ा जाना चाहिए।

क्यू बाइट्स या वर्ण?
एक बाइट्स, लेकिन आप कोई भी वांछित कोडपेज चुन सकते हैं।

Q लगातार कार्य और पूर्व निर्धारित चर जैसे J 9:, वास्तव में 9, और Pretzel का 9उपयोग किया जा सकता है?
एक हाँ, शब्दावली परिमित है अगर (जम्मू के लिए 19, 10 वास्तव में और प्रेटज़ेल के लिए)।

— एडम
स्रोत

यदि 0-9 नंबर शाब्दिक नहीं हैं, लेकिन पूर्व-आबादी वाले चर हैं, तो क्या वे उचित खेल होंगे?

— साइओस

@Cyoce 10 तो {1, 0} है और 2 × 5 नहीं?

— आदम

नहीं, शाब्दिक अर्थों के लिए एक और वाक्यविन्यास है जो आधार -10 नहीं है, इसलिए 0-9 शाब्दिक नहीं हैं। वे 0-9 का मान रखते हैं, लेकिन चर माना जाता है

— साइओस

@ कोको तो ठीक है। वह कौन सी भाषा है?

— 18

प्रेट्ज़ेल (एक भाषा जो मैं काम कर रहा हूं)।

— साइओस

15

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

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

हेक्सागोनी के 0माध्यम से , 9ऐसे फ़ंक्शन हैं जो वर्तमान मेमोरी को 10 से गुणा करते हैं, और फिर फ़ंक्शन नाम द्वारा दर्शाए गए संख्या को जोड़ते हैं। इसलिए, पहला स्निपेट खाली है क्योंकि यादें शुरू होती हैं 0।

उदाहरण के लिए, यदि वर्तमान मेमोरी है 65, तो फंक्शन 3को निष्पादित करने से वर्तमान मेमोरी बन जाएगी 653।

(डाउनवॉटर्स: डाउनवोट आप सभी चाहते हैं; मैं तैयार हूं।)

— लीक नन
स्रोत

डरपोक, लेकिन मेरे अपवित्र और टिक जाता है।

— 13

49

फंकिटॉन , 1222 बाइट्स

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

चुनौती पोस्ट किए जाने से पहले यहां इस्तेमाल किए गए सभी पुस्तकालय कार्य मौजूद थे।

0 (UTF-16 में 40 बाइट्स)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

यह कम से कम के लिए कच्चे वाक्यविन्यास का उपयोग करता है। एक मान कभी भी स्वयं से कम नहीं होता है, इसलिए इसका परिणाम 0 होता है।

UTF-16 में 1 (52 बाइट्स)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

⌑एक एकल तत्व युक्त एक आलसी अनुक्रम देता है और ɕतत्वों की संख्या को गिनता है। (आलसी अनुक्रम पर्याप्त आलसी है कि यह स्निपेट वास्तव में स्टड का मूल्यांकन नहीं करता है!)

2 (UTF-16 में 70 बाइट्स)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2 =। ʂएक अनुक्रम के सभी बाद उत्पन्न करता है, और इस तरह n तत्वों का एक क्रम 2ⁿ में बदल जाता है ।

यूटीएफ -16 में 3 (88 बाइट्स)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. ♯1 से एक मान बढ़ाता है।

4 (यूटीएफ -16 में 88 बाइट्स)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 =।

5 (यूटीएफ -16 में 106 बाइट्स)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1।

6 (UTF-16 में 106 बाइट्स)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 गुट।

7 (UTF-16 में 110 बाइट्स)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= ए (2, 2) (एकरमन फ़ंक्शन)।

8 (यूटीएफ -16 में 118 बाइट्स)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (शिफ्ट-बाएं)।

9 (UTF-16 में 128 बाइट्स)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3।

यूटीएफ -16 में 10 (146 बाइट्स)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5।

42 (यूटीएफ -16 में 170 बाइट्स)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1)।

— Timwi
स्रोत

6

एकरमन समारोह के लिए +1 ।

— intrepidcoder

4

काश मैं एक से अधिक बार

— उत्थान कर पाता

26

जावास्क्रिप्ट, 144 141 140 138 132 125 123 बाइट्स

@ Edc65 की मदद से , @Sjoerd नौकरी Postmus , @DocMax , @usandfriends , @Charlie व्यान और @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत

4 कोशिश करें: - ~

— Math.PI

@ edc65 धन्यवाद! मैंने सोचा कि कुछ ऐसा होगा जो मैं पीआई के साथ कर सकता हूं। :)

— user81655

5, 6 के लिए आप किसी अन्य बाइट (दो बार) का उपयोग -~-~Math.PIऔर -~-~-~Math.PIबचत भी कर सकते हैं ।

— Sjoerd Job Postmus

1

42 के साथ एक बचाओ (escape+NaN).length। पीएस टुडे मैंने सीखा कि जावास्क्रिप्ट वास्तव में अजीब है ...

— Mwr247

1

मैं कहने वाला था कि NaNएक संख्या के रूप में गिना जाता है, लेकिन यह वस्तुतः संख्या नहीं है: P

— ETHproductions

17

माउस- 2002 , 27 26 17 14 बाइट्स

पहले के टुकड़े 0-10 धक्का, और ZR+धक्का 25तो 17और 25 17 + 42 =है 1।

A
B
C
D
E
F
G
H
I
J
K
ZR+

— बिल्ली
स्रोत

यह "एक झलकी या अभिव्यक्ति" कहता है ताकि आप सभी को हटा सकें! 'S

— ev3commander

3

@ मैं प्रश्नकर्ता के लिए नहीं बोल सकता, लेकिन मुझे लगता है कि इसका मतलब है कि एक दूसरे से अकेले खड़े रहना - किसी एक फंक्शन को परिभाषित नहीं करना, फिर दूसरे में उसका इस्तेमाल करना। हालांकि, प्रत्येक स्निपेट को एक संपूर्ण कार्यक्रम होने की आवश्यकता नहीं है, यह बॉयलरप्लेट के int main() {}...बराबर मान सकता है जो इसे चलाएगा।

— TessellatingHeckler

15

सीजेम, 27 24 बाइट्स

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

-1 बाइट के लिए @ मार्टिनबटनर को धन्यवाद!

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

— डेनिस
स्रोत

12

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

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

प्रत्येक पंक्ति को व्यक्तिगत रूप से चलाया जाना चाहिए।

पहले 10 आत्म व्याख्यात्मक हैं: हम प्रत्येक प्लस के माध्यम से सेल के मूल्य में वृद्धि करते हैं।

42 बहुत अधिक जटिल है। यह इस तथ्य पर निर्भर करता है कि सबसे अधिक ब्रेनफैक दुभाषिया 8-बिट कोशिकाओं का उपयोग करता है, जिसका अर्थ है कि इस पर सभी ऑपरेशन मोडुलो 256 किए जाते हैं। --सेट सेल # 0 से 254। तब हम एक लूप दर्ज करते हैं जो सेल # 0 तक चलता है। 0. प्रत्येक प्रवाह 1 से सेल # 1 में जोड़ता है और 6 से सेल # 0 में जोड़ता है। यह लूप 43 बार चलता है, इसलिए सेल # 1 43 है। आखिरकार, हम इसे बनाने के लिए सेल # 1 से 1 घटाते हैं।

मुझे http://esolangs.org/wiki/Brainfuck_constants से अब तक का सबसे कुशल 42 मिला

— p1xel
स्रोत

1

@someonewithpc 4 और 2 42 से अलग है: ओपी का कहना है कि प्रत्येक स्निपेट का परिणाम एक वास्तविक संख्या में परिणाम होना चाहिए जो स्निपेट के रूप में उसी भाषा का उपयोग करके आगे की गणना के लिए उपयोग किया जा सकता है, अर्थात उस संख्या का प्रतिनिधित्व करने वाला एक टेक्स्ट स्ट्रिंग नहीं । आप 42 पर सीधे गणना कर सकते हैं, लेकिन यह अलग-अलग कोशिकाओं में 4 और 2 के लिए समान नहीं है।

— p1xel

ओह ठीक। मुझे वह याद आ गया था ..

— someonewithpc

12

अंधेरा , 339 303 बाइट्स

यह वह जगह है जहां अंधेरे वास्तव में चमकता है । उसे ले लो? : ~)!

मुद्रण के बिना ( \sपहली पंक्ति के साथ अंतरिक्ष को प्रतिस्थापित करें क्योंकि यह अन्यथा नहीं दिखाई देगा):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████

मुद्रण के साथ:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■

प्रत्येक पंक्ति को इस मामले में व्यक्तिगत रूप से चलाया जाना चाहिए क्योंकि कार्यक्रम प्रकाश (एक स्थान) में समाप्त होता है। हालांकि, एक ही कार्यक्रम में इसे एक या कई पंक्तियों पर लिखना संभव है।

नियमित अंधेरा (darkness) 1 से एक रजिस्टर बढ़ाता है, और ■ निर्देश (कुछ प्रकार के मिनी-अंधेरे) रजिस्टर की सामग्री को आउटपुट करता है।

— sweerpotato
स्रोत

मुझे नहीं लगता कि यह पूर्ण कार्यक्रमों के लिए पूछता है, सिर्फ स्निपेट।

— आउटगॉल्फ

12

पर्ल 5, 86 75 71 66 बाइट्स

सभी ^Fs शाब्दिक नियंत्रण वर्ण हैं (ASCII में 0x06), और इसलिए एक ही बाइट।

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

9 बाइट्स के लिए 11 बाइट्स और डॉम हेस्टिंग्स को बचाने के लिए msh210 का धन्यवाद !

— Doorknob
स्रोत

3

पर्ल अजीब है। zoitz.com/comics/perl_small.png

— ldam

डाउनग्रेड किया गया क्योंकि "अधिकतम sys फ़ाइल डिस्क्रिप्टर नंबर, 2 ऑन सभी डेन सिस्टम = 3" लेकिन मेरे पास 65+ है

— कैट

(मैं सिर्फ मजाक कर रहा हूं, मैं निश्चित रूप से उत्साहित हूं)

— बिल्ली

1

आप कभी एसई पोस्ट पर टिप्पणी पढ़ते हैं और सोचते हैं, "वाह, किस डंबास ने लिखा है कि"? वह मैं अभी, अपने आप पर।

— बिल्ली

!$[+ord$/ # -1 + 10- मुझे समझ नहीं आ रहा है। लाइन 2 में आप कहते हैं कि !$[आपको 1 देता है, ,1 नहीं, इसलिए यह स्निपेट 11. देता है

— टिमवी

10

MATL, 30 बाइट्स

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H,, Iऔर K2, 3, और 4 (जैसे pi) के लिए पूर्वनिर्धारित स्थिरांक हैं । Oऔर lऐसे कार्य हैं जो शून्य ( O) या लोगों के मैट्रिक्स को लौटाते हैं ( l), डिफ़ॉल्ट आकार 1x1 है। :एक वेक्टर बनाता है, और sइसे sums करता है, इसलिए K:s1 से 4 तक एक वेक्टर बनाता है और इसे पाने के लिए sums। 10. Yqn-th प्राइम फ़ंक्शन है, इसलिए KYq4 वां प्राइम, 7 है।

— डेविड
स्रोत

वह Yqकार्य (और उसका कार्यान्वयन) आपका बहुत अच्छा सुझाव था :-)

— लुइस मेंडू

IK+सिर्फ 7 के लिए काम करेगा, लेकिन यह थोड़ा उबाऊ है: पी

— डेविड

10

प्रोलोग, ११३ 99 बाइट्स

स्निपेट्स:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

गणितीय स्थिरांक को जोड़ती है e और piइंट में परिवर्तित विभिन्न तरीकों को ।

संपादित करें: 0-2 के लिए फ़्लोट्स का उपयोग करके 14 बाइट्स सहेजे गए।

— Emigna
स्रोत

1

ई / ई = 1 के साथ कुछ भी गलत?

— लेवल रिवर सेंट

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

— एमिग्ना

1

@steveverrill फ़्लोट ठीक हैं। हमें सिर्फ सही मूल्य चाहिए ।

— आदाम

9

PHP, 157 145 91 बाइट्स

पहली बार कोड गोल्फ पर पोस्टिंग, मुझे लगा कि मैं इसे एक शॉट दूंगा। मैं अंत में बेहतर हो जाऊंगा: P यदि आपको कोई स्पष्ट (आपको) स्पॉट दिखाई देता है जहां मैं पात्रों को बचा सकता हूं, तो मुझे बताएं।

संपादित करें: एहसास हुआ कि मुझे अर्धविरामों की आवश्यकता नहीं है, क्योंकि ये सिर्फ स्निपेट हैं।

EDIT2: कई सुझावों के लिए ब्लैकहोल को धन्यवाद!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

— ORP
स्रोत

5

PHP में बहुत सारे एक्सटेंशन हैं, और इसलिए इस चुनौती के लिए गणितीय लोगों की तुलना में बहुत अधिक पूर्वनिर्धारित स्थिरांक हैं;)। LC_ALL0 (-1 बाइट) के लिए, DNS_A1 के लिए (-3 बाइट्स), LOCK_NB4 के लिए (-3 बाइट्स), LC_TIME5 के लिए (-7 बाइट्स) के लिए, LOG_INFO6 (-8 बाइट्स) के लिए, INI_ALL7 (-5 बाइट्स) के लिए, ...

— ब्लैकहोल

5

… IMG_WBMP8 (-4 बाइट्स) के लिए, SQL_DATE9 (-9 बाइट्स) के लिए, SQL_TIME10 (-3 बाइट्स) के लिए और LOG_INFO*INI_ALL42 (-11 बाइट्स) के लिए। इसलिए कुल 51 बाइट बच गए! ये स्थिरांक विंडोज पर PHP 5.6.1 में कम से कम मान्य हैं।

— ब्लैकहोल

@ ब्लेकहोल LC_ALLएक स्थानीय निर्भर बात नहीं है?

— बिल्ली

@cat यह वास्तव में एक निरंतर उपयोग है जिसका उपयोग setlocale()सभी श्रेणियों के स्थानों को बदलने के लिए किया जाता है । लेकिन स्थिरांक का मूल्य निश्चित रूप से लोकेल से स्वतंत्र है :)।

— ब्लैकहोल

@ ब्लेकहोल आह, मैं देख रहा हूँ!

— बिल्ली

9

पायथन 2, 191 159 158 157 156 149 146 बाइट्स

मेरा पहला सबमिशन, मुझे आशा है कि मुझे सब कुछ सही मिला! मेरे द्वारा इस पर खर्च किए गए समय के आधार पर, मुझे लगता है कि उनमें से कुछ के लिए निश्चित रूप से बेहतर है।

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

FryAmTheEggman को बहुत धन्यवाद!

— जोआचिम जबलोन
स्रोत

PPCG में आपका स्वागत है :) मैं इस चुनौती के बारे में 100% निश्चित नहीं हूं लेकिन मुझे लगता है कि True1 के लिए एक मुहावरे के रूप में उपयोग करना स्वीकार्य होना चाहिए, क्योंकि मुझे नहीं पता कि जब वे स्निपेट के बराबर नहीं होते हैं।

— FryAmTheEggman

ओह, तुम सही हो! 1 के लिए इसका उपयोग नहीं कर रहा है, क्योंकि True is not 11 के आधार पर सभी गणना के लिए, यह मदद करता है! अब संपादन कर रहे हैं।

— जोकिम Jablon

1

का उपयोग करें #8 len(`id(id)`)। फिर 8, 9, और 10 छोटा होगा। साथ ही, इसे ऑनलाइन आज़माने के लिए हाइपरलिंक भी जोड़ सकते हैं ।

— mbomb007

आप len(`{()}`)11 बाइट्स के लिए 9 प्राप्त कर सकते हैं , और यह आपको 10 छोटे के माध्यम से 7 देता है।

— xnor

9

सी #, कोई usings, 234 बाइट्स

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

यह बहुत अधिक उबाऊ है जितना मैंने शुरू में सोचा था कि यह होने जा रहा था। मैं इस तरह के रूप में बहुत विविध विचारों, था new[]{true}.Lengthऔर true.GetHashCode()और typeof(int).Name.Lengthऔर uint.MinValueआदि, लेकिन new int()उन सब को हराया।

— Timwi
स्रोत

क्या नियम आपको कुछ करने var a = new int();और फिर aप्रत्येक स्निपेट में उपयोग करने की अनुमति देंगे ?

— ldam

@LoganDam: मुझे यह अधिक दिलचस्प लगता है अगर हर अभिव्यक्ति को अपने दम पर खड़ा होना है। इसीलिए मैंने किसी भी usingघोषणा का उपयोग नहीं किया ।

— तिमवी

वो क्या हैं जो 9/10/42 के लिए हैं: Oo

— ev3commander

@ ev3commander: वे एमएसकोरलिब में परिभाषित सबसे छोटे नाम वाले मान हैं जो आवश्यक पूर्णांक मान रखते हैं। ConsoleKey.Tab के लिए, मान 9 आश्चर्यजनक नहीं है (9 टैब वर्ण का ASCII भी है)। दूसरे शायद मनमानी कर रहे हैं।

— तिमवी

8 के लिए एक छोटा:int a=-~-~new int();a<<a

— LegionMammal978

9

पॉवरशेल, 147 बाइट्स

ये +पूर्णांक के लिए चीजों को निहित करने के लिए उपयोग करते हैं। बाद के नंबर्स पॉवरशेल के .Net फ्रेमवर्क अनरपिनिंग से एनम का उपयोग करते हैं जो सही मान रखते हैं।

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

-~-~-~जावास्क्रिप्ट में इस्तेमाल किया, C # और PHP जवाब - -bnot - -bnot - -bnotPowerShell में होगा ।
x^yपर्ल जवाबों में, या x**yपायथन या जावास्क्रिप्ट ES7 में उपयोग किया जाने वाला प्रतिपादक होगा[Math]::Pow($x,$y)
स्थिरांक ई और पाई चरित्र-भारी हैं [Math]::Eऔर[Math]::PI

— TessellatingHeckler
स्रोत

x^yजावास्क्रिप्ट में xor है जावास्क्रिप्ट (ईएस 7) **के प्रतिपादकों के लिए है। स्रोत

— mbomb007

@ mbomb007 आह, धन्यवाद - मैंने उस पर अपना नोट अपडेट कर दिया है।

— TessellatingHeckler

@ mbomb007 मुझे अब भी लगता है कि यह मूर्खतापूर्ण है

— SuperJedi224

@ SuperJedi224 क्यों? पाइथन यही करता है। और Xor एक महत्वपूर्ण ऑपरेटर है।

— mbomb007

8

डीसी , 35 बाइट्स

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

स्निपेट्स का परीक्षण fकरने के लिए स्टैक को प्रिंट करने के लिए एक को जोड़ दें और उस स्ट्रिंग को पास करें dc:

$ echo 'EdE++f' | dc
42

— हिममानव
स्रोत

मेरा मानना है कि यहाँ Eऔर Fअंक भी हैं (तब भी जब वे इनपुट मूलांक से अधिक होते हैं)। इसके लिए साक्ष्य यह है कि वे अंकों के रूप में संयोजित होते हैं; जैसे F0-> 150। इनपुट और आउटपुट मूलांक बदलने के बाद आप दशमलव अंकों के साथ समान व्यवहार देख सकते हैं।

— टॉबी स्पाइट

समान सामान का उपयोग करके बहुत सारे अन्य उत्तर हैं ... मुझे केवल एक ही क्यों होना चाहिए जहां यह ठीक नहीं है?

— यति

आपको ऐसा नहीं करना चाहिए - यदि अंकों का उपयोग करने वाले अन्य समाधान हैं, तो वे मान्य उत्तर नहीं हैं।

— टोबे स्पाइट

1

मैं किसी भी अधिक परवाह नहीं है! Codegolf भी कार्य का हल एक ascii कला मैंडलब्रॉट प्रोग्राम लिखने के लिए के रूप में एक ग्राफिक मैंडलब्रॉट सेट कार्यक्रम को स्वीकार करता है ... codegolf एक बड़ा रीसेट की आवश्यकता है और जब पुन: प्रारंभ मैं या नियमों के बारे में फिर से परवाह नहीं हो सकता है ...: मई

— हिममानव

7

टीआई-बेसिक, 41 बाइट्स

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

TI-BASIC में, सभी एकरचनात्मक एकल-अक्षर चर 0 पर शुरू होते हैं, और Xmax (ग्राफ़ स्क्रीन की दाईं खिड़की की सीमा) 10 से शुरू होती है।

गणितीय स्थिरांक πहै एक बाइट , लेकिन eदो बाइट्स है।

— lirtosiast
स्रोत

क्या संख्यात्मक डेटा नहीं माना जाता है?

— vsz

@vsz शायद, लेकिन यह एक नंबर शाब्दिक नहीं है। सेशन भी ऐसा कहता है।

— SuperJedi224

@NBZ बहुत अच्छी बात है। मेरी गलती।

— GamrCorps

6

पायथन 2, 306 275 274 बाइट्स

मैंने इस तथ्य का उपयोग किया कि किसी भी एक्स (पूर्णांक और 0 नहीं) के लिए अभिव्यक्ति x/x1 के बराबर होती है और कुछ बिटवाइज़ ऑपरेशंस के साथ खेली जाती है।

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

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

— ბიმო
स्रोत

आप बाइट्स को बचा सकते हैंi=id(id);r=~i/i

— Cycece

6

गणित ++, 92 बाइट्स कुल

0 (1 बाइट्स): a

1 (2 बाइट्स):!a

2 (3 बाइट्स):_$e

3 (4 बाइट्स): _$pi

4 (7 बाइट्स): _$e+_$e

5 (8 बाइट्स): _($e+$e)

6 (9 बाइट्स): _$pi+_$pi

7 (8 बाइट्स): _($e*$e)

8 (9 बाइट्स): _($e*$pi)

9 (10 बाइट्स): _($pi*$pi)

10 (12 बाइट्स): _$e*_($e+$e)

42 (19 बाइट्स): _($pi+$pi)*_($e*$e)

— SuperJedi224
स्रोत

5

जावास्क्रिप्ट (ब्राउज़र एनवी), 155 136 130 बाइट्स

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

इसके लिए धन्यवाद:
@ इस्माइल मिगुएल : 155 -> 136 -> 130 बाइट्स

— usandfriends
स्रोत

1

आप -~[]+[]+-[]उत्पादन करने के लिए उपयोग कर सकते हैं 10। यह एक स्ट्रिंग लौटाएगा, लेकिन यह अभी भी एक संख्या के रूप में उपयोग करने योग्य है। इसके अलावा, आप (-8 बाइट्स) की -~(top+top.s).lengthगणना करने 42और Google Chrome पर अपनी निर्भरता छोड़ने के लिए उपयोग कर सकते हैं । अधिक 3 बाइट्स बचाने के लिए, (P=Math.PI)*P>>+[]9 की गणना करें।

— इस्माइल मिगुएल

1

क्षमा करें, कुछ बाइट्स भूल गए आप शेव कर सकते हैं। आप ~(~[]+[]+-[])जेनरेट करने के लिए उपयोग कर सकते हैं 9। कि कुछ और बाइट्स में कटौती करनी चाहिए।

— इस्माईल मिगुएल

उत्सुकता से, +[12]देता है 12और +[1, 2]देता है NaN। मुझे JS से नफरत है

— cat

2

@ यह जावास्क्रिप्ट की अजीब कास्ट सिस्टम के कारण है। Arrays को तार की तरह [1,2,3]=> पर ले "1,2,3"जाया जाता है और स्ट्रिंग "12"=> जैसे संख्याओं में डाली जाती हैं, 12लेकिन यदि स्ट्रिंग में गैर-संख्या वर्ण हैं, तो रिटर्न मिलता है NaN। +[1,2]एक स्ट्रिंग पर जाती है फिर एक संख्या लेकिन स्ट्रिंग में एक अल्पविराम होता है इसलिए "1,2"बन जाता है NaN।

— user81655

@ user81655 कि है। भयंकर।

— बिल्ली

5

गंभीरता से, 39 33 बाइट्स

कोष्ठक में सामग्री स्पष्टीकरण है:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

कार्यक्रमों के Hexdumps:

6 बाइट्स के लिए क्विंटोपिया का धन्यवाद!

— मेगो
स्रोत

1

मुझे लगता है कि गंभीर रूप से एक 256 char कोडपेज का उपयोग करता है जिसमें छद्म ग्राफिक वर्ण शामिल हैं?

— Adám

2

@NBZ CP437

— Mego

आप 6 बाइट पर Hl save

— quintopia

— यूए के

HlPD42 पर 2 बाइट्स QlPबचाता है, और 7 पर एक बाइट बचाता है, और Qlª9 पर एक बाइट बचाता है, और Ql╙8. पर एक बाइट बचाता है। मुझे लगता है कि सभी 33 बाइट्स के नीचे गंभीरता से हो जाता है, Pyth को बांधने।

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

5

डीसी, 42 बाइट्स

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

परिणाम

डीसी के साथ नए नंबर उत्पन्न करने के कई तरीके नहीं हैं। मैं उपयोग करता हूं O: आउटपुट बेस, शुरू में 10; K: परिशुद्धता, शुरू में 0; zढेर की गहराई, शुरू में 0; Zऑपरेंड के महत्वपूर्ण अंक। हम इन्हें सामान्य अंकगणितीय ऑपरेटरों के साथ जोड़ते हैं।

परीक्षण कार्यक्रम

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

— टोबी स्पाईट
स्रोत

4

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

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

मुझे पूरा यकीन है कि इनमें से कुछ सबॉप्टीमल हैं। वे गोल कोष्ठक वास्तव में महंगे हैं।

स्थिरता के लिए, पहले दो भी हो सकते हैं E-Eऔर E/Eनिश्चित रूप से, लेकिन मुझे लगा कि अपरिभाषित चर के साथ एक संगणना से 0और इसे पाने के लिए काफी निफ्टी है 1।

— मार्टिन एंडर
स्रोत

@NBZ क्षमा करें, भूल गए 0। यदि बाद aमें मान मिलता है 0, तो यह कोई मुद्दा नहीं है, जब तक कि इसका a/aमूल्यांकन नहीं किया जाता है।

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

@ एनबीजेड बाइट काउंट केवल यूटीएफ -8 बाइट काउंट है।

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

4

जाप , ३४ 33 30 बाइट्स

1 बाइट ने @ThomasKwa को धन्यवाद दिया

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

यहाँ विभिन्न वर्णों में से प्रत्येक का अर्थ है:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

— ETHproductions
स्रोत

क्या Japt डिफ़ॉल्ट रूप से हेक्साडेसिमल संख्या लेता है? यदि ऐसा है, तो एफ के माध्यम से एक संख्यात्मक शाब्दिक होगा ...

— Adám

@ एनबीजेड A-Iवे चर हैं जो डिफ़ॉल्ट रूप से, विभिन्न संख्याओं को सौंपे जाते हैं, जैसा कि ऊपर दिखाया गया है। A-F10-15 को सौंपा है। क्या यह उन चरों को अमान्य करता है?

— ETHproductions

नहीं, मैं सोच रहा था कि, 12AB3 वैध था। अब मुझे पता है कि यह नहीं है। यहां कोई शाब्दिक नहीं, साथ चलते हैं। :-)

— एडम डे

4

मारबेलस , 98 बाइट्स

बहुत रोमांचक नहीं है, यह पर निर्भर करता है ?n उपकरणों है जो किसी भी संगमरमर को यादृच्छिक मान में बदल देते हैं 0..n (समावेशी) इसका एक दुष्प्रभाव यह है कि?0 किसी भी संगमरमर को इनपुट की परवाह किए बिना 0 में बदल देता है। मुझे लगता है कि शाब्दिक के उपयोग की अनुमति है क्योंकि मूल्य परिणाम को प्रभावित नहीं करता है और मारबुलस में एक बार फ़ंक्शन को कॉल करने का कोई अन्य तरीका नहीं है।

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

— overactor
स्रोत

यह निश्चित लगता है कि 0 ... L न्यूमेरिकल शाब्दिक हैं।

— Adám

2

@NBZ वे नहीं हैं, आप उन्हें स्वतंत्र रूप से उपयोग नहीं कर सकते। +0 थ्रू + जेड बिल्ट फ़ंक्शंस की तरह हैं। यह उबाऊ है लेकिन वैध है।

— ओवरएक्टर

4

> <> , 86 बाइट्स

0: ln;
1: lln;
2: llln;
3: lll+n;
4: lll:+n;
5: llll+n;
6: llll++n;याllll:+n;
7: lllll+n;
8: lllll:+n;
9: lllll++n;याllllll+n;
10: llll+:+n;याlll:l+*n;
42: llll*ll+*n;

अपने शाब्दिक प्राप्त करने के लिए स्टैक आकार पर निर्भर करता है।

— हारून
स्रोत

आप शायद nप्रत्येक को हटा सकते हैं क्योंकि स्टैक-आधारित भाषाओं में फ़ंक्शन -11 बाइट्स के लिए स्टैक पर आउटपुट छोड़ सकते हैं ।

— redstarcoder

@redstarcoder तो मैं ;कुल 22 बाइट्स के लिए भी निकाल सकता था और पंक्ति के अंत में पहुंच गए फ़ंक्शन के अंत पर विचार कर सकता था, लेकिन यह थोड़ा अस्पष्ट है क्योंकि ><>इसमें आउट-ऑफ-द-बॉक्स फ़ंक्शन नहीं हैं।

— एरोन

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

— हारून

मैंने वास्तव में आपके पोस्ट को पहले देखा है, और अच्छा काम किया है! मैंने कार्यों की अस्पष्टता के बारे में एक मेटा पोस्ट किया । मैं जो कह रहा हूं वह यह है कि आम तौर पर अनुमति दी जाती है, के साथ ;। मेरे द्वारा छोड़ने ;का कारण यह है क्योंकि अन्यथा फ़ंक्शन के बिना समाप्त होने का कोई तरीका नहीं है .। ज्यादातर लोग इस मेले पर विचार करने लगते हैं, लेकिन यदि आप चिंतित हैं तो मैं यहां एक विशिष्ट मेटा पोस्ट लिखने की कोशिश कर सकता हूं ।

— redstarcoder

1

@redstarcoder जानकारी के लिए धन्यवाद! मुझे लगता है कि ><>स्निपेट्स को प्रत्यय देना .फ़ंक्शन की परिभाषा से चिपके रहने का सबसे अच्छा तरीका होगा जैसा कि मेटा पोस्ट के सबसे उत्कीर्ण उत्तर में वर्णित है, हालांकि मैं मानता हूं ;कि एक अच्छा विकल्प है जिसे कम स्पष्टीकरण की आवश्यकता होती है।

— हारून

4

एमएस एक्सेल सूत्र, 163 151 150 143 बाइट्स

बिल्कुल नहीं एक प्रोग्रामिंग भाषा, लेकिन यहाँ यह जाता है ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()अधिकांश मामलों में इसका उपयोग किया जाता है क्योंकि यह संख्या (स्ट्रिंग शाब्दिक) का उपयोग किए बिना संख्यात्मक मान प्रस्तुत करने का सबसे छोटा तरीका है (जो मुझे पता है)। Nविभिन्न चीजों (संख्याओं) को संख्याओं में Tपरिवर्तित करता है , और विभिन्न चीजों को पाठ में परिवर्तित करता है। TYPEपाठ तर्क के लिए 2 और बूलियन तर्क के लिए 4 रिटर्न। TRUNCभिन्नात्मक भाग (यानी राउंड पॉजिटिव नंबर डाउन), EVENअगले ODDराउंड नंबर तक राउंड और अगले विषम नंबर तक राउंड। CODE(-PI())रूपांतरण के पहले अक्षर का ASCII कोड है-code, यानी 45 ("-" के लिए)।

EDIT: बाइट काउंट (-12!) से समान संकेत हटाए गए - जैसा कि टिप्पणियों में Nᴮᶻ द्वारा बताया गया है, उन्हें शामिल नहीं किया जाना चाहिए।

EDIT 2: शेष वर्कशीट को खाली मानते हुए, रिक्त सेल के संदर्भ को शून्य के रूप में उपयोग करना संभव है (फिर से, Nᴮᶻ द्वारा सुझाया गया) बशर्ते कि हम एक माइनस साइन (या इसे अन्य संख्यात्मक अभिव्यक्ति में उपयोग करें) को हल करने के लिए शामिल करें प्रकार अस्पष्टता।

— dnep
स्रोत

0=Z9

— एडम

एस हटा दिया =, धन्यवाद। आपके सुझाव के बारे में, मैंने यह सुनिश्चित करने के लिए सेल के संदर्भों को टाल दिया कि यह सुनिश्चित करने के लिए कि सूत्र तालिका की सामग्री से स्वतंत्र हैं - यदि Z9कोई पाठ शामिल है, =Z9तो अब शून्य नहीं लौटेगा। मैंने मेज के बारे में कुछ भी नहीं मानने का फैसला किया।

— dnep

वैसे भी, तुमने मुझे फिर से लूट लिया, और मैंने महसूस किया कि मैं कम से कम 1 बाइट बचा सकता था 0 को उसी तर्क का उपयोग करके जो मैंने 1 का इस्तेमाल किया ...

— dnep

लेकिन कुछ भाषाओं में सभी चर 0 पर सेट होते हैं यदि वे किसी और चीज़ के लिए सेट नहीं हैं। इस संदर्भ में, मैं एक्सेल को एक भाषा के रूप में (सैद्धांतिक रूप से अनंत) मेमोरी सेल्स A1: ZZZ ..: 999 ... और प्रोग्राम कोड और डेटा (यानी सेल्फ-मॉडिफाइंग) के बीच कोई अंतर नहीं देखूंगा। चूंकि प्रत्येक स्निपेट दूसरों से स्वतंत्र है, इसलिए मुझे लगता है कि यह A1 में है, और बाकी शीट यह खाली है। (कार्यक्रमों के लिए, मेरे पास प्रत्येक सेल A1, A2, आदि में एक पूरा विवरण होगा)

— Adám

मैं आपकी बात देख रहा हूं ... लेकिन सेल संदर्भों के साथ एक और समस्या है: Z9एक खाली शीट पर एक खाली मूल्य है जिसे 0कई मामलों में परिवर्तित किया जाता है, लेकिन ""कुछ अभिव्यक्तियों में उपयोग किए जाने पर (खाली स्ट्रिंग) में परिवर्तित किया जा सकता है - बहुत पसंद एक VBA अनधिकृत रूप से भिन्न होता है - इसलिए यह कड़ाई से समकक्ष नहीं है 0। उदाहरण के लिए, = 0&"a" मूल्यांकन किया जाता है, "0a"लेकिन = Z9&"a"मूल्यांकन करता है "a"। इसे हल किया जा सकता है, हालांकि -संदर्भ में एक यूनरी जोड़कर (इस प्रकार यह संख्यात्मक होने के लिए मजबूर करता है - फिर से, VBA की तरह)। तो शून्य के रूप में इस्तेमाल किया -Z9 जा सकता है। मैंने अभी जवाब अपडेट किया है। एक बार फिर धन्यवाद।

— dnep

4

डीयूपी , 68 बाइट्स

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

ऐसा करने के लिए बहुत सारे तरीके हैं, लेकिन मैं इस एक के लिए रिटर्न स्टैक का दुरुपयोग कर रहा हूं।

व्याख्या

इसका पूरी तरह से पता लगाने के लिए, आपको लैम्ब्डा के बारे में डीयूपी के व्यवहार को समझने की आवश्यकता है। लैम्ब्डा को स्टैक में धकेलने के बजाय, यह वास्तव में लैम्ब्डा का पता लगने पर स्टैक के वर्तमान आईपी को धकेलता है। यह पहले 3 स्निपेट की व्याख्या कर सकता है, जिसमें लंबोदर शामिल हैं।

अगले स्निपेट रिटर्न स्टैक का उपयोग करते हैं। जब !निष्पादित किया जाता है, तो वर्तमान आईपी को रिटर्न स्टैक पर धकेल दिया जाता है, और स्टैक के शीर्ष को लंबर निष्पादन शुरू करने के लिए नए आईपी के रूप में सेट किया जाता है। )डेटा स्टैक पर रिटर्न स्टैक से एक नंबर को पॉप करता है।

बाकी स्निपेट्स की व्याख्या करने के लिए यह काफी पर्याप्त है। यदि आप अभी भी इसे प्राप्त नहीं करते हैं, तो ध्यान रखें कि Stepबटन काफी उपयोगी है!

— मामा फन रोल
स्रोत

4

05AB1E, 40 38 24 बाइट्स

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

धक्का counter_variable
धक्का १
धक्का २
पुश 1 + 2
पुश 2 * 2
पुश 10/2
पुश (10/2) +1
पुश (10/2) +2
पुश 10-2
पुश 10-1
धक्का १०
32, 10, पुश करें

— acrolith
स्रोत

1

Y·की तुलना में अधिक स्टैक-क्लीन है Yx, यहां के Xबजाय इसका उपयोग किया जा सकता ºहै (यह चूक 1, ºसाधन len(stack)>1, इसलिए यह किसी भी चीज के लिए डिफ़ॉल्ट नहीं है)। इसके अलावा, आपका बाइटकाउंट 24 है, 35 नहीं (CP-1252, newlines गिनती नहीं है अगर वे अलग-अलग स्निपेट हैं)।

— आउटगॉल्फ

मुझे पता है कि जब आप इसे पोस्ट करते हैं, तो यह संभव नहीं था, लेकिन ₆tएक बाइट को बचाने के लिए 6 अब (पुश 36, वर्ग-मूल) हो सकता है ( इसे ऑनलाइन आज़माएं )।

— केविन क्रूज़सेन

3

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

प्रत्येक पंक्ति एक अलग स्निपेट है।

कार्यक्रम में संख्याओं को संख्या शाब्दिक के रूप में नहीं गिना जाता है क्योंकि वे केवल कमांड के रूप में उपयोग किए जाते हैं।

अंतिम निश्चित रूप से अधिक गोल्फ हो सकता है।

संपादित करें: मुझे दुभाषिया काम कर रहा है और सभी स्निपेट काम करते हैं। यदि आप स्वयं परीक्षण करना चाहते हैं, 0f0fतो स्निपेट के अंत में जोड़ें ताकि कार्यक्रम समाप्त हो जाए।

— ASCIIThenANSI
स्रोत

6

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

— मेघ

2

क्या आप बता सकते हैं कि वे कैसे काम करते हैं?

— अड्म

@NBZ D1ffe7e45e दो हेक्साडेसिमल संख्याओं के बीच के अंतर के आधार पर काम करता है। उस अंतर को तब एक कमांड में व्याख्यायित किया जाता है। उदाहरण के लिए, 0 और 2 के बीच का अंतर 2 है, जिसे वेतन वृद्धि कमांड के रूप में समझा जाता है (जैसे +ब्रेनफ ** के)। मैंने सोचा था कि चूंकि वे कमांड के रूप में उपयोग किए जा रहे हैं और संख्या शाब्दिक नहीं हैं जो अब भी गिने जाते हैं। यदि ऐसा नहीं होता तो मैं उत्तर हटा दूंगा।

— ASCIIThenANSI

@ मैगो मैं दुभाषिया काम कर रहा है और मेरे कोड काम करता है। उपरोक्त टिप्पणी देखें कि मुझे क्यों लगता है कि वे शाब्दिक नहीं हैं।

— ASCIIThenANSI

1

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

— डेनिस

3

पायथ, 35 34 33 बाइट्स

-1 बाइट @ मिमिक द्वारा

कुछ कार्यक्रमों के लिए कई संभावनाएं हैं।

0, 1 बाइट

1, 2 बाइट्स

hZ
!Z

2, 3 बाइट्स

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 बाइट्स

l`d

4, 3 बाइट्स

l`b
eCN

5, 4 बाइट्स

hl`b
telG

6, 3 बाइट्स

elG

7, 4 बाइट्स

tttT
helG

8, 3 बाइट्स

ttT

9, 2 बाइट्स

tT

10, 1 बाइट

42, 4 बाइट्स

yhyT

इन सभी में बुनियादी डबल ( y), +1 ( h) और -1 ( t) कमांड, या l(स्ट्रिंग की लंबाई) शामिल हैं। Z वैरिएबल को शून्य पर आरंभीकृत किया गया है।

5 के लिए, bएक नवागंतुक चरित्र के लिए आरंभिक है। बैकटिक देता है"\n" (उद्धरण सहित, और उस स्ट्रिंग की लंबाई 4 है।

उन्हें यहाँ की कोशिश करो !

— lirtosiast
स्रोत

उपयोगकर्ता Mimarik ने 42 के साथ एक बाइट को बचाने का सुझाव दिया yhyT। (मैंने मेटा.कोडगॉल्फ.स्टैकएक्सचेंज.com/questions/1615/… ) के अनुसार संपादन को अस्वीकार कर दिया

— मार्टिन

कोई तार (या संख्या) संलग्न नहीं है

वैध स्निपेट के उदाहरण

अमान्य स्निपेट के उदाहरण

सामान्य प्रश्न

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

फंकिटॉन , 1222 बाइट्स

0 (UTF-16 में 40 बाइट्स)

UTF-16 में 1 (52 बाइट्स)

2 (UTF-16 में 70 बाइट्स)

यूटीएफ -16 में 3 (88 बाइट्स)

4 (यूटीएफ -16 में 88 बाइट्स)

5 (यूटीएफ -16 में 106 बाइट्स)

6 (UTF-16 में 106 बाइट्स)

7 (UTF-16 में 110 बाइट्स)

8 (यूटीएफ -16 में 118 बाइट्स)

9 (UTF-16 में 128 बाइट्स)

यूटीएफ -16 में 10 (146 बाइट्स)

42 (यूटीएफ -16 में 170 बाइट्स)

जावास्क्रिप्ट, 144 141 140 138 132 125 123 बाइट्स

माउस- 2002 , 27 26 17 14 बाइट्स

सीजेम, 27 24 बाइट्स

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

अंधेरा , 339 303 बाइट्स

पर्ल 5, 86 75 71 66 बाइट्स

MATL, 30 बाइट्स

प्रोलोग, ११३ 99 बाइट्स

PHP, 157 145 91 बाइट्स

पायथन 2, 191 159 158 157 156 149 146 बाइट्स

सी #, कोई usings, 234 बाइट्स

पॉवरशेल, 147 बाइट्स

डीसी , 35 बाइट्स

टीआई-बेसिक, 41 बाइट्स

पायथन 2, 306 275 274 बाइट्स

गणित ++, 92 बाइट्स कुल

जावास्क्रिप्ट (ब्राउज़र एनवी), 155 136 130 बाइट्स

गंभीरता से, 39 33 बाइट्स

डीसी, 42 बाइट्स

परिणाम

परीक्षण कार्यक्रम

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

जाप , ३४ 33 30 बाइट्स

मारबेलस , 98 बाइट्स

> <> , 86 बाइट्स

एमएस एक्सेल सूत्र, 163 151 150 143 बाइट्स

डीयूपी , 68 बाइट्स

व्याख्या

05AB1E, 40 38 24 बाइट्स

D1ffe7e45e , 112

पायथ, 35 34 33 बाइट्स