यह मजेदार था! हालाँकि केवल तीन अंकों के साथ, मज़ा बहुत जल्द खत्म हो गया। यह चुनौती समान है, लेकिन हम मज़े लेते रहेंगे।

चुनौती

संभव के रूप में गोल्डन अनुपात Print के कई अंकों के रूप में प्रिंट करें । गोल्डन रेशियो को उस संख्या के रूप में परिभाषित किया जाता है जो φ = (1 + 1) / ies को संतुष्ट करती है और पहले 100 अंक निम्न द्वारा दिए गए हैं:

1,6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

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

प्रतिबंध

अपने आप से, φ के अंकों को प्रिंट करना थोड़ा सरल होगा, इसलिए यहां नियम हैं:

आपको संख्या को बाएं से दाएं क्रम में बनाना है , या तो इसे टुकड़ा से प्रिंट करके या बाएं से दाएं एक स्ट्रिंग का निर्माण करके इसे अंत में प्रिंट करना है - आप अंकों का एक सरणी भी उत्पन्न कर सकते हैं और फिर इसे जोड़ सकते हैं और इसे तब तक प्रिंट करें, जब तक आप इसे क्रम में करते हैं। निम्नलिखित नियमों में "प्रिंट" और "आउटपुट" उन प्रक्रियाओं में से किसी को संदर्भित कर सकते हैं (जैसे कि यदि आप एक स्ट्रिंग का निर्माण कर रहे हैं, और स्ट्रिंग में पहले से मुद्रित 1.6होने के रूप में मायने रखता है 1.6)।
आपके कोड के लिए आपको प्रति अंक 15 वर्णों का बजट मिलता है । उस बजट की अवधि की गणना नहीं की जाती है, लेकिन इसे भी मुद्रित किया जाना है। ध्यान दें कि प्रतिबंध केवल कुल कोड आकार पर है: आप किसी भी अंक के लिए 15 से अधिक वर्णों का उपयोग कर सकते हैं जब तक कि आप औसत पर अधिक उपयोग न करें। वास्तव में, आप वर्णों में "ऋण" का निर्माण कर सकते हैं और बाद में इसका भुगतान कर सकते हैं। उदाहरण के लिए 1.618आपके पास ६० अक्षर हैं।
मानक-पुस्तकालय में कोड आकार के लिए / आयात शामिल नहीं हैं। लेकिन आप उन लोगों को मुफ्त में आशुलिपि के अलाउंस नहीं दे सकते हैं!
आप वर्तमान में जो अंक उत्पन्न कर रहे हैं, उसका उपयोग नहीं करना चाहिए, और न ही आपने पहले से ही छपवाया है। ईजी 1आपके स्रोत कोड में कहीं भी दिखाई दे सकता है, क्योंकि यह बहुत पहला अंक है। कोड जो आउटपुट करता 8है 1.618वह किसी भी या सभी अंकों का उपयोग कर सकता है [0234579], लेकिन कोई भी नहीं [168]। इस प्रयोजन के लिए, सभी शाब्दिक जो कि एक अंक के बराबर हैं, को उस अंक के रूप में माना जाता है । इसलिए यदि आपकी भाषा का प्रतिनिधित्व कर सकते हैं 9क्योंकि '\t'आपको कहीं भी उपयोग करने की अनुमति नहीं है, जहां आप 9इसके बजाय उपयोग नहीं कर सकते ।
आपको एक साथ कई अंक नहीं बनाने चाहिए। एक बार में एक अंक उत्पन्न करने वाले अपने कोड को स्पष्ट रूप से विखंडित करना संभव होना चाहिए।
आपको किसी भी अंतर्निहित फ़ंक्शन, गणितीय / बूलियन / बिट-वार / स्ट्रिंग ऑपरेटर, चर या निरंतर का उल्लेख नहीं करना चाहिए जो आपने उस कोड में उपयोग किया है जो एक पूर्व अंक उत्पन्न करता था। अपवाद पूर्णांक-से-स्ट्रिंग रूपांतरण, स्ट्रिंग संयोजन और मुद्रण कार्य हैं जो आपको हर एक अंक के लिए आवश्यक हो सकते हैं। ध्यान दें कि इससे कोई फर्क नहीं पड़ता कि आप किस नाम से किसी अंतर्निहित का उल्लेख करते हैं: सिर्फ इसलिए कि आप PIदोनों को एक अंतर्निहित खाता बनाते हैं pऔर qइसका मतलब यह नहीं है कि आपको pएक बार और qएक बार उपयोग करना है । इसी तरह, आप कर रहे हैं एक नाम दो बार उपयोग करने के लिए अगर यह स्ट्रिंग की तरह, दो अलग अलग बनाया-इन को संदर्भित करता है की अनुमति दी lengthऔर सरणी length।

_{यदि आपकी प्रोग्रामिंग लैंग्वेज में फ़ंक्शंस नहीं हैं, तो आपके सबसे अच्छे निर्णय का उपयोग इस बात के लिए किया जाएगा कि समतुल्य क्या है - उदाहरण के लिए बैश स्क्रिप्टिंग के लिए, अन्य प्रोग्रामों को लागू करने के लिए फ़ंक्शंस पर लगाए गए नियमों का पालन करना चाहिए।}
आपका सबमिशन एक ही भाषा में लिखा जाना चाहिए। इसलिए उस भाषा के बिल्ट-इन तक पहुँच पाने के लिए किसी अन्य भाषा के दुभाषिए को क्रियान्वित नहीं करना।

निहितार्थ

निम्नलिखित नियम उपरोक्त नियमों द्वारा निहित हैं, लेकिन मैं उन्हें यहां उन सवालों से बचने के लिए जोड़ता हूं जो पहले ही सैंडबॉक्स में आ चुके हैं ::

आपको '\b'बीच में कुछ बैकस्पेस (आमतौर पर ) को प्रिंट करके अपने आउटपुट के कुछ हिस्सों को ओवरराइट करने की अनुमति नहीं है ।
लूप जो कई अंकों को उत्पन्न / आउटपुट करते हैं, निषिद्ध हैं। (एक अंक की गणना करने वाले लूप ठीक होते हैं, हालांकि)
(1 + √5)/2किसी एक से अधिक अंक प्राप्त करने के लिए एक अस्पष्ट संस्करण का उपयोग करना या फिबोनाची संख्याओं को विभाजित करना निषिद्ध है।
आप 10 अंकों को पहले से निर्धारित नहीं कर सकते हैं और उन्हें 10 चर में संग्रहीत कर सकते हैं और फिर उन का संदर्भ ले सकते हैं, क्योंकि वे चर संदर्भ न तो अंक उत्पन्न करते हैं - जो कोड चर को भरता है, इसलिए यह नियम 6 का उल्लंघन है।
वास्तव में, आप किसी भी पिछले (या मध्यवर्ती परिणाम) का पुन: उपयोग नहीं कर सकते, क्योंकि इसका मतलब होगा कि दो अंक उत्पन्न होने के लिए कोड साझा करेंगे ।
अन्यथा, आप अंकों को उत्पन्न करने के लिए किसी भी तरह (जो कि विशुद्ध रूप से गणितीय नहीं है) का उपयोग कर सकते हैं। (और आपको करना चाहिए!)
वास्तव में कुछ भी गणना करने की आवश्यकता नहीं है, यदि आप अपने मानक पुस्तकालय का उपयोग करके कई अलग-अलग स्थानों से सही अंक निकाल सकते हैं।
आप एकल अंक उत्पन्न करते समय कई बार ऑपरेटर का उपयोग कर सकते हैं, इसलिए 2+2+2पहला उत्पन्न करने के लिए उचित खेल है 6(हालांकि यह सबसे कम संभावना नहीं है)।
आप कर सकते हैं , जैसा कि अक्सर आप चाहते हैं के रूप में किसी भी शाब्दिक उपयोग करें, क्योंकि वे निर्मित नहीं कर रहे हैं स्थिरांक। तो जब तक आपको प्रिंट नहीं करना है 5, तब तक आप 5अपने कोड में बहुत से एस चाहते हैं।
आप आउटपुट को हार्डकोड नहीं कर सकते, क्योंकि इसमें आपके द्वारा आउटपुट किए जा रहे अंकों का उपयोग करना शामिल होगा।

संक्षेप में: दो बार अंक उत्पन्न करने की किसी भी विधि का उपयोग न करें और उस अंक का उपयोग न करें जो आप वर्तमान में आउटपुट कर रहे हैं या किसी ने पहले ही प्रिंट कर लिया है।

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

स्कोरिंग

वह प्रोग्राम जो सबसे अधिक अंकों को प्रिंट करता है, सही तरीके से जीतता है। एक टाई के मामले में कम कोड टाई को तोड़ देता है।

कृपया एक असम्बद्ध टिप्पणी संस्करण जोड़ें जो आपके कोड के किस हिस्से को पहचानता है कि कौन सा अंक उत्पन्न करता है।

पुनश्च: यदि कोई 100 अंकों के ऊपर धड़कता है, तो यहां कुछ और हैं ।

code-challenge number restricted-source

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

टिप्पणियाँ शुद्ध; कृपया मुझे किसी भी संभावित खो जानकारी के लिए सूचित करें।

— दरवाज़े

"एक ओफ़्फ़ुसेटेड संस्करण का उपयोग करना ..." यह सिर्फ x = (x+1)/x(या x^2 = x+1) (या x^2-x+1) पर द्विघात सूत्र का उपयोग कर रहा है ।

— कोल जॉनसन

.... क्या मैं एक से अधिक बार कार्यान्वयन-परिभाषित ऑपरेटर का उल्लेख कर सकता हूं?

— स्टैकस्टॉक

क्या मैं असाइनमेंट का पुन: उपयोग कर सकता हूं?

— स्टैकस्टॉक

18

PHP, 100 अंक

मैं शायद नियमों को थोड़ा सा यहाँ झुका रहा हूँ, लेकिन PHP में दर्जनों स्थिरांक हैं जिन्हें चुनना है:

<?php
echo TRUE . '.' . PM_STR . DNS_A . MSG_EOR . LC_ALL . T_FMT . LOCK_UN . SQL_DATE
. E_NOTICE . IMG_WBMP . INI_ALL . E_PARSE . SOCKET_EBADF . LOG_USER .
IMAGETYPE_JPC . IMG_PNG . GLOB_MARK . LOCK_NB . LOG_NDELAY . D_FMT . PHP_ZTS .
GLOB_ERR . AM_STR . SQL_DOUBLE . SOL_TCP . FILE_APPEND . LOG_ERR . SORT_ASC .
SOCK_RAW . LOG_INFO . LC_TIME . SQL_FLOAT . SORT_DESC . INFO_MODULES . E_ERROR .
IMG_GIF . SQL_REAL . LOG_DEBUG . DNS_NS . CODESET . CAL_FRENCH . CURLE_OK .
LDAP_OPT_RESTART . LOCK_SH . XML_PI_NODE . SQLITE_INTERRUPT . MYSQLI_ASYNC .
CURLM_OK . SNMP_NULL . SQLITE_NOMEM . LC_MESSAGES . IMG_JPG . SO_KEEPALIVE .
SOCKET_ENXIO . LOCK_EX . D_T_FMT . ENT_QUOTES . LOG_NOTICE . SOCK_RDM .
INPUT_ENV . CURLAUTH_NTLM . INPUT_SESSION . AF_INET . IMG_JPEG . SQL_CONCURRENCY
. SEEK_SET . SOCKET_EIO . LC_CTYPE . PHP_URL_QUERY . LOG_KERN . INI_SYSTEM .
IMAGETYPE_BMP . SEEK_END . JSON_HEX_QUOT . LOG_PID . LIBXML_DTDATTR .
XML_DOCUMENT_NODE . PHP_DEBUG . LOG_CRIT . ENT_IGNORE . LC_NUMERIC .
DOM_NOT_SUPPORTED_ERR . PHP_URL_FRAGMENT . FILE_TEXT . IMAGETYPE_TIFF_II .
LOG_CONS . LOG_EMERG . UPLOAD_ERR_CANT_WRITE . MSG_PEEK . SQLITE_OK . FNM_PERIOD
. AF_UNIX . CURLPROTO_FTPS . STREAM_NOTIFY_FAILURE . MYSQL_BOTH .
CURLE_FTP_ACCESS_DENIED . MSG_OOB . FTP_TEXT . LC_MONETARY .
CURLE_COULDNT_CONNECT . SQLITE_BUSY . "\n";

यह शायद बहुत पोर्टेबल कोड नहीं है, लेकिन यह मेरे सिस्टम पर ठीक काम करता है। यहाँ कोड है कि इसे उत्पन्न किया है:

<?php
$phi = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375";
echo "<?php\necho TRUE . '.' . ";
$consts = get_defined_constants();
foreach($consts as $k=>$v) if (preg_match('/\d|TRUE|PHP_EOL/',$k)) unset($consts[$k]);
for ($p=0;$p<strlen($phi);$p++) {
  $d = ord($phi[$p]) - 48;
  $min = 999;
  foreach($consts as $k=>$v) {
    if (strlen("$v")==1 && $v==$d && strlen($k)<$min) {
      $min = strlen($k);
      $maxk = $k;
    }
  }
  if ($min==999) break;
  echo "$maxk . ";
  unset($consts[$maxk]);
}
echo "\"\\n\";\n";

— बग़ल में ossifrage
स्रोत

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

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

<?for(;;);9MB मेमोरी का उपयोग करता है। अब मुझे पता है क्यों ... मुझे @ kernigh का आत्म-लगाया प्रतिबंध # 7 पसंद है, हालांकि, जो इस प्रकार की खामियों को बंद करता है। इसके अलावा, इसके लायक क्या है, मेरे सिस्टम पर आउटपुट यह है: codepad.org/wSrtJBco

— primo

हालाँकि, जेनरेटर चलाने से एक वैध प्रतिनिधित्व उत्पन्न होता है , इसलिए उसके लिए +1;) कोडपैड सर्वर पर चलने वाला एक संस्करण: codepad.org/myBpc6cB

— primo

2

बधाई हो, आपने चुनौती तोड़ दी। ;) ... वास्तव में नहीं ... यह जवाब वास्तविक चुनौती को कुछ हद तक कम कर देता है, लेकिन यह नियमों के भीतर अच्छी तरह से है जहां तक मैं देख सकता हूं, इसलिए मुझे हार को स्वीकार करना होगा और इसे स्वीकार करना होगा। :)

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

11

पर्ल - 37 अंक

use Math::Trig;
use POSIX;

print
  !0,'.',chop$=||$=,A==A,2**3,$|,++$^F,75/5/5,pi*pi%\_,4+4,a^Y,w&'?',~"\xcb",$^=~y/_//c,
  ord"\b",unpack(h,"\t").@{[c,c,c,c]},$#{[b..j]},"$^W"|'$',$^H>>log$^H,cos()- -cos,$[,
  $-=sqrt%SIG,$%=$],$+[*$=~/($)/],split('',$~).map(glob,"{,,,}{,}"),index(\L,L),
  exp(exp)<<exp,ceil(sinh acosh$^C).keys{stat$0},rindex(\R,R),($s=ssssss)=~s/s//g,
  $?=acos(--$z),$^T=pack(u,$^T.$^T.TTTT),B~~B,C<=C,length$^V,

वर्तमान में 392 बाइट्स, (10.6 प्रति अंक)।

आउटपुट:

1.618033988749894848204586834365638117

स्व-लगाया प्रतिबंध

मैंने भाषा सुविधाओं के उपयोग को सीमित करने के लिए कुछ अतिरिक्त प्रतिबंध जोड़े हैं, जो समस्या का समाधान करेंगे। उदाहरण के लिए, एरे डीरेफेरेंस @{...}और एरे फाइनल फाइनल इंडेक्स $#{...}केवल एक बार उपयोग किए जाते हैं। इस्तेमाल किया प्रत्येक सरणी एक अलग ढंग से उत्पन्न होता है (तुलना [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}"))। इसके अतिरिक्त, किसी भी प्रतीक या नंगेपन का उपयोग एक से अधिक बार नहीं किया जाता है, हालांकि इसे चुनौती विवरण में स्पष्ट रूप से अनुमति दी गई है। मुझे लगता है कि यह पर्ल के लिए एक अच्छा विचार है (या इंट-केवल विशेष चर के साथ कोई भाषा है (क्या कोई अन्य हैं?)), क्योंकि यह निहित अंतर रूपांतरणों की संख्या को सीमित करता है।

टुकड़े

!0                       # returns 1
'.'
chop$=||$=               # $= is 60, chop the 0, returns 6
A==A                     # returns 1 (because 0==0)
2**3                     # returns 8
$|                       # auto flush, returns 0
++$^F                    # max system filehandle pre-incremented, returns 3
75/5/5                   # returns 3
pi*pi%\_                 # pi² mod a large value, returns 9
4+4                      # returns 8
a^Y                      # bitwise 'a' xor 'Y', returns 8
w&'?'                    # bitwise 'w' and '?', returns 7
~"\xcb"                  # bitwise inversion of char 203, returns 4
$^=~y/_//c               # count non-underscores in $^, returns 9

ord"\b"                  # returns 8
unpack(h,"\t")           # unpack "\t" as a hex nibble, returns 9
@{[c,c,c,c]}             # anonymous array, returns 4 in scalar context
$#{[b..j]}               # final index of the range b..j, returns 8
"$^W"|'$'                # bitwise '0' or '$', returns 4
$^H>>log$^H              # $^H is 256, log$^H is ~5, returns 8
cos()- -cos              # cos(undef) is 1, subtract -1, returns 2
$[                       # array start index, returns 0

$-=sqrt%SIG              # set $- to sqrt(23), returns 4
$%=$]                    # set $% to the version number, returns 5
$+[*$=~/($)/]            # match end on *$ (aka *main::$), returns 8
split('',$~)             # split "STDOUT" into chars, returns 6 in scalar context
map(glob,"{,,,}{,}")     # an array of 8 empty strings, returns 8 in scalar context
index(\L,L)              # finds 'L' in 'SCALAR(...)', returns 3

exp(exp)<<exp            # 2.718281828 << 1, returns 4
ceil(sinh acosh$^C)      # ceil(2.30129...), returns 3
keys{stat$0}             # stat$0 is an array with 13 entries, which has 6 keys when
                         # interpreted as a hash, returns 6 in scalar context
rindex(\R,R)             # finds 'R' in 'SCALAR(...)' in reverse, returns 5
($s=ssssss)=~s/s//g      # replace the every 's' in 'ssssss' with nothing, returns 6

$?=acos(--$z)            # set $? to 3.14159... implicit int conversion, returns 3
$^T=pack(u,$^T.$^T.TTTT) # set $^T to "8,30P,...", returns 8
B~~B                     # returns 1 (because B represents the same thing as B)
C<=C                     # returns 1 (because 0<=0)
length$^V                # string length of $^V, returns 7

— Primo
स्रोत

8

पायथन 2.7, 19 अंक, 231 प्रासंगिक वर्ण

from math import ceil, pi, trunc, gamma, sin

print ''.join(map(str,
[33-32,
chr(46),
~-7,
8>>3,
trunc(gamma(4.3)),
'x'.find('x'),
22/7,
range(4).pop(),
len('am I phi?'),
52%44,
2*4,
5|2,
ord('/'),
'\b',
5+2+2,
2<<2,
eval("5+2+2"),
ceil(pi),
'\b',
'\b',
str(sin(5))[5],
5&52]))

— wrongu
स्रोत

बैकस्पेस-लोफोल बंद होने से पहले यह जवाब पोस्ट किया गया था। जैसा कि यह काफी चालाक चाल है और इस मामले में चुनौती के लिए हानिकारक नहीं है (और क्योंकि यह जवाब था कि वास्तव में मुझे खामियों की ओर इशारा किया गया था), यह जवाब इस प्रकार हो सकता है - इसलिए कृपया इसके आधार पर इसे कम न करें, बल्कि चतुराई के लिए इसे बढ़ा। :)

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

6

रूबी 2.1 54 अंकों के लिए, 808 वर्ण

#!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket
print 2/2,?.,9-3,3&5,2*4,2^2,7%4,55>>4,5+4,2<<2,-~7,5|2,2**2,(2r+2+5).to_i,(2.2+5).ceil,(55r/5-2).floor,(2.2*2).to_i,(2r*2*2).ceil,(2.2**2).floor,2.to_bn<<2,__LINE__,$<.to_i,IO::LOCK_NB,Errno::EIO::Errno,File::APPEND,'aaaaaa'.size,?a.encoding.name.sub(/\D+/,''),%w[a a a].size,%w[a b c d].to_set.size,%w[a a a].count,Socket::AF_NS,Date.jd(Date::ITALY).wday,*Digest::MD5.digest(?j).scan(/\d/),Set[?a,?b,?c].count,SignalException.new('FPE').signo,Float::ROUNDS,begin
exit false
rescue Object
$!.status
end,Process::RLIMIT_NPROC,:aaaaaaa.size,Prime.first,?/.next,{a:p,b:p,c:p}.size,STDIN.lineno,?a.crypt('at')[/\d/],{a: :a}.find_index([:a,:a]),/b/=~'aaaaaaaaab',[?a,?b].index(?b),:aaaaaaab=~/b/,?\t.ord,'aaaaaaaab'=~/b/,open(?/).pos,'aaaaab'.index(?b),?\a.bytes{|b|break b},'aaaaaaa'.rindex(?a),%w[a a].map.size

इस कार्यक्रम के साथ काम करता है ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]। OpenBSD 5.5 के अलावा अन्य प्रणालियों में कुछ अंकों के लिए भिन्न मान हो सकते हैं।

व्याख्याओं

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

कोष्ठक, डॉट और डबल-कॉलोन ऑपरेटर नहीं हैं। कोष्ठक सिर्फ संचालन के क्रम को बदलते हैं। डॉट कॉल विधियों के रूप में $<.fileno, और डबल कोलन में स्थिरांक प्राप्त करता है IO::LOCK_NB। विधि या स्थिर का नाम ऑपरेशन का हिस्सा है। क्योंकि () . ::ऑपरेटर नहीं हैं, मैं उनके लिए प्रतिबंध 6 लागू नहीं करता। मैं अधिक अंक उत्पन्न करने के लिए उनका पुन: उपयोग कर सकता हूं।
एक अलग कार्यान्वयन के साथ एक विधि एक अलग विधि है। उदाहरण के लिए, Array#countऔर Enumerable#countप्रतिबंध के लिए समान कार्य नहीं हैं। 6. दोनों विधियां समान हैं, लेकिन एक अलग कार्यान्वयन के साथ Array#countओवरराइड करती हैं Enumerable#count। यदि मैं Array#countएक अंक उत्पन्न करने के लिए उपयोग करता हूं, तो मैं Enumerable#countएक और अंक उत्पन्न करने के लिए उपयोग कर सकता हूं ।
कक्षा # नया एक तरीका है। रूबी में, Mutex.new, Random.new, Time.newऔर इतने पर ही विधि के लिए, का उल्लेख Class#new। मैं SignalException.newएक अंक उत्पन्न करने के लिए उपयोग करता हूं । प्रतिबंध 6 के कारण, मैं फिर कभी उपयोग नहीं कर सकता Class#new।
कक्षाओं या मॉड्यूल के लिए स्थिरांक अभी भी स्थिरांक हैं। रूबी में, कक्षा के नाम जैसे हैं Floatऔर IOनिरंतर हैं! मैं IO::LOCK_NBएक अंक उत्पन्न करने के लिए उपयोग करता हूं । प्रतिबंध 6 के कारण, मैं फिर कभी उपयोग नहीं कर सकता IO। यह व्याख्या केवल रूबी को बांधती है, न कि अन्य भाषाओं को जहां पैकेज के नाम स्थिर नहीं हैं।
साहित्य स्थिरांक नहीं हैं। हालांकि 2 एक गणितीय स्थिरांक (किसी भी चर से स्वतंत्र) है, यह रूबी में एक स्थिर नहीं है। मैं प्रतिबंध 6 को शाब्दिक रूप से लागू नहीं करता हूं, और मैं एक अंक से अधिक के लिए शाब्दिक 2 का पुन: उपयोग कर सकता हूं।
साहित्यकार संचालक नहीं हैं। मैं कोष्ठक या उद्धरणों पर प्रतिबंध 6 को लागू नहीं करता हूं जो कि शाब्दिक सरणियों, हैश, नियमित अभिव्यक्तियों या स्ट्रिंग्स के रूप में होते हैं [] {} // ''। मैं हमेशा ऐसे अंकों का उपयोग अधिक अंक उत्पन्न करने के लिए कर सकता हूं।
समान मूल्य वाले दो स्थिरांक समान स्थिर होते हैं। File::APPENDऔर IPSocket::LOCK_UNएक ही नंबर के दो नाम हैं। 8. प्रतिबंध 6 कहता है, "इससे कोई फर्क नहीं पड़ता कि आप किस नाम से किसी अंतर्निहित बिल का उल्लेख करते हैं।" क्योंकि File::APPENDऔर IPSocket::LOCK_UNकेवल नाम से भिन्न है, वे एक ही स्थिर होना चाहिए, इसलिए मैं उन्हें दो अंकों के लिए उपयोग नहीं कर सकता।
हो सकता है कि दो अंक समान वैश्विक चर का संदर्भ न दें। यह एक खामियों को बंद करता है। प्रतिबंध 6 केवल फ़ंक्शन, ऑपरेटर और स्थिरांक पर लागू होता है। प्रतिबंध 4 केवल शाब्दिक पर लागू होता है। $SAFEएक अंतर्निहित वैश्विक चर है, न कि फ़ंक्शन, ऑपरेटर, स्थिर, और न ही शाब्दिक। $SAFEमान 0 है। खामियों के साथ, मैं $SAFEकार्यक्रम में हर अंक 0 उत्पन्न करने के लिए पुन: उपयोग कर सकता हूं । मैं वैश्विक चर को भी प्रतिबंधित करने के लिए प्रतिबंध 6 की व्याख्या करके खामियों को दूर करता हूं।

पहली पंक्ति है #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket। रूबी इस लाइन को पार्स करती है और अपने मानक पुस्तकालय के छह हिस्सों को लोड करती है, जैसे कि require 'date', require 'digest'और इसी तरह। मैं इन 56 वर्णों की गणना नहीं करता, क्योंकि प्रतिबंध 3 में "मानक पुस्तकालय आयात / शामिल" की छूट है।

कार्यक्रम के बाकी लोग printतर्कों की एक लंबी सूची के साथ कॉल करते हैं, ताकि उन्हें तार में परिवर्तित कर सकें और उन्हें क्रम में प्रिंट कर सकें। तर्क ये हैं:

1से 2/2: विभाजन फिक्सन # /
. से ?.: शाब्दिक एकल-वर्ण स्ट्रिंग
6से 9-3: घटाव Fixnum # -
1से 3&5: बिटवाइज़ और फिक्सनम # &
- 5 व्याख्या करके, मैं 3फिर से उपयोग कर सकता हूं ।
8से 2*4: गुणा फिक्सन # *
0से 2^2: बिटवाइज़ एक्सक्लूसिव-या फ़िक्नम # ^
3से 7%4: मापांक फिक्सन #%
3से 55>>4: राइट शिफ्ट फ़िक्नम # >>
9से 5+4: इसके अलावा Fixnum # +
8से 2<<2: बाएँ पारी Fixnum # <<
8से -~7: पूरक फिक्सन की उपेक्षा # - @ फिक्सनम # ~
- घटाव Fixnum # - और निषेध Fixnum # - @ अलग-अलग विधियाँ हैं।
7से 5|2: बिटवाइज़ या फ़िक्नम # |
4से 2**2: घातांक फ़िक्नम # **
9से (2r+2+5).to_i: तर्कसंगत जोड़ तर्कसंगत # + तर्कसंगत # to_i
- व्याख्या 2 के द्वारा, Fixnum # + और Rational # + अलग-अलग विधियाँ हैं। वे दोनों संख्याओं को जोड़ते हैं, लेकिन उनके पास अलग-अलग कार्यान्वयन हैं, जो बाईं संख्या के लिए विभिन्न प्रकारों से शुरू होते हैं।
- 2rरूबी 2.1 में तर्कसंगत शाब्दिक नए हैं। 2r+2कॉल तर्कसंगत # + और एक और तर्कसंगत देता है; फिर से तर्कसंगत #2r+2+5 कॉल करता है ।
- रूबी प्रिंट्स की तरह तर्कसंगत 2/1और प्रिंट करती है 2.0। : इसे ठीक करने के लिए, मैं पूर्णांक में बदलने का to_i शून्य, की ओर राउंड प्लस्तर लगाना राउंड अप, मंजिल नीचे दौर।
8से (2.2+5).ceil: फ्लोट जोड़ फ्लोट # + फ्लोट # छत
- 1 व्याख्या करके, मैं फिर से कोष्ठक ()और बिंदु का उपयोग कर सकता हूं .।
9से (55r/5-2).floor: तर्कसंगत विभाजन और घटाव तर्कसंगत # / तर्कसंगत # - तर्कसंगत # मंजिल
4से (2.2*2).to_i: फ्लोट गुणन फ्लोट # * फ्लोट # to_i
8से (2r*2*2).ceil: तर्कसंगत गुणन तर्कसंगत # * तर्कसंगत # छत
4से (2.2**2).floor: तर्कसंगत घातांक तर्कसंगत # **
8से 2.to_bn<<2: OpenSSL बड़ी संख्या के साथ बाईं पारी Fixnum # to_bn OpenSSL :: BN # <<
2से __LINE__: वर्तमान लाइन संख्या के लिए जादू निरंतर
0से $<.to_i: मानक इनपुट IO # to_i की फाइल डिस्क्रिप्टर
4से IO::LOCK_NB: गैर-अवरुद्ध फ़ाइल लॉक के लिए ध्वज
- यह सिस्टम पर निर्भर कई स्थिरांक में से पहला है। OpenBSD में 4 हैं।
- व्याख्या 4 से, मैं अब उपयोग नहीं कर सकता IO। 7 की व्याख्या करके, मैं अब 4 के मान के साथ किसी भी निरंतर का उपयोग नहीं कर सकता हूं।
5से Errno::EIO::Errno: इनपुट / आउटपुट त्रुटि के लिए संख्या
8से File::APPEND: ध्वज एक फ़ाइल के लिए संलग्न करने के लिए
- यह व्याख्या के आसपास एक खामी है। मैं उपयोग नहीं कर सकता हूं IO, लेकिन इससे Fileस्थिरांक प्राप्त होता है IO, इसलिए File::APPENDइसे प्राप्त करने का एक अलग तरीका है IO::APPEND।
6से 'aaaaaa'.size: स्ट्रिंग स्ट्रिंग की लंबाई # आकार
8से ?a.encoding.name.sub(/\D+/,''): एन्कोडिंग के नाम का हिस्सा स्ट्रिंग # एन्कोडिंग # एन्कोडिंग # नाम स्ट्रिंग # उप
- 6 व्याख्या करके, मैं फिर से स्ट्रिंग उद्धरण का उपयोग कर सकता हूं।
- रूबी 2.0 के बाद से, डिफ़ॉल्ट एन्कोडिंग UTF-8 है। मैं एक खाली स्ट्रिंग के साथ "UTF-8" और विकल्प / \ D + / मिलान "UTF-" लेता हूं। यह "8" पैदावार देता है।
3से %w[a a a].size: सरणी सरणी की लंबाई # आकार
4से %w[a b c d].to_set.size: सेट Array में तत्वों की संख्या # to_set सेट # आकार
3से %w[a a a].count: सभी तत्वों को गिनें Array # count
- Array # size और Array # count के बीच का अंतर यह है कि उत्तरार्द्ध वैकल्पिक तर्क लेता है कि किन तत्वों को चुनना है। मैं कोई तर्क नहीं देता, इसलिए यह सभी तत्वों को गिनता है।
6से Socket::AF_NS: एनएस एड्रेस परिवार के लिए नंबर
5से Date.jd(Date::ITALY).wday: शुक्रवार 15 अक्टूबर 1582 के लिए कार्यदिवस की संख्या, जब इटली ग्रेगोरियन कैलेंडर तिथि पर स्विच किया गया :: jd दिनांक # दिन
6से *Digest::MD5.digest(?j).scan(/\d/): बाइनरी MD5 के पहले ASCII अंक "j" डाइजेस्ट के डाइजेस्ट :: MD5 :: डाइजेस्ट स्ट्रिंग # स्कैन
- स्ट्रिंग # स्कैन सभी मैचों की एक सरणी देता है। *करने के लिए तर्क के रूप में सरणी तत्वों से गुजरता है print। यह सरणी है ["6"]।
3से Set[?a,?b,?c].count: सभी तत्वों की गणना करें सेट :: [] अनगिनत # गिनती
- व्याख्या 2 के द्वारा, Array # count और Enumerable # count अलग-अलग विधियाँ हैं।
8से SignalException.new('FPE').signo: SIGFPE कक्षा की संख्या # नया SignalException # साइनो
1से Float::ROUNDS: राउंडिंग मोड, यहां 1 राउंड-टू-निकटतम के लिए
1से begin(newline) exit false(newline) rescue Object(newline) $!.status(newline) endसे बाहर निकलने के लिए विफलता के लिए की स्थिति:
- यह उसी तरह का मान है SystemExit.new(false).status, लेकिन व्याख्या 3 से, मैं अब कक्षा को # नया नहीं कह सकता । इसके बजाय मैं एक SystemExit उठाता हूं और बचाव करता हूं।
7से Process::RLIMIT_NPROC: एक उपयोगकर्ता के लिए प्रक्रियाओं की संख्या के लिए संसाधन सीमा के लिए संख्या
7से :aaaaaaa.size: प्रतीक की लंबाई # प्रतीक
2से Prime.first: पहला प्राइम नंबर Enumerable # पहला
0से ?/.next: अगली तार "के बाद?" स्ट्रिंग # अगले
3से {a:p,b:p,c:p}.size: हैश हैश की लंबाई # आकार स्ट्रिंग # पी
0से STDIN.lineno: मानक इनपुट IO # लाइनो के लिए वर्तमान लाइन संख्या
- व्याख्या 8 से, मैं पुन: उपयोग नहीं कर सकता $<। मैं उपयोग करता हूं STDIN। अंतर यह है कि $<एक वैश्विक चर है और STDINएक स्थिर है। एक कार्यक्रम $<एक अलग इनपुट पर सेट हो सकता है , लेकिन STDINहमेशा इसका मूल मूल्य होता है $<।
3से ?a.crypt('at')[/\d/]: एन्क्रिप्टेड पासवर्ड स्ट्रिंग में पहला ASCII अंक # क्रिप्ट स्ट्रिंग # [
- विभिन्न क्रिप्ट () फ़ंक्शन वाली प्रणाली अलग परिणाम देगी।
0से {a: :a}.find_index([:a,:a]): पहली कुंजी का सूचकांक: a, मूल्य: a हैश में अनगिनत # find_index
- मैं, एक हैश, नहीं एक सरणी का उपयोग करें क्योंकि सरणी # find_index के लिए एक उपनाम है सरणी # सूचकांक है, जो मैं जल्द ही उपयोग करने की योजना।
9से /b/=~'aaaaaaaaab': सूचकांक जहां स्ट्रिंग मैच / बी / Regexp # = ~
1से [?a,?b].index(?b): सरणी में पहला "बी" का सूचकांक सरणी # सूचकांक
7से :aaaaaaab=~/b/: सूचकांक जहां प्रतीक / बी / प्रतीक से मेल खाता है = ~ ~
9से ?\t.ord: टैब का ASCII मान "\ t" स्ट्रिंग # ऑर्ड
8से 'aaaaaaaab'=~/b/: सूचकांक जहां स्ट्रिंग मैच / बी / स्ट्रिंग # = ~
- व्याख्या 2 से, रेगेक्सप # = ~ और स्ट्रिंग # = ~ अलग-अलग विधियां हैं।
0से open(?/).pos: रूट डायरेक्टरी खोलने के बाद फाइल में पोजिशन "/" फाइल कर्नेल के रूप में # ओपन IO # पॉस
5से 'aaaaab'.index(?b): स्ट्रिंग स्ट्रिंग # सूचकांक में पहले "बी" का सूचकांक
7से ?\a.bytes{|b|break b}: चेतावनी के ASCII मान "\" एक " स्ट्रिंग # बाइट्स
- यह "\" में बाइट्स को पुनरावृत्त करके काम करता है, लेकिन पहले बाइट को वापस करके लूप को तोड़ता है।
6से 'aaaaaaa'.rindex(?a): स्ट्रिंग स्ट्रिंग # रिंडेक्स में अंतिम "ए" का सूचकांक
2से %w[a a].map.size: एन्यूमरेटर का आकार जो सरणी से मैप करता है एरे # मैप एन्यूमरेटर # आकार

— kernigh
स्रोत

प्रभावशाली! आपकी अधिकांश व्याख्याएँ वैसे भी नियमों के अनुरूप हैं। 1. मैंने कभी भी आह्वान नहीं किया था, डेरेफेरेंसिंग और एक्सेस ऑपरेटरों को प्रतिबंधित किया जाना था, यही वजह है कि मैंने "गणितीय, बूलियन, बिट-वार और स्ट्रिंग" ऑपरेटर कहा। 2. नियम से आच्छादित 6. 6. अन्य भाषाओं में पुन: उपयोग करना ठीक होगा, क्योंकि यह आमतौर पर एक ऑपरेटर होता है - इसे केवल उसी वर्ग पर पुन: उपयोग नहीं किया जा सकता है क्योंकि यह एक कंस्ट्रक्टर (अंतर्निहित फ़ंक्शन) कहता है। रूबी में वह कैसे है? क्या newवास्तव में हमेशा एक ही imlpementation कहा जाता है या उपवर्गों में इसे ओवरराइड किया जाता है? [ctd।]

— मार्टिन

4. यदि आप रूबी के लिए वहां अपवाद बना देते हैं, तो मैं ठीक हो जाऊंगा, लेकिन आपकी स्पोर्ट्समैनशिप के लिए धन्यवाद। ;) 5. और 6. नहीं वे नहीं हैं, यही वजह है कि कुछ नियमों को जिस तरह से कहा गया है। 7. यह एक अच्छा सूक्ष्म बिंदु है जिसके बारे में मैंने नहीं सोचा था। तकनीकी रूप से, यदि वे समान 8 का संदर्भ नहीं देते हैं , तो उन दोनों का उपयोग करना ठीक रहेगा। 8. अच्छा बिंदु, मैं निर्मित चर के बारे में नहीं सोचा था। मैं जाँच करूँगा कि क्या यह किसी अन्य सबमिशन और नियम को तोड़ने के लिए पर्याप्त रूप से नहीं टूटता है। 6. निष्पक्ष खेलने के लिए धन्यवाद! :)

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

मुझे इस उत्तर में कोई नियम उल्लंघन नहीं मिला, इसलिए मैंने इसे स्वीकार कर लिया। हालाँकि, मैं आपके उत्तर को पुरस्कृत करना चाहूंगा, क्योंकि यह अब तक का सबसे लंबा है, जो वास्तव में चुनौती के माध्यम से खेलता है। इसलिए, मैं इस चुनौती के लिए एक इनाम की पेशकश करूंगा। यह इनाम सात दिनों तक चलेगा और इस जवाब के साथ आना चाहिए कि आपका "निष्पक्ष" तरीके से धड़कना है, मैं इनाम को उसी हिसाब से दूंगा। (बेशक, आप किसी भी दावेदार की कोशिश करने और उसे हराने के लिए स्वतंत्र हैं;)) आशा है कि आप इसके साथ ठीक हैं!

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

5

जावा, 21 अंक, 276 वर्ण

class C{public static void main(String[]a){System.out.print((3&5)+"."+(2|4)+Byte.BYTES+2*4+"".length()+(7-4)+~-4+(7+2)+(2<<2)+(int)Math.sqrt('@')+(2^5)+(int)Math.pow(2,2)+32%23+Byte.SIZE+('$'>>2)+Float.BYTES+Long.BYTES+Integer.BYTES+Double.BYTES+Short.BYTES+Math.round(.2));}}

class C {
  public static void main(String[] a) {
    System.out.print(
      (3&5)+       // 1
      "."+         // .
      (2|4)+       // 6
      Byte.BYTES+  // 1
      2*4+         // 8
      "".length()+ // 0
      (7-4)+       // 3
      ~-4+         // 3
      (7+2)+       // 9
      (2<<2)+      // 8
      (int)Math.sqrt('@')+  // 8
      (2^5)+       // 7
      (int)Math.pow(2,2)+   // 4
      32%32+       // 9
      Byte.SIZE    // 8

      // rest of explanation to come later today
    );
  }
}

— Ypnypn
स्रोत

हा, मुझे पसंद है 7-4& -4+7, वह चतुर है! :)

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

चतुर, लेकिन मुझे लगता है कि यह लगातार (पुन: उपयोग नहीं करने के नियम का उल्लंघन करता है दोनों में सकारात्मक 7 का उपयोग किया जाता है)

— गलत

1

@ श्रंग 7एक स्थिर नहीं बल्कि शाब्दिक है

— मार्टिन

तो आप वहाँ क्यों रुक गए?

— वैलेंटाइन ग्रेजायर

4

रूबी, 74 वर्ण, 10 अंक

यह सिर्फ एक शुरुआत है; मुझे जाना है इसलिए मैं इसे बाद में सुधारूंगा।

$><<[3-2,?.,3+3,?..size,2**3,$*.size,24/8,7%4,[*7..77][2],2*4,7.next].join

मेरे पास 76 पात्रों को बाद के लिए बचाया गया है, जब यह अधिक कठिन हो जाएगा!

— Doorknob
स्रोत

यह एक अच्छी शुरुआत है! प्रश्न की भावना पर अंत में एक उत्तर। :)

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

3

रूबी, 17 अंक, 168 बाइट्स

$><<[-~0,'.',9-3,3/3,2**3,$.,25%22,'   '=~/$/,2+7,2<<2,"10".oct,2|5,[2,2,2,2].size,[*$....2*5].last,(2^5).succ,'a'.to_i(25).pred,'aaaa'.count('a'),eval(55.chr.next)]*''

Ungolfed:

$><<[
  -~0,                # 1
  '.',                # .
  9-3,                # 6
  3/3,                # 1
  2**3,               # 8
  $.,                 # 0
  25%22,              # 3
  '   '=~/$/,         # 3
  2+7,                # 9
  2<<2,               # 8
  "#{'a'.hex}".oct,   # 8
  2|5,                # 7
  [2,2,2,2].size,     # 4
  [*$....2*5].last,   # 9
  (2^5).succ,         # 8
  'a'.to_i(25).pred,  # 9
  'aaaa'.count('a'),  # 4
  eval(55.chr.next)   # 8
]*''

विशेष रूप से चतुर कुछ भी करने के लिए मजबूर नहीं किया गया है, मैं वापस आ सकता हूं और अंक जोड़ सकता हूं।

— histocrat
स्रोत

1

"अभी तक विशेष रूप से चतुर कुछ भी करने के लिए मजबूर नहीं किया गया है।" हाँ, मुझे लगा कि रूबी, पर्ल और सामान्य संदिग्धों के पास प्रति अंक 15 अक्षरों के साथ वास्तव में कठिन समय नहीं होगा, लेकिन मैं बड़े मानक-पुस्तकालयों के साथ सी-डेरिवेटिव और गणितज्ञ जैसी चीजों के लिए जगह छोड़ना चाहता था, लेकिन अधिक जटिल नाम।

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

"अगर वे वास्तव में केवल उपनाम हैं, नहीं [आप उनका उपयोग नहीं कर सकते हैं]।" succऔर nextउपनाम हैं।

— दरवाज़े

1

पहला एक फिक्सनम पर बुलाया जा रहा है, दूसरा एक स्ट्रिंग पर, इसलिए मुझे नहीं लगता कि वे एक ही विधि के रूप में गिनते हैं।

— हिस्टोक्रेट

आह, अच्छी बात है। हालाँकि, सवाल यह भी कहता है कि "आपको किसी भी संदर्भ का उल्लेख नहीं करना चाहिए ... निरंतर जो आपने कोड में उपयोग किया है जो पहले अंक उत्पन्न करता है," और आप $.दो बार उपयोग करते हैं । हालांकि, प्यार होगा $....: डी

— दरवाज़े

2

गोल्फस्क्रिप्ट , 17 अंक

एक सीधा प्रयास। गोल्फस्क्रिप्ट में बहुत सारे गैर-अल्फ़ान्यूमेरिक एक-बिल्ट-इन-इन्स हो सकते हैं, लेकिन इसमें बहुत सारे बिल्ट-इन नहीं होते हैं!

".",                         # 1: string length (separate from array length)
'.'    
3 3+                         # 6: addition
''[49]+                      # 1: string concatenation
-9~                          # 8: bitwise not
2!                           # 0: boolean not
7 4%                         # 3: modulus
4(                           # 3: decrement
7))                          # 9: increment
257 2/2/2/2/2/               # 8: division
4 2*                         # 8: multiplication
22 5- 5- 5-                  # 7: subtraction
2 2?                         # 4: power
[2 5] 2 base                 # 9: base conversion
[2 2 2 2 2 2 2 2],           # 8: array length (separate from str length)
[2 2 2 2 2 2 2 2 2 5]5?      # 9: array.find()
2 2+                         # 4: addition
"2 2*2*"~                    # 8: eval

— Claudiu
स्रोत

2

मुझे लगता है कि आप जारी रख सकते हैं 5,)\; # range, right uncons, flip, and pop।

— पीटर टेलर

1

बैश, 65 अंक में 5 अंक

मैं जल्द ही इसे अपडेट करूंगा! अभी के लिए, यह सिर्फ प्रिंट 1.6180करता है, और इसमें कोई अंक नहीं होता है।

false
tr -d ' '<<<$?.`wc -c<<<abcde``nl<<<' '``kill -l FPE`$(())

व्याख्या

अंक उत्पन्न करने के लिए निम्न विधियों का उपयोग किया जाता है:

1: से बाहर निकलने की स्थिति false

6: स्ट्रिंग की लंबाई

1: nlदुरुपयोग

8: killसंकेत संख्या

0: एक खाली अभिव्यक्ति का संख्यात्मक मान

1

86 83 78 वर्णों में गणितज्ञ 9 8 अंक ।

10`8FromDigits@#/10^Length@#&@{a/a,3!,-I I,2π/(45°),#&''[],Prime@2,Sqrt@9,4+5}

आउटपुट:

1.6180339

— गणना
स्रोत

आह, मुझे पता था कि मैंने कहीं गलती की है। उपसर्ग संकेतन इस मामले में काम नहीं करता है। यूनिकोड पाई और डिग्री का उपयोग करना, अभी भी काम करने लगता है।

— टैली

हाँ, यह # & '' [] गुम इनपुट से एक त्रुटि उत्पन्न करेगा, जबकि इस रूप में यह ध्यान नहीं देता है कि इसे कोई इनपुट नहीं मिला। फिर भी मुझे इसका उपयोग न करने का बहाना नहीं देता जहाँ यह काम करता है।

— टैली

1

धन्यवाद। मैं व्यक्तिगत रूप से # & '' [] से प्यार करता था (मूल रूप से f [x] = x की दूसरी व्युत्पत्ति

— टैली

(टिप्पणी ऊपर साफ़ किया।) यह है काफी अच्छा है, लेकिन आप शायद एक चरित्र को बचाने की जगह से कर सकते थे #एक की अनुमति दी अंकों के साथ और डैश में से एक छोड़ने।

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

इस तरह से पता लगाया कि मैं संभावित भविष्य के उपयोग के लिए उस अंक को बचाने में सक्षम हूं।

— टैली

1

जूलिया - 345 अक्षरों में 23 अंक (15 अंक प्रति अंक)

print(div(2,2),'.','/'+7,length(" "),2^3,size([])[end],isqrt(9),int(cbrt(27)),54-45,'h'$'P',[2:22][7],endof("2222222"),count(isodd,[5,5,5,5]),search("Hello man",'n'),nextpow2(5),rsearch("Love boat",'t'),sizeof('й'),("I"summary(b"H"))[22],iceil(float(pi)),iround(cosh(e)),ifloor(exp(catalan)),cmp(5,5),itrunc(5sin(one(Int))),uint(erfcx(-ones())))

आउटपुट: 1.618033988749894848202045

मैंने वर्णों और तारों की व्याख्या करने योग्य के रूप में प्रयोग किया, इसलिए जब तक मैंने एक विशिष्ट चरित्र या स्ट्रिंग का पुन: उपयोग नहीं किया था (तब तक स्ट्रिंग में वर्णों का पुन: उपयोग किया जा सकता था, जब तक कि स्ट्रिंग नहीं थी); हालाँकि, मैंने खुद को किसी चरित्र के सीधे मान का उपयोग करने की अनुमति नहीं दी थी। एक गैर- ASCII चरित्र (й) है।

अधिक पठनीय फैशन में (वास्तविक कोड नहीं):

1> div(2,2)
.> '.'
6> '/'+7
1> length(" ")
8> 2^3
0> size([])[end]
3> isqrt(9)
3> int(cbrt(27))
9> 54-45
8> 'h'$'P'
8> [2:22][7]
7> endof("2222222")
4> count(isodd,[5,5,5,5])
9> search("Hello man",'n')
8> nextpow2(5)
9> rsearch("Love boat",'t')
4> sizeof('й')
8> ("I"summary(b"H"))[22]
4> iceil(float(pi))
8> iround(cosh(e))
2> ifloor(exp(catalan))
0> cmp(5,5)
4> itrunc(5sin(one(Int)))
5> uint(erfcx(-ones()))

— ग्लेन हे
स्रोत

0

C ++ 12.4 चार्ट प्रति पंक्ति, प्रत्येक अंक के लिए 14 वर्ण प्रति पंक्ति था

पुनः संचालन ऑपरेटरों की मेरी गलती को ठीक किया।

#include <iostream>
#include <math.h>
#define S std::string
#define C(x) std::cout<<x
int main()
{
C(cos(0));
C(char(46));
C('j'%'d');
C('\0'+3-2);
C(sqrt('@'));
C(log(1));
C('c'/'!');
S s("xyz");
C(s.size());
return 0;
}

सुनिश्चित नहीं हैं कि अगर इस तरह के वर्णों का उपयोग चार लीटर के रूप में गिना जाता है या नहीं? यदि यह कोड स्वीकार्य है तो इसे हमेशा के लिए जारी रखा जा सकता है और चार ऋणों का भुगतान किया जाएगा।

#include <iostream>
#define C(x) std::cout<<x
int main()
{
C('b'-'a');//1
C(char(46));//.
C('g'-'a');//6
C('b'-'a');//1
C('i'-'a');//8
C('a'-'a');//0
C('d'-'a');//3
C('d'-'a');//3
C('j'-'a');//9
//etc
return 0;
}

— bacchusbeale
स्रोत

शाब्दिक ठीक हैं (क्योंकि वे एकल-अंकों की संख्या के बराबर नहीं हैं), लेकिन आप -ऑपरेटर का पुन: उपयोग करते रहते हैं । इसके अलावा, मुझे पसंद है कि आपने लाइन की लंबाई के लिए टिप्पणी कैसे गिना। : डी

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

हां, जो बहुत बेहतर दिखता है, लेकिन आप 1उत्पादन करने के लिए उपयोग कर रहे हैं 0(जो कि अस्वीकृत है, क्योंकि 1पहले सुनहरे अनुपात में दिखाई दिया था)। इसके अलावा, आपको #define S(अन्य एक नहीं) को गिनने की ज़रूरत है , क्योंकि यह एक शामिल नहीं है, लेकिन सिर्फ शॉर्टहैंड उर्फ को परिभाषित करता है।

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

गोल्डन रेशियो प्रिंट करें

चुनौती

प्रतिबंध

निहितार्थ

स्कोरिंग

PHP, 100 अंक

पर्ल - 37 अंक

पायथन 2.7, 19 अंक, 231 प्रासंगिक वर्ण

रूबी 2.1 54 अंकों के लिए, 808 वर्ण

व्याख्याओं

टिप्पणियाँ

जावा, 21 अंक, 276 वर्ण

रूबी, 74 वर्ण, 10 अंक

रूबी, 17 अंक, 168 बाइट्स

गोल्फस्क्रिप्ट , 17 अंक

बैश, 65 अंक में 5 अंक

व्याख्या

86 83 78 वर्णों में गणितज्ञ 9 8 अंक ।

जूलिया - 345 अक्षरों में 23 अंक (15 अंक प्रति अंक)

C ++ 12.4 चार्ट प्रति पंक्ति, प्रत्येक अंक के लिए 14 वर्ण प्रति पंक्ति था