चुनौती

निम्नलिखित वर्ण प्रिंट करें:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

पकड़ यह है कि आप अपने कोड में उनमें से किसी एक का उपयोग नहीं कर सकते हैं।

आप उन्हें एक अग्रणी या अनुगामी न्यूलाइन के साथ या बिना मनमाने क्रम में मुद्रित कर सकते हैं, लेकिन हो सकता है कि आप किसी अन्य वर्ण को न छापें।

नियम

आप ऊपर वर्णित सेट से किसी भी वर्ण का उपयोग नहीं कर सकते हैं
आप किसी अन्य वर्ण का उपयोग कर सकते हैं
बेईमानी नहीं
मानक खामियों पर रोक लगाई
यह कोड-गोल्फ , सबसे छोटी उत्तर जीत है।

स्पष्टीकरण

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

— dkudriavtsev
स्रोत

8

यह कुछ अस्पष्ट है। यदि आप अपने कोड में उन बाइट्स के बिना उन कच्चे बाइट्स आउटपुट का मतलब है, तो आपको यह निर्दिष्ट करना चाहिए कि आप इन वर्णों के कोडपॉइंट का उपयोग नहीं कर सकते हैं, भले ही वे आपकी भाषा के कोडपेज में किसी और चीज़ के लिए मैप करें।

— 19

11

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

— आर। कप

2

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

— पलटें

1

यदि वे आंतरिक रूप से ints द्वारा प्रतिनिधित्व करते हैं, तो @briantist ठीक है, लेकिन पात्रों को स्वयं मुद्रित करना होगा।

— dkudriavtsev

3

@ R.Kap जावास्क्रिप्ट काम कर सकती है, बशर्ते आप इसके बारे में एस्को के रूप में न सोचें

— विनाशकारी नींबू

19

वी , 8 7 बाइट्स

1 बाइट ने सभी regex स्टेटमेंट में इसे डालकर @DJMcMayhem को धन्यवाद दिया

¬/{Ó×ü_

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

आउटपुट:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

नोट: ×है या नहीं , यह हैxX0xd7

Hexdump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

व्याख्या

¬/{            " inserts every character in the range / to {

अब आउटपुट जैसा दिखता है:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

हमें सभी गैर-अल्फ़ान्यूमेरिक वर्णों को हटाना होगा और _(क्योंकि यह शामिल नहीं है \W), तो चलो करते हैं कि regex का उपयोग कर रहे हैं

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

— क्रिकटी लिथोस
स्रोत

गजब का! इसके लिए मुझे पिटाई करने के लिए +1। इसके अलावा :), आप इसे नीचे एक regex के लिए अगर तुमने किया था को आसान बनाने में कर सकता है Ó×ü_(जो के बराबर है :s/\W\|_//g)

— DJMcMayhem

50

ऑक्टेव , 52 46 40 बाइट्स

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

यह करने के लिए मूल्यांकन करता है

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

व्याख्या

यहां हम इस तथ्य का उपयोग कर रहे हैं कि अंकगणित संचालन +-या जैसे कि फ़ंक्शन फ़ंक्शन :लागू होने पर वर्णों को पूर्णांक में बदल दिया जाता है। जब एक खाली स्ट्रिंग ( [...,'']) के साथ समतल किया जाता है , तो संख्याओं को फिर से वर्णों में बदल दिया जाता है।

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

— flawr
स्रोत

7

+1एक चुनौती में पहली गैर गूढ़ भाषा होने के लिए बहुत esolangs लिए उपयुक्त है।

— DJMcMayhem

4

एक बड़ा +1, ऑक्टेव का उपयोग करने के लिए नहीं (यह काफी आगे है), लेकिन इसे बहुत अच्छी तरह से गोल्फ के लिए, और _एक चर के रूप में उपयोग करना ! मुझे नहीं पता था कि यह संभव था ... अच्छा!

— स्टीवी ग्रिफिन

1

जब एक खाली स्ट्रिंग ([..., '']) के साथ, संख्याओं को फिर से वर्णों में बदल दिया जाता है .... बहुत अच्छा

— rahnema1

29

ब्रेनफक , 77 76 75 72 बाइट्स

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

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

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

दुभाषिया 0 कोशिकाओं के टेप से शुरू होता है ।

++++++++

यह पहली सेल को 8 पर सेट करता है , जिससे टेप को निम्न अवस्था में छोड़ दिया जाता है।

   8
   ^

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

यह दूसरी सेल को एक बार बढ़ाता है, तीसरी सेल को 6 बार, चौथे सेल को 4 बार, पांचवें सेल को एक बार घटाता है, फिर टेप की शुरुआत में वापस जाता है और पहले सेल को घटाता है। 8 पुनरावृत्तियों के बाद , टेप निम्नानुसार दिखता है।

  0   8  48  32  -8
  ^

>++

हम दूसरी सेल को आगे बढ़ाते हैं और दो बार इसे बढ़ाते हैं, अंकों को प्रिंट करने के लिए तैयार होते हैं।

  0  10  48  32  -8
      ^

[>.+<-]

यह तीसरी सेल को प्रिंट करता है, इसे बढ़ाता है, फिर दूसरी सेल में वापस जाता है और इसे घटाता है। 10 पुनरावृत्तियों के बाद , हमने मुद्रित किया है 0123456789और टेप निम्नानुसार दिखता है।

  0   0  58  32  -8
      ^

>>

पत्रों के लिए टेप को प्रस्तुत करने का समय! हम दो कोशिकाओं को आगे बढ़ाने से शुरू करते हैं।

  0   0  58  32  -8   0   0
              ^

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

यह पांचवें सेल को एक बार, छठे सेल को दो बार, सातवें सेल को तीन बार बढ़ाता है, फिर चौथे सेल में वापस जाता है और इसे घटाता है। 32 पुनरावृत्तियों के बाद , टेप इस प्रकार दिखता है।

  0   0  58   0  24  64  96
              ^

>++

पत्रों को छापने से पहले एक अंतिम चरण के रूप में, हम पांचवें सेल को आगे बढ़ाते हैं और इसे दो बार बढ़ाते हैं।

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

अंत में, हम छठे सेल को आगे बढ़ाने और इसे प्रिंट करने के लिए अग्रिम करते हैं, सातवें सेल के लिए भी ऐसा ही करते हैं, फिर पांचवें सेल में वापस जाएं और इसे घटाएं। 26 पुनरावृत्तियों के बाद , हमने मुद्रित किया है Aa...Zz।

— डेनिस
स्रोत

अच्छा गोल्फ! मैं आपके उत्तर के लिए लिंक

— करूंगा

25

रूबी, 42 बाइट्स

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

एक फ़ंक्शन जो एक चार सरणी देता है। एक प्रोग्राम जो सिर्फ पात्रों को आउटपुट करता है वह 49 बाइट्स है:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

यह बस एक सीमा को परिभाषित करने के लिए संबंधित श्रेणियों के दोनों तरफ एससीआई पात्रों का उपयोग करता है। उदाहरण के लिए, ?/...?:अंत को छोड़कर एक आगे स्लैश और एक बृहदान्त्र के बीच के वर्ण का मतलब है। शुरुआत से छुटकारा पाने के लिए, हम एक सरणी को घटाते हैं जिसमें तीन शुरुआत अक्षर होते हैं।

— histocrat
स्रोत

अच्छा काम। मैंने इसे उसी तरह देखा जैसे मैं अपने 60 बाइट संस्करण को पोस्ट करने आया था उसी विचार का उपयोग करके।

— ऐशली

3

आप एक बाइट को थोड़े अलग रेंज के साथ बचा सकते हैं: $> << ([ (? / ...? {)] - [* ?:? .. ..? @], * (? .. [? `) ?,? ]) ''

— एशेल्ली

यह वास्तव में सुंदर है। अच्छा, बदसूरत। आप जानते हैं कि मेरा क्या मतलब है। अच्छी तरह से किया।

— वेन कॉनराड

22

6502 मशीन भाषा, 74 70 68 बाइट्स

हेक्स डंप (6502 प्रोग्राम आम तौर पर स्थानांतरित करने योग्य नहीं होते हैं; यहाँ कोड को $ 0603 पर शुरू किया गया है):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

आप देख सकते हैं कि यह प्रतिबंधित बाइट्स में से कोई भी उपयोग नहीं करता है: $ 5 ए के माध्यम से $ 41, $ 7 ए के माध्यम से $ 61, या $ 39 के माध्यम से $ 30।

यह एक ऐसा तर्क है जिसका कोई तर्क नहीं है, जिसे जब बुलाया जाता है, तो मानक 6502 कॉलिंग कन्वेंशन के अनुसार, स्टैक के शीर्ष पर वर्ण सरणी "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXZZ0123456789" के सूचक को लौटाता है।

स्पष्टीकरण के माध्यम से, यहाँ एक disassembly है:

पता हेक्सडंप डिस्सैड
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0 ए एएसएल ए
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8 डी 1 ए 06 एसटीए $ 061 ए
$ 0617 8 डी 1 सी 06 एसटीए $ 061 सी
$ 061 ए ई एनओपी 
$ 061 बी एक टैक्स 
$ 061 सी ईओ एनओपी 
$ 061 a8 TAY 
$ 061 a9 00 LDA # $ 00
$ 0620 ई.एन. एनओपी 
$ 0621 ई.एन.ओ.पी. 
$ 0622 98 TYA 
$ 0623 ई.एन.ओ.पी. 
$ 0624 8a TXA 
$ 0625 ई.एन. एनओपी 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062 सी 20 3 ए 06 जेएसआर $ 063 ए
$ 062f ए 9 5 बी एलडीए # $ 5 बी
$ 0631 a0 40 LDY # $ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 ए 9 3 ए एलडीए # $ 3 ए
$ 0638 a0 2f LDY # $ 2f
$ 063 ए 85 80 एसटीए $ 80
$ 063 सी सी 8 आईएनवाई 
$ 063d e8 INX 
$ 063e 98 TYA 
$ 063 एफ 95 00 एसटीए $ 00, एक्स
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 आरटीएस

मशीन-भाषा कोड स्वयं-संशोधित है। स्टैक हेरफेर के लिए, मुझे संचायक को धक्का देने और पॉप करने के लिए PHA और PLA का उपयोग करने की आवश्यकता थी, लेकिन इन निर्देशों में $ 48 और $ 68 के ऑपकोड हैं, जो निषिद्ध हैं (वे 'H' और 'h' अक्षर के ASCII कोड हैं)। इसलिए, PHA के लिए, मैं संख्या $ 24 लेता हूं, एक अंकगणित शिफ्ट छोड़ दिया (ASL) करता हूं, और परिणामी $ 48 को कोड में चार स्थानों पर संग्रहीत करता हूं जहां इसे निष्पादित करने की आवश्यकता होती है। फिर, पीएलए के लिए, मैं $ 68 की गणना करने के लिए संचायक में $ 48 पर बिटवाइज़ या बिट का उपयोग करता हूं, और इसे कोड में दो स्थानों पर संग्रहीत करता हूं जहां इसकी आवश्यकता होती है।

PHA और PLA के अलावा और भी कई निर्देश थे जिनका उपयोग मैं इसलिए भी नहीं कर पाया क्योंकि उनके opcodes ASCII अक्षरों या अंकों के समान ही होते हैं, लेकिन मुझे उन अन्य लोगों के लिए प्रत्यक्ष वर्कअराउंड मिला।

वांछित वर्ण सरणी की गणना की जाती है और स्थान 0 पर शुरू किया जाता है (यह वास्तव में कोई फर्क नहीं पड़ता कि यह कहाँ से संग्रहीत है क्योंकि हमें सिर्फ यह सुनिश्चित करने की आवश्यकता है कि इसके लिए एक सूचक स्टैक के शीर्ष पर वापस आ जाए)।

आप निक मॉर्गन के 6502 असेंबलर और एमुलेटर पर इसे आज़मा सकते हैं । यहाँ एक स्क्रीनशॉट है; कार्यक्रम के चलने के बाद नीचे स्थित मॉनिटर बॉक्स आउटपुट स्ट्रिंग ($ 3 डी के माध्यम से $ 00 स्थानों में) दिखाता है।

— मिशेल स्पेक्टर
स्रोत

16

हास्केल , 75 72 63 58 56 बाइट्स

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

इसे ऑनलाइन आज़माएं! के साथ बुलाओ __। आउटपुट:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Xnor के लिए धन्यवाद जिन्होंने सुझाव दिया __और _'दो बाइट चर नामों के रूप में (!)या इसके समान, 9 बाइट्स की बचत की। मुझे विशेष रूप से पसंद है कि _'सिंटैक्स हाइलाइटिंग को कैसे तोड़ता है। और श्रेणियों को सामान्य करने के लिए xnor के लिए फिर से धन्यवाद, एक और 4 बाइट्स की बचत।
संपादित करें: मुझे पता चला है कि यूनिकोड वर्ण हास्केल में पहचानकर्ता के रूप में अनुमति दी जाती है, तो उदाहरण के लिए ä, ö... भी दो बाइट पहचानकर्ता के रूप में इस्तेमाल किया जा सकता। चूँकि उस कार्यक्रम में एक तीन बाइट पहचानकर्ता बचे थे जिससे मैंने इसे बदल दिया था ä, जिससे एक और 2 बाइट बच गई ।

स्पष्टीकरण:

__और _'मान्य चर नाम हैं। से भाषा विनिर्देश :

एक पहचानकर्ता में एक पत्र होता है जिसके बाद शून्य या अधिक अक्षर, अंक, अंडरस्कोर और एकल उद्धरण होते हैं। [...] अंडरस्कोर, को लो _-केस लेटर के रूप में माना जाता है, और जहां-जहां लो-केस लेटर हो सकता है, वहां हो सकता है। हालांकि, _सभी अपने आप में एक आरक्षित पहचानकर्ता हैं, जिनका उपयोग पैटर्न में वाइल्ड कार्ड के रूप में किया जाता है।

तो कोड के बराबर है

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

सूची में समझ aके लिए बाध्य हो जाता है '/'और bकरने के लिए ':'( "/:"के बराबर है ['/',':'], तो पैटर्न मिलान सफल होता है)। तब सीमा [a..]सभी वर्णों के स्ट्रिंग को अधिक समान बनाती है '/':

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

हर किरदार के लिए xइस स्ट्रिंग में यह तो है कि क्या जाँच की है '/'<xऔर x<':', वर्ण में जिसके परिणामस्वरूप 0123456789। तो फिर aऔर bकरने के लिए बाध्य कर रहे हैं @ और [, वर्ण उपज ABCDEFGHIJKLMNOPQRSTUVWXYZऔर इतने पर।

— Laikoni
स्रोत

3

आप उपयोग कर सकते हैं __और _'चर के रूप में।

— xnor

@xnor धन्यवाद, मुझे Underscore is treated as a lower-case letterनियम के बारे में पता नहीं था ।

— लकोनी

1

आप श्रेणियों _'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__']को सामान्य करके कुछ बाइट्स बचा सकते हैं: (सामान्य चर में z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b])।

— xnor

@xnor फिर से धन्यवाद! एक स्ट्रिंग में श्रेणियों की शुरुआत और अंत को संयोजित करने के लिए शानदार विचार। मैंने भी श्रेणियों को सामान्य बनाने की कोशिश की लेकिन हमेशा इस विचार के बिना लंबे समय तक समाप्त हो गया। एक अतिरिक्त बाइट स्ट्रिंग को बांधने से बचाया जा सकता है __, _'_ भले ही __सूची समझ के अंदर पहचानकर्ता के रूप में उपयोग किया जाता है।

— लैकोनी

13

पर्ल (5.10 या 5.12), 30 29 बाइट्स

इस कार्यक्रम में ज्यादातर अप्राप्य वर्ण शामिल हैं, इसलिए यहां एक हेक्सडंप है:

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

यह कार्यक्रम बहुत सरल है: हम एक regex के विरुद्ध एक =~अंडरस्कोर () का _धन्यवाद कर रहे हैं ( @ धन्यवाद, जो इस काम को इंगित करता है)। Regex को शाब्दिक के बजाय एक अभिव्यक्ति के रूप में निर्दिष्ट किया गया है; विशेष रूप से, हम ~एक स्ट्रिंग के बिटवाइज़ पूरक ( ) ले रहे हैं । अंतर्निहित स्ट्रिंग में प्राप्त करने के लिए बिटवाइज़ पूरक को उलट कर, हमें निम्नलिखित regex मिलता है जिसे निष्पादित किया जा रहा है:

(?{say a..z,A..Z,0..9})

पर्ल संस्करण 5.10 और 5.12 में, (?{…})वाक्यविन्यास एक प्रायोगिक वाक्यविन्यास था जो रेगेक्स को रनटाइम पर मनमाना कोड चलाने की अनुमति देता था। इस मामले में, हम इसका उपयोग वांछित आउटपुट को प्रिंट करने के लिए एक सीधा पर्ल प्रोग्राम चलाने के लिए करते हैं। (5.10 से पहले के संस्करणों का उपयोग नहीं किया जा सकता क्योंकि उनके पास नहीं है say।)

(?{…})सुरक्षा कारणों से पर्ल के आधुनिक संस्करणों को डिफ़ॉल्ट रूप से अक्षम कर दिया गया है, लेकिन यदि आपके पास पर्ल का ऐसा संस्करण है, तो आप -Mre=evalकमांड लाइन तर्क के रूप में चेक (और इस तरह इस प्रोग्राम को चला सकते हैं) को निष्क्रिय कर सकते हैं (मानक के साथ -M5.010जो संस्करण को निर्दिष्ट करता है भाषा को लागू करने के लिए, और जो बाइटकाउंट के खिलाफ गिनती नहीं करता है)।

13

दरअसल 8 5 4 बाइट्स

'>┘▀

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

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

कार्यक्रम के अंत में प्रिंट निहित है।

संपादित करें 1: केवल आधार 62 के प्रिंट वर्ण प्राप्त करने के साथ वर्णमाला को निम्न / अपरकेस और फिर संख्या सीमा (10) में रखा गया।

2 संपादित करें: ">" को '>> मेगो के लिए धन्यवाद :) 1 बाइट बचाया।

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

— पेल पेलिकन
स्रोत

'>से एक बाइट कम है ">"।

— मेगो

@ मेगो ये है, संपादित :) धन्यवाद।

— टीले पेलिकन

11

PHP, 69 बाइट्स

<?=~"ÏÎÍÌËÊÉÈÇÆ¾½¼»º¹¸·¶µ´³²±°¯®¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

यहां विंडोज -1252 का उपयोग करके कोड को स्टाइल किया गया है। नीचे एक प्रतिवर्ती xxd हेक्सडंप है।

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

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

— डेनिस
स्रोत

10

जावा (ओपनजेडके 9) , 277 बाइट्स

हां, जावा, आपने इसे अच्छी तरह से पढ़ा है!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

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

यह श्रेणियों को प्रिंट करता है, लेकिन उलट जाता है, क्योंकि ऑर्डर का कोई महत्व नहीं है।

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

मैंने charपूरी तरह से काम करने के लिए आवश्यक रूप से परिभाषित करने के लिए "कोई इनपुट नहीं" नियम की अनुपस्थिति पर खेला । अगर वह धोखा दे रहा है, तो कृपया कहें।

असंगठित और परीक्षण

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

— ओलिवियर ग्रेजायर
स्रोत

3

रुको क्या?? मैं सभी जावास्क्रिप्ट समाधानों से कम हूँ ? o_O

— ओलिवियर ग्रेजायर

ऐसा इसलिए है क्योंकि जावास्क्रिप्ट के पास नहीं है char, अन्यथा यह केक का एक टुकड़ा होता। और निष्पक्ष होने के लिए, मेरा उत्तर आपके प्रारंभिक उत्तर से छोटा है। मेरे द्वारा जाने वाले सभी ओवरहेड के लिए मेरे स्पष्टीकरण पर एक नज़र डालें।

— पैट्रिक रॉबर्ट्स

2

@PatrickRoberts निष्पक्ष होने के लिए, हमें आरंभिक संपादन की तुलना प्रारंभिक संपादन से करनी चाहिए या अंतिम संपादन से अंतिम संपादन तक, आरंभिक से अंतिम तक नहीं ...) मैंने ध्यान से पढ़ा कि जावास्क्रिप्ट के लिए क्या किया गया था, खासकर क्योंकि मुझे समझ नहीं आया कि मैं कैसे कर सकता था जेएस वाले सभी की तुलना में कम जवाब मिलता है।

— ओलिवियर ग्रेजायर

9

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

क्योंकि ब्रेनफ़ॉक अल्फ़ान्यूमेरिक वर्णों को वैसे भी अनदेखा करता है, यह सिर्फ एक निरंतर-उत्पादन चुनौती है ... (संपादित करें: एक संस्करण के लिए डेनिस समाधान देखें जो 10 बाइट्स छोटा है)

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

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

यह कोड ब्रेनफक में बुनियादी गिने हुए छोरों का एक अच्छा उदाहरण है:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

ध्यान दें कि यह संख्याओं को उत्पन्न करने के लिए रैपिंग शॉर्टकट्स का उपयोग करता है, जिसका अर्थ है कि दुभाषिया को 8-बिट रैपिंग सेल (जैसे कि मैं जिसे लिंक किया गया है) की आवश्यकता है।

— FlipTack
स्रोत

5

ब्रेनफक वह पहली भाषा थी जिसके बारे में मैंने सोचा था। मुझे शर्म नहीं आती। अच्छा जवाब।

— एलपीड्रो

7

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

ईएस 6 में बदल जाता है बहुत सारे वर्ण आप जावास्क्रिप्ट चर नामों में उपयोग कर सकते हैं ! आपके साथ छह 1-2 बाइट चर नामों को समाप्त करने के बाद महान कार्य करता है $और _।

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

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

उपरोक्त के बारे में जानने से पहले यह मेरा उत्तर था।

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

मैं jjencode केconsole.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890') माध्यम से भागा और परिणाम को मैन्युअल रूप से प्राप्त किया। निश्चित रूप से अधिक अनुकूलन हो सकते हैं।

— darrylyeo
स्रोत

अरे, FYI करें मैंने codegolf.stackexchange.com/a/105854/42091 पोस्ट किया क्योंकि मैंने इसमें बहुत काम किया है और मुझे लगता है कि यह आपके उत्तर से पर्याप्त रूप से भिन्न है।

— पैट्रिक रॉबर्ट्स

कोई बात नहीं, अच्छा लग रहा है!

— darrylyeo

अच्छा! उस आखिरी अपडेट ने मुझे 100 से अधिक बाइट प्राप्त करने में मदद की!

— पैट्रिक रॉबर्ट्स

1

यदि आप अपनी एन्कोडिंग को ISO8859-1 में बदलते हैं, और इसे बिल्कुल इस तरह छोड़ देते हैं, तो यह 769 बाइट्स होगा।

— पैट्रिक रॉबर्ट्स

7

बेफुज, 73 72 59 57 55 53 बाइट्स

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

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

यह एक एकल लूप है, जिसकी गिनती नीचे से होती है {(अर्थात एक के बाद एक वर्ण z)। पहले पुनरावृति पर, "{"<अनुक्रम {स्टैक पर दो प्रतियों को धकेलता है - एक प्रारंभिक लूप काउंटर है, और दूसरे को उस क्रम का उपयोग करते हुए उस काउंटर को !!-अपघटित करने के लिए उपयोग किया जा रहा है (दो NOTs बनाते हैं 1, जो तब घटाया जाता है)। बाद के पुनरावृत्तियों पर, लूप काउंटर पहले से ही स्टैक पर है, इसलिए केवल एक {को डिक्रीमेंट अनुक्रम को सेट करना आवश्यक है।

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

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

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

— जेम्स होल्डरनेस
स्रोत

1

यदि स्टैक पर काउंटर के अलावा और कुछ नहीं है, तो आप अपने वेतन वृद्धि भाग को बदल सकते हैं! +! अगर वहाँ है, तो आप कर सकते हैं:: + +। शून्य-शून्य मानों के लिए

— MildlyMilquetoast

लाइन की शुरुआत में चेक को फिर से व्यवस्थित करके -2 बाइट्स

— जो किंग

@JoKing वेल स्पॉट किया गया। हम vप्रतिबंधित-स्रोत का उपयोग नहीं कर सकते , लेकिन यह अभी भी एक के साथ ही काम करता है ^। धन्यवाद।

— जेम्स होल्डरनेस

-2 बाइट अप के बजाय नीचे की गिनती करके, और दूसरी पंक्ति पर काउंटर की अतिरिक्त प्रतिलिपि का उपयोग करके यह देखने के लिए कि क्या लूप खत्म हो गया है (इस समय प्रतिबंधित स्रोत के बारे में याद किया गया है?)

— जो किंग

@JoKing वाह, आप वास्तव में इस गोल्फिंग में मुझसे बेहतर हैं! एक बार फिर धन्यवाद।

— जेम्स होल्डरनेस

6

जेली , 17 16 बाइट्स

“:[{“/@`‘Ḷḟ"/ỌḊ€

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

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

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

— डेनिस
स्रोत

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

— FlipTack

@FlipTack IIRC जेली का कोडपेज मुद्रण योग्य ASCII के साथ संगत है।

— पुरकाकूदरी

@FlipTack Pietu1998 सही है। और यहां तक कि अगर वह नहीं थे, तो कल्पना पात्रों पर प्रतिबंध लगाती है, बाइट्स नहीं।

— डेनिस

@ डेनिस वास्तव में, यह टिप्पणियों के अनुसार बाइट्स पर प्रतिबंध लगाता है , हालांकि यह अभी भी वैध है (एएससीआईआई-संगत)।

— आउटगोल्फ

6

सेल्फ-मॉडिफाइंग ब्रेनफक , 32 बाइट्स

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

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

xxd -rअपरिवर्तनीय हेक्सडंप (जिसमें अप्रतिबंधित होते हैं):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

— आउटगोल्फर को एरिक करें
स्रोत

क्या करता @/है?

— यति

@TuukkaX अंतिम 6 वर्ण `\x1a@\x1a/\nहैं क्योंकि उनके कोडपॉइंट्स वास्तव में गोल्फिंग में उपयोगी हैं। आप उन्हें हटा नहीं सकते।

— आउटगोल्फर

@downvoter: यदि आप इस पोस्ट पर ठोकर खाते हैं, तो कृपया अपना डाउनवोट हटा दें। यह तब से तय है।

— को आउटगोल्फर

मुझे खुशी है कि मैं SMBF का उपयोग करने वाला एकमात्र व्यक्ति नहीं हूं। :)

— mbomb007

@ mbomb007 व्यावहारिकता :) मैं बीएफ के बारे में सोच रहा था, और उन्हें एसएमबीएफ का ख्याल आया, ताकि मेरे पास कोडपॉइंट तैयार हों। प्रतिबंध ने मुझे बाइट्स का खर्च नहीं दिया, क्योंकि मैंने +.इसके बजाय इस्तेमाल किया था .+।

— २26

6

सी, 128 बाइट्स

हाँ, सी। और यह भी कुछ गूढ़ लोगों की तुलना में छोटा है।

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

_पर्याप्त रूप से बड़े, खाली char *बफर पर कॉल करें ।

_{हो सकता है कि एक किशोर मूतक संकलक निर्भर हो। जीसीसी का उपयोग करके परीक्षण किया गया; फ़ाइल कोड पृष्ठ 1252 में सहेजी गई थी।}

— गुमनाम
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 812 745 657 650 536 520 416 बाइट्स

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

संपादित करें: ISO8859-1 एन्कोडिंग का उपयोग करते हुए, यह समाधान 520 बाइट्स के बजाय 416 बाइट्स है। पूरा कार्यक्रम 432 बाइट्स का है, जिसके लिए अतिरिक्त 16 बाइट्स को ध्यान में रखा गया है

f=\r\n
416 byte submission here\r\n
alert(f())

यह एक फ़ंक्शन सबमिशन है, एक पूर्ण कार्यक्रम के विपरीत। मैंने JJEncode ( उस के लिए darrylyeo के लिए हैट-टिप ) में काफी लंबा समय बिताया , लेकिन गोल्फ के बजाय

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

मैंने गोल्फ किया

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

जहां ओवरहेड में Øइनिशियलाइज़ किया ""जाता है।

अल्पविराम ऑपरेटरों के साथ फिर से जुड़कर नई सुर्खियों में आए:

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

व्याख्या

यह स्क्रिप्ट कुछ अंतर्निहित प्रकारों को शुरू करने और उन्हें तार में प्रस्तुत करने से शुरू होती है। अल्फ़ान्यूमेरिक वर्णों का उपयोग किए बिना हम जो तार प्राप्त कर सकते हैं वे हैं:

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

इन तारों से, और व्यक्तिगत पात्रों को संदर्भित करने के लिए आवश्यक अंक, हम तार प्राप्त कर सकते हैं returnऔर constructor, जिनका उपयोग किया जा सकता है:

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

ऑब्जेक्ट का कंस्ट्रक्टर Object(), और इसका कंस्ट्रक्टर है Function(), जिसे हम अनिवार्य रूप से उपयोग कर सकते हैं eval()।

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

एन्कोडेड स्क्रिप्ट में निर्मित वर्णमाला के वर्णों के लिए, जो निर्मित-इन्स का उपयोग करके एक्सेस नहीं किया जा सकता है, JJEncode ऑक्टल एस्केप का उपयोग करता है उनका प्रतिनिधित्व करने के लिए, फिर पूरे स्ट्रिंग को एक आंतरिक फ़ंक्शन से वापस लौटाता है। स्रोत को निष्पादित करने के लिए बाहरी फ़ंक्शन को बुलाया जा सकता है।

डेमो

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

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

— पैट्रिक रॉबर्ट्स
स्रोत

5

ब्रेन-फ्लैक , 171 बाइट्स

के लिए +3 शामिल है -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

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

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

ऐड 1 "फ़ंक्शन" को दोहराए बिना ऐसा करने का एक तरीका शायद है।

— रिले
स्रोत

5

जूलिया 0.4 , 46 बाइट्स

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

यह एक जेनेरिक फ़ंक्शन है जो वर्ण सरणी देता है।

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

वैकल्पिक संस्करण, 47 बाइट्स, ASCII- केवल

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

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

— डेनिस
स्रोत

5

जे, 171 बाइट्स

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

ओउ ... मेरा दिमाग दर्द करता है ... इसे ऑनलाइन प्रयास करें!

यहाँ आप इसे एक लाइन के साथ देख सकते हैं (यह नहीं चलेगा, हालांकि, लाइन टूट जाती है।)

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

केवल j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52उसी क्रम में जे संस्करण के साथ काम करने की गारंटी है । (केवल पहले 12 अक्षर मायने रखते हैं।)

व्याख्या

कार्यक्रम का अधिकांश भाग निरंतर पीढ़ी को समर्पित है। उन स्थिरांक के साथ उनके मूल्यों को प्रतिस्थापित किया जाता है, कार्यक्रम इस तरह दिखता है:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

कुछ कोष्ठकों को हटा दिया गया, और कुछ संख्याओं को अच्छा बना दिया गया:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

यह s ,और ,~s के एक समूह से बना है , जो तर्क और तर्क प्रस्तुत करता है। यहाँ अलग मूल्य हैं:

":26
('.',~10{9!:14'')
'+/'
(":65 97 48)
','
(':',~12{9!:14'')

1है 26एक स्ट्रिंग के रूप।

9!:14'' TIO पर निम्न स्ट्रिंग उत्पन्न करता है:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

के साथ 2, हम 10वें वर्ण ( iसे linux) प्राप्त करते हैं , और इसमें .से एक को जोड़ते हैं , उपज i.।

3और 5आत्म-व्याख्यात्मक हैं।

465 97 48एक स्ट्रिंग के रूप में संख्याओं की सूची है ।

6के समान है 2, सिवाय इसके कि यह 12वें वर्ण ( uसे linux) है और एक :, अंत में जोड़ता है , उपज है u:।

यह, सभी एक साथ, पैदावार u:,65 97 48+/i.26। ".इसका मूल्यांकन करता है, हमें दे रहा है:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(नोट: +/इसके अलावा सारणीबद्ध है।)

फिर, इसके साथ 62{., हम पहले 62अक्षर लेते हैं , हमें दे रहे हैं ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789।

— कोनोर ओ ब्रायन
स्रोत

आप लगातार 14 प्राप्त कर सकते हैं <:<.^^*_जो एक बाइट बचाता है। इसके अलावा, मैंने पूरी रेंज तैयार करने और प्रतीकों को हटाने के लिए ':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++'104 बाइट्स प्राप्त करने की कोशिश की । मुझे यकीन है कि यह बहुत कम मिल सकता है

— मील

5

05AB1E , 18 15 11 बाइट्स

-4 अदनान के लिए धन्यवाद, क्योंकि यदि इनपुट का आकार 1 है, तो 05AB1E पहले कमांड पर b के लिए 0 का उपयोग करेगा।

•£•Ýç©á®þ«˜

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

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it.

मैंने बहुत सारे अलग-अलग तरीकों की कोशिश की, लेकिन यहाँ मुख्य बिंदुओं ने इसे कठिन बना दिया है:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

— जादू ऑक्टोपस Urn
स्रोत

1

You may print them in arbitrary orderचुनौती कहते हैं।

— AdmBorkBork

1

— अदनान

@ अदनान अच्छा है, यह नहीं जानता कि यह 0 का उपयोग करता है जब कोई बी नहीं है।

— मैजिक ऑक्टोपस Urn

5

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

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

आउटपुट:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

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

टेप को 3 · 2 ^{n पर} आरंभ करता है, और वहां से काम करता है।

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

— Primo
स्रोत

5

पर्ल 6 , 43 बाइट्स - नॉनकमेटिंग

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

एक लंबोदर जो पात्रों की सूची देता है।
स्पष्टीकरण:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Rakudo Perl 6 दुभाषिया के लिए एक बगफिक्स पर निर्भर करता है जो केवल आज git रेपो के लिए प्रतिबद्ध था, और अभी तक एक आधिकारिक Rakudo रिलीज का हिस्सा नहीं है। वास्तव में, मैंने इस चुनौती का जवाब देते हुए बग का सामना किया, और पर्ल 6 कोर देवों में से एक की मदद से तय होने में कामयाब रहा। इस साइट के नियम, जैसा कि मैं उन्हें समझता हूं, ऐसी स्थिति में जवाब देने की अनुमति न दें, इसलिए मैंने इसे नॉन-कमिंग के रूप में चिह्नित किया।

— SMLS
स्रोत

41 बाइट्स

— जो किंग

4

PHP 7.0+, 110 बाइट्स

भगवान ने बिटवा के तार आशीर्वाद दिए!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

\nएक वास्तविक * NIX- शैली नईलाइन के साथ बदलें ।
यह कोड में मौजूद है ताकि नए सिरे से समस्याओं से बचा जा सके, लेकिन अंक में नहीं गिना जाता।

यह चेतावनी का एक गुच्छा फेंकता है, लेकिन @हर आवारा के सामने एक जोड़कर उन्हें प्रभावित किया जा सकता है _।

चेतावनी मुफ्त , 113 बाइट्स

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

— इस्माइल मिगुएल
स्रोत

3

65c02 मशीन भाषा + Apple] [ROM, 25 बाइट्स

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

प्रिंट करता है abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789।

पर शुरू होना चाहिए $8000।

disassembly

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS

— insert_name_here
स्रोत

यह कोडपॉइंट नियम का उल्लंघन करता है- आप वर्णों का उपयोग किसी भिन्न वर्ण सेट में कर रहे हैं। बाइट्स तब तक ठीक होते हैं जब तक कि वे आईटीआर नहीं होते हैं या कोड द्वारा पढ़े जाते हैं।

— dkudriavtsev

@wat आह, ठीक है। मैंने अपना कोड संपादित किया है ताकि वह किसी भी मशीन कोड बाइट्स का उपयोग न करे जो अल्फ़ान्यूमेरिक वर्णों के नक्शे को "सामान्य" (सकारात्मक) ASCII में इस्तेमाल करता है और किसी भी सकारात्मक या नकारात्मक ASCII अल्फ़ान्यूमेरिक शाब्दिक का उपयोग नहीं करता है ; क्या यह अब वैध है?

— --___ कहीं

मुझे ऐसा लगता हैं... ।_।

— dkudriavtsev

@wat वर्तमान में उपयोग किए जाने वाले बढ़ते हुए क्रम में कोड बिंदु हैं 10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253, जो कि उन वर्णों के मानचित्र हैं ↵.. ,`.¢©¯ÀÊÐàíùýजहाँ .s अनपेक्षित वर्ण हैं। यह मान्य है

— पैट्रिक रॉबर्ट्स

3

बैश (लाइनक्स पर), 507 493 490 485 बाइट्स

यह वैश्विक चर में वर्णों की एक सरणी संग्रहीत करता है __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

इसे एक नए सिरे से बूट लाइनक्स मशीन के साथ निष्पादित किया जाना चाहिए /proc, या एक पिड नेमस्पेस जैसा कुछ

स्पष्टीकरण:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

इसे आज़माने के लिए हम declare -p __परिणाम को प्रदर्शित करने के लिए अंत में जोड़ सकते हैं

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

— izabera
स्रोत

+1। मुझे लगता है कि आपको लिनक्स पर बैश के रूप में यह कहना चाहिए कि अन्य OSes (जैसे MacOS) में नहीं है /proc। वास्तव /procमें, लिनक्स पर कड़ाई से आवश्यक नहीं है, हालांकि इसके बिना आधुनिक डिस्ट्रो को खोजने के लिए आपको शायद ही दबाया जाएगा।

— डिजिटल ट्रामा

3

जावास्क्रिप्ट, 1273 1351 1610 बाइट्स

यह समाधान अन्य दो इस धागे पर जवाब के रूप में अनिवार्य रूप से उसी तरह काम करता है यहाँ और यहाँ है, जहां यह से पत्र का उपयोग करता है true, false, undefined, और [object Object]तार कार्यों है कि यह अन्य पत्र उत्पन्न करने के लिए की जरूरत है बनाने के लिए।

चूँकि अक्षरों की एक अच्छी संख्या पहले से ही ऑब्जेक्ट में रखी गई है, मैंने शेष बचे हुए सभी छोटे अक्षरों और संख्याओं को ऑब्जेक्ट में जोड़ने की कोशिश की, और फिर ऑब्जेक्ट में मौजूद toUpperCaseसभी मानों को गायब किए गए बड़े अक्षरों को उत्पन्न करने के लिए लागू किया ।

अपडेट करें:

मैं उस तरीके को सुधारने में सक्षम था जो अष्टांगिक मूल्यों को निर्धारित कर रहा था, लेकिन वे अभी भी 13 x 30 बाइट्स ले रहे हैं (या वे 30 बाइट्स होंगे प्रत्येक के बाद मैं अलग-अलग कुंजियों में नंबर बदलता हूं), प्रत्येक अब इस सामान्य का अनुसरण करता है पैटर्न: $.ž=\'\\'+$.一+$.七+$.二+'\';।

अतिरिक्त 49 बाइट्स को आसानी से 2 बाइट वर्णों की संख्या के लिए कुंजियों को स्विच करके निकाला जा सकता है।

वर्तमान प्रस्तुत:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

— मार्टिन
स्रोत

1

यह दिलचस्प लगता है, लेकिन जैसा कि यह है, यह बहुत गोल्फ नहीं है। बस व्हाट्सएप को हटाने से 74 बाइट्स बचेंगे, सिंगल कोट्स का इस्तेमाल ऐसे स्ट्रिंग्स के लिए किया जा सकता है जिसमें डबल कोट्स हों, और 3-बाइट यूनिकोड के पात्रों को कम महंगे लोगों के साथ बदला जा सके।

— डेनिस

@ डेनिस सच है, हालांकि मुझे लगता है कि अभी इस पद्धति के साथ सबसे बड़ी समस्या यह है कि बहुत सारे चरित्र अष्ट कोड के साथ सेट किए जा रहे हैं।

— मार्टीन

3

सी (क्लैंग) , 164 बाइट्स

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

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

यह एक पुनरावर्ती फ़ंक्शन है जो 1 के मान (स्वयं और घटाना से घटाना) के साथ शुरू करके वर्ण प्राप्त करता है, और उसी से अन्य सभी संख्याएं बनाता है।

Ungolfed / Explaination:

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}

— Logern
स्रोत

2

सीजेएम , 15 बाइट्स

"{`[@:/"_:,:^\-

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

व्याख्या

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

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

2

S, 8 चार्ट / 19 बाइट्स

ᶐ+ᶛ+⩥Ⅹă⬯

यहाँ यह कोशिश करो!

ᶐअपरकेस वर्णमाला, है ᶛलोअरकेस वर्णमाला है, और ⩥Ⅹă⬯रेंज (है ⩥) से 0करने के लिए 10( Ⅹ, यूनिकोड रोमन संख्या) शून्य 1, द्वारा (शामिल हो गए ă) कुछ भी नहीं ( ⬯)।

— कोनोर ओ ब्रायन
स्रोत

सभी ASCII वर्णमाला वर्णों का उपयोग किए बिना उन्हें प्रिंट करें

चुनौती

नियम

स्पष्टीकरण

वी , 8 7 बाइट्स

व्याख्या

ऑक्टेव , 52 46 40 बाइट्स

व्याख्या

ब्रेनफक , 77 76 75 72 बाइट्स

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

रूबी, 42 बाइट्स

6502 मशीन भाषा, 74 70 68 बाइट्स

हास्केल , 75 72 63 58 56 बाइट्स

पर्ल (5.10 या 5.12), 30 29 बाइट्स

दरअसल 8 5 4 बाइट्स

PHP, 69 बाइट्स

जावा (ओपनजेडके 9) , 277 बाइट्स

असंगठित और परीक्षण

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

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

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

बेफुज, 73 72 59 57 55 53 बाइट्स

जेली , 17 16 बाइट्स

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

सेल्फ-मॉडिफाइंग ब्रेनफक , 32 बाइट्स

सी, 128 बाइट्स

जावास्क्रिप्ट (ईएस 6), 812 745 657 650 536 520 416 बाइट्स

व्याख्या

डेमो

ब्रेन-फ्लैक , 171 बाइट्स

जूलिया 0.4 , 46 बाइट्स

वैकल्पिक संस्करण, 47 बाइट्स, ASCII- केवल

जे, 171 बाइट्स

व्याख्या

05AB1E , 18 15 11 बाइट्स

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

पर्ल 6 , 43 बाइट्स - नॉनकमेटिंग

PHP 7.0+, 110 बाइट्स

65c02 मशीन भाषा + Apple] [ROM, 25 बाइट्स

disassembly

बैश (लाइनक्स पर), 507 493 490 485 बाइट्स

जावास्क्रिप्ट, 1273 1351 1610 बाइट्स

सी (क्लैंग) , 164 बाइट्स

सीजेएम , 15 बाइट्स

व्याख्या

S, 8 चार्ट / 19 बाइट्स