अक्षर A के बिना

69

आपका कार्य पत्र "ए" को अकेले प्रदर्शित करना है, बिना किसी अन्य चीज़ के, बिना किसी नए रूप के अनुगामी के यदि आप उनसे बच नहीं सकते हैं, तो ऐसा किसी कार्यक्रम और / या स्निपेट में करें। कोड जो वापस लौटता है (छपाई के बजाय)।

"A" अक्षर के लोअरकेस और अपरकेस संस्करण स्वीकार्य हैं (अर्थात, यूनिकोड U + 0061 या यूनिकोड U + 0041 हैं । अन्य वर्ण एन्कोडिंग जो यूनिकोड की अनुमति नहीं हैं, लेकिन किसी भी तरह से, आपके कोड के परिणामस्वरूप आउटपुट होना चाहिए। लैटिन अक्षर "ए" हो, और कोई भी लुकलेस या होमग्लाइफ़ न हो)

आपके कूट में से कोई भी नीचे वर्ण का उपयोग नहीं करना चाहिए , चाहे आप जो भी वर्ण कूटबन्धन करें:

  • " ए ", चाहे अपरकेस या लोअरकेस।

  • " यू ", चाहे लोअरकेस या अपरकेस।

  • एक्स , चाहे अपरकेस या लोअरकेस।

  • +

  • और

  • #

  • 0

  • 1

  • 4

  • 5

  • 6

  • 7

  • 9

धोखा, खामियों, आदि की अनुमति नहीं है।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा समाधान, जो सभी नियमों का पालन करता है, विजेता है।

वैधता परीक्षक

यह स्टैक स्निपेट यह सुनिश्चित करने के लिए जांचता है कि आपका कोड प्रतिबंधित वर्णों का उपयोग नहीं करता है। यह कुछ चरित्र एन्कोडिंग के लिए ठीक से काम नहीं कर सकता है।

var t = prompt("Input your code.");

if (/[AaUuXx+&#0145679]/.test(t)) {
  alert("Contains a disallowed character!");
} else {
  alert("No disallowed characters");
}
स्निपेट का विस्तार करें

यह स्टैक स्निपेट जो सुनिश्चित करता है कि आपके पास एक अस्वीकृत चरित्र नहीं है, JSFiddle पर भी उपलब्ध है ।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  restricted-source 
— बफर ओवर पढ़ें
स्रोत
7
@ColdGolf आप कार्यों के लिए "हां" कहते दिख रहे हैं, लेकिन फ़ंक्शन प्रदर्शित नहीं होते हैं, वे आमतौर पर वापस लौटते हैं।
— xnor
2
एक चर है कि अभी aभी काफी अच्छा होता है के साथ समाप्त हो रहा है?
— टन हास्पेल
1
मेरा वह मतलब नहीं था। वेरिएबल असाइनमेंट करने वाले कथित कोड में कोई भी निषिद्ध वर्ण नहीं होगा। मैं बस यह समझने की कोशिश कर रहा हूं कि "मुद्रण के अलावा अन्य तरीकों से प्रदर्शन" क्या है। यदि "एक फ़ंक्शन से वापस आना" ठीक है, तो "एक चर को असाइन करें" के बारे में क्या?
— टन हास्पेल
1
वो खास किरदार क्यों?
— इमिबिज़
7
@ Aस्पष्ट कारणों के लिए स्तन । Uयूनिकोड बच तार (के लिए \u0041है A), Xहेक्स भागने तार (के लिए \x41), +यूनिकोड ऑर्डिनल्स (के लिए U+0041), &एचटीएमएल संस्थाओं के लिए, #के लिए मैं वास्तव में नहीं पता है, 65की दशमलव क्रमसूचक है A, 41की हेक्स क्रमसूचक है A, 97की दशमलव क्रमसूचक है a, और 0पिछले कुछ कारणों से।
— मेगो

जवाबों:

86

प्लसो, 1 बाइट

o

प्लसो एसोलांग्स पेज ।

प्लसो में एक एकल संचायक होता है, जो मान 1 से शुरू होता है। यह दो कमांड्स का उपयोग करता है, p जो संचायक (मॉड 27) को बढ़ाता है, और o जो वर्तमान मान को अपरकेस ASCII वर्ण, AZ या स्पेस के रूप में प्रिंट करता है (जहां 1-26 का प्रतिनिधित्व करता है) AZ क्रमशः, और 0 अंतरिक्ष का प्रतिनिधित्व करता है)।

संचायक 1 से शुरू के रूप में, आदेश ओ कोई पूर्व के साथ पी इच्छा उत्पादन एक ।

— CDW
स्रोत
14
PPCG में आपका स्वागत है! मैं आपके जवाब में स्पष्टीकरण डालने की सलाह दूंगा, अगर किसी कारण से लिंक की मृत्यु हो जाती है।
— TheBikingViking
स्पष्टीकरण जोड़ा गया। मॉडरेटर की मंजूरी का इंतजार
— केपीएम
2
सिफारिश (और स्वागत) के लिए धन्यवाद, मैंने एक संक्षिप्त विवरण शामिल करने के लिए अपना जवाब अपडेट किया है।
— cdw
मैं सिर्फ 666 प्रतिनिधि पर डाल दिया। उसके लिए माफ़ करना।
— एडन एफ। पियर्स
5
क्या यह विफल नहीं है "यह एक एसोलंग" परीक्षण है क्योंकि यह व्यावहारिकता की जाँच नहीं कर सकता है?
— मैजिक ऑक्टोपस Urn
155

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

print`3<3`[~3]

अभिव्यक्ति 3<3बूलियन देता है False, और बैकटिक्स अपना स्ट्रिंग प्रतिनिधित्व देता है 'False'। यहां से, यह पत्र निकालने के लिए बना हुआ है a। पायथन 0-अनुक्रमित है, इसलिए aसूचकांक में है 1, जो एक प्रतिबंधित चरित्र है। इसे व्यक्त किया जा सकता है 3-2, लेकिन इसका एक छोटा तरीका है। पाइथन -1अंतिम प्रविष्टि के लिए इंडेक्स के साथ पीछे से इंडेक्सिंग की अनुमति देता है , -2इससे पहले कि एक के लिए, और इसी तरह। हम सूचकांक चाहते हैं -4, लेकिन 4एक प्रतिबंधित संख्या भी है। लेकिन, हम इसे ~3बिट-सप्लीमेंट का उपयोग करके व्यक्त कर सकते हैं ~, जो इसके लिए देता -n-1है ~n।

— XNOR
स्रोत
7
यह वास्तव में अच्छा समाधान है। इसके अलावा, आप के [2]बजाय नहीं कर सकता [~3]?
— DJMcMayhem
6
@DJMcMayhem यह दुर्भाग्य से 0-अनुक्रमित है, इसकी आवश्यकता होगी [1]।
— xnor
4
... क्यों 1और 4'प्रतिबंधित' नंबर हैं ??
— क्रिस Cirefice
4
चुनौती के नियम ऐसा कहते हैं।
— xnor
20
अब मैं "~ 0" को "शून्य अनुक्रमित पहला तत्व पीछे से पढ़ा जा रहा है" का उपयोग करने पर भी विचार कर रहा हूं। मुझे आश्चर्य है कि हम पायथन में "-1" अंकन का उपयोग क्यों करेंगे ....
— पास्कलवूटेन
48

PHP, ९ ६ बाइट्स

<?=O^_^Q;

9 बाइट्स के लिए: @ टॉन हास्पेल के जवाब से प्रेरित । साथ ही, इसमें काओमीजी की तरह दिखने का अतिरिक्त लाभ है। :-)

6 बाइट्स बेहतर संस्करण:

<?=~¾;

जिसमें 0xBE का हेक्स कोड है (यह लैटिन -1 एन्कोडिंग में फ़ाइल को सहेजना महत्वपूर्ण है , न कि एफएफ़ -8!)।

— YetiCGN
स्रोत
एक वैकल्पिक संस्करण है f^E^b।
— इस्माइल मिगुएल
हां, 9-बाइट समाधान प्रचुर मात्रा में हैं। मैंने y ^ '8' और x ^ '9' के साथ शुरुआत की, दुर्भाग्य से संख्याओं को स्ट्रिंग में डालना होगा या यह XOR होगा जिसके परिणामस्वरूप प्रकार पूर्णांक होगा।
— यतिसीजीएन
23
चेहरे के लिए +1^_^
— Cyoce
6 बाइट संस्करण प्रिंट नहीं करता है A। यह प्रिंट करता है =A।
— यूटीएफ -8
1
मुझे अब इस पहेली का उत्तर पता है: UTF-8 में "अंश तीन तिमाहियों" कोडपॉइंट को दो बाइट्स के रूप में एन्कोड किया गया है: 0xC2 0xBE , 0xBE ISO-8859-1 में समान है । मैंने देखा कि जब मैंने इसे अपने लिनक्स बॉक्स पर एक फ़ाइल में सहेजा था, जिसे मैं SSH के साथ UTF-8 के माध्यम से एक्सेस करता हूं, तो निश्चित रूप से, यह फ़ाइल 7 बाइट्स है । इसलिए, लैटिन -1 एन्कोडिंग के साथ स्क्रिप्ट को बचाएं और यह 6 बाइट्स होगा और =चरित्र को आउटपुट नहीं करेगा ।
— यतिसीजीएन
32

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

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

यह 159 के लिए एसोलंग के ब्रेनफक एल्गोरिदम पर आधारित है ।

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

— डेनिस
स्रोत
3
यह .... यह विज़ार्ड है।
— कॉनर ओ'ब्रायन
3
यह समाधान इंडेक्स -1 में सेल का उपयोग करता है, जो सभी ब्रेनफोक दुभाषियों में समर्थित नहीं है और इसके परिणामस्वरूप दुर्घटना होगी। आप इसे यहाँ देख सकते हैं fatiherikli.github.io/brainfuck-visualizer/…
— Cody
37
पीपीसीजी पर @ कोडी, भाषाओं को उनके कार्यान्वयन द्वारा परिभाषित किया गया है। जब तक एक दुभाषिया होता है जो वांछित व्यवहार करता है, यह एक वैध समाधान है।
— डेनिस
3
निषिद्ध पात्रों से बचना आपके लिए कितना कठिन था?
— हेगन वॉन एटिजन
1
@HagenvonEitzen मुझे एक एल्गोरिथ्म खोजने के लिए थोड़ा खोदना पड़ा, जिससे बच सकते थे +। ( ए प्रिंट करने का सबसे छोटा तरीका होगा >+[+[<]>>+<+]>.), लेकिन एसोलंग पर स्थिरांक की सूची के लिए धन्यवाद, बहुत मुश्किल नहीं है।
— डेनिस
30

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

नील को धन्यवाद दो बाइट्स बचाए!

_=>` ${-_}`[2]

का दूसरा चरित्र लौटाता है NaN, जो है a।

यह कम से कम मैं के लिए साथ आने सकता है A, 43 42 बाइट्स:

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

कौन कहता है कि एक पर्यवेक्षक कोड गोल्फ के साथ मदद नहीं करता है? मैं नहीं!

स्पष्टीकरण

पहले वाला, गहराई में।

_=>` ${-_}`[2]

-__अपरिभाषित है , क्योंकि NaN है। इसे स्ट्रिंग के रूप में प्राप्त करने के लिए, निम्न में से किसी एक की आवश्यकता होगी:

-_+""
`${-_}`
(-_).toString()

अंतिम बहुत लंबा है, और पहला उपयोग करता है +। इसलिए हम दूसरे का उपयोग करते हैं। अब, aसूचकांक में है 1। यह कोई अच्छा नहीं है, क्योंकि 1निषिद्ध है। हालांकि, एक टेम्पलेट स्ट्रिंग होने के नाते, हम इसे इंडेक्स में बनाने के लिए एक जगह रख सकते हैं 2, इस प्रकार हमें छोड़ सकते हैं ` ${-_}`।

दूसरा, गहराई में।

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

यह एक डोज था।

_=>`                                `[-~8]

यह अंदर के टेम्पलेट स्ट्रिंग का 9 वां वर्ण है, 9 के -~8बराबर है। इस मामले में, यह टेम्पलेट स्ट्रिंग स्ट्रिंग के लिए है। यह अंदर का समीकरण कड़ा किया जा रहा है, बीच में ${...}:

[][`constr${`${!_}`[2]}ctor`]

आइए इसे थोड़ा विस्तार दें:

(new Array())[`constr${`${!_}`[2]}ctor`]

यह एक खाली सरणी से संपत्ति प्राप्त करता है। यह संपत्ति, बेशक, एक टेम्पलेट स्ट्रिंग है, लेकिन इसके चारों ओर कुछ पाठ है। यह लगभग बराबर है:`constr${${!""}[2]}ctor`

"constr" + `${!_}`[2] + "ctor"

अंदर बारी के बराबर है:

(!_).toString()[2]

!_है true(क्योंकि _है undefined, और !undefined === true), और stringified है "true"। हमें इसका दूसरा चरित्र मिलता है u; हमें uअपने कोड में स्पष्ट रूप से डालने से बचने के लिए इसे प्राप्त करना होगा ।

तो, यह अंदर बिट के बराबर है:

"constr" + "u" + "ctor" === "constructor"

तो हम Array, Arrayfunction का कंस्ट्रक्टर प्राप्त कर रहे हैं । मैं इसे स्पष्ट रूप से नहीं बता सकता क्योंकि इसमें निषिद्ध है A। अब, Arrayफ़ंक्शन पैदावार को सख्त करता है "function Array() { [native code] }"।

मूल कोड पर वापस:

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

जैसा हमने देखा है, यह इसके बराबर है:

_=>Array.toString()[-~8]

के बराबर:

_=>Array.toString()[9]

अंत में इसके बराबर:

_=>"A"
— कोनोर ओ ब्रायन
स्रोत
1
@ColdGolf यह ठीक है।
— कॉनर ओ'ब्रायन
2
क्या किसी स्पष्टीकरण को जोड़ने के लिए एक पर्यवेक्षक के सिद्धांतों के खिलाफ होगा ...? मैं उत्सुक हूं कि यह कैसे काम करता है।
— ट्राइकोप्लाक्स
2
@trichoplax मुझे लगता है कि यह मेरे तरीके यहाँ प्रकट करने के लिए चोट नहीं होगा;) मैंने दोनों के लिए एक स्पष्टीकरण जोड़ा।
— कॉनर ओ'ब्रायन
1
@ OldBunny2800 नंबर aएक निषिद्ध चरित्र है, और में है toUpperCase।
— कॉनर ओ'ब्रायन
3
मैंने सोचा था कि यह पहले पर्ल था।
— Οurous
29

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

अय्या ल्मो? एक गैर-गोल्फिंग भाषा के लिए काफी गोल्फ। कोड:

B(;@

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

अधिक पठनीय रूप:

 B (
; @ .
 . .

यह अक्षर के ASCII मान को B, जो वर्तमान मेमोरी एज पर 66 है, डालता है । यह एक का उपयोग करके इसे प्रतिस्थापित करता है (और इसके साथ प्रिंट करता है ;। उसके बाद, प्रोग्राम का उपयोग करके समाप्त कर दिया जाता है @।

अप्रचलित पथ छवि:

यहाँ छवि विवरण दर्ज करें

— अदनान
स्रोत
8
"अधिक पठनीय" + हेक्सागोनी = ???
— चार्ल्स
18

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

ØWḢ

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

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

ØWḢ  Main link. No arguments.

ØW   Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_".
  Ḣ  Head; extract the first character.

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

l-ṾṂ

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

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

l-ṾṂ  Main link. No arguments.

l-    Take the logarithm of 0 with base -1. Yields (nan+infj).
  Ṿ   Uneval; yield the string representation, i.e., "nanıinf".
   Ṃ  Take the minimum, returning 'a'.
— डेनिस
स्रोत
1
बहुत बुरा दूसरा दृष्टिकोण लंबा है। ._।
— डेनिस
6
दूसरे दृष्टिकोण को शामिल करने के लिए धन्यवाद। यह सुंदर है
— ट्राइकोप्लेक्स
18

दरअसल , 2 बाइट्स

úF

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

स्पष्टीकरण:

úF
ú   lowercase English alphabet
 F  first element
— मेगो
स्रोत
क्या आप लेखक हैं? मैंने पहले इस भाषा को नहीं देखा है।
— loa_in_
मैंने देखा है कि यह अब चुनौतियों में एक दो बार पॉप अप करता है। मुझे लगता है कि यह साइट पर किसी भी गोल्फिंग भाषा का सबसे चतुर नाम है :-) मैं हाल ही में सूट देख रहा हूं और मुझे लगता है कि यह बहुत हार्वे है।
— corsiKa
12

बबलगम , 1 बाइट

"

या

B

हर कोई यह अस्तित्व में भूल गया लग रहा था ...

— jimmy23013
स्रोत
पहले कभी बबलगम का उपयोग नहीं किया था, इसलिए शायद मेरी अज्ञानता का बहाना है, लेकिन मैं बबलगम के लिए डॉक्स कहां पा सकता हूं? इसके अलावा, मैंने आपके दोनों उत्तरों के साथ bubblegum.tryitonline.net की कोशिश की , लेकिन यह कुछ भी आउटपुट नहीं करता है।
— केविन क्रूज़सेन
1
@KevinCruijssen डॉक्टर: esolangs.org/wiki/Bubblegum : TIO केवल स्रोत कोड के hexdump स्वीकार करते हैं, तो इस तरह यह प्रयास करने के लिए लग रहा था bubblegum.tryitonline.net/...
— jimmy23013
आह, यह मेरी समस्या है; हेक्सडंप का उपयोग नहीं कर रहा है। धन्यवाद और +1 एकल-बाइट उत्तर (प्लसो से बंधा हुआ) के साथ सबसे छोटा होने के लिए।
— केविन क्रूज़सेन
@ केविनक्रूजसेन 1 बाइट प्लसो उत्तर है। यह एक अजीब साइट नियम के साथ कुछ समस्याएं हैं, हालांकि।
— jimmy23013
10

पर्ल, ९ 9 बाइट्स

Xor अभी भी अनुमति है, लेकिन sayनहीं है। तो 9 बाइट्स के लिए:

print$/^K

हालांकि STDERR को आउटपुट का उपयोग करने से 8 बाइट्स मिलते हैं:

die~"\x9e\xf5"

बदलें \x9eऔर \xf5उनके शाब्दिक संस्करणों द्वारा। या निष्पादन योग्य फ़ाइल का उपयोग करके उत्पन्न करें:

perl -e 'printf q(die~"%s"),~"a\n"' > a.pl
— टन हास्पेल
स्रोत
@ कॉल्डगॉल्फ: यह मेरे लिए स्पष्ट नहीं है। क्या आपका मतलब है कि मैं sayमुद्रण के लिए (ए) का उपयोग कर सकता हूं जब तक कि तर्क का निर्माण निषिद्ध पात्रों का उपयोग नहीं करता है?
— टन हास्पेल
"हालांकि, आपको अपने कोड में नीचे दिए गए किसी भी वर्ण का उपयोग नहीं करना चाहिए: * ए, चाहे अपरकेस या लोअरकेस।" उसी से, मैं print "No using the letter with code point 65";।
— हयकम
@ColdGolf का मतलब किसी भी तरह से सवाल का जवाब देना है?
— हॉब्स
10

> <> , 6 बाइट्स

'|;o-$

यह वर्णों की एक स्ट्रिंग बनाता है, उछलता है और इसे फिर से बनाता है, शीर्ष 2 स्टैक आइटमों को घटाता है और घटाता है: '|' (124) माइनस;) (59) 'ए' (65) है

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

— torcado
स्रोत
2
अच्छा! मैं '$-o;|जो लगभग समान है, लेकिन उछल के बिना है। ( |;o-$'यह भी काम करता है।)
— रैंडम
1
@randomra ओह सच! यह निश्चित रूप से तेजी से चलेगा, इतना अच्छा काम
— torcado
10

रूबी, 15 12 बाइट्स

$><<to_s[-3]
— जॉर्डन
स्रोत
1
आप 2 बाइट्स को बदलने के $><<लिए p , बनाता हैp to_s[-3]
— Ephi
@ Ephi अपने तर्कों पर pकहता inspectहै, इसलिए आउटपुट उद्धृत किया जाएगा, जो इसे अयोग्य घोषित करेगा।
— जॉर्डन
मैंने चुनौती के उस हिस्से को याद किया, मैं उन टिप्पणियों को जाने दूंगा क्योंकि मुझे लगता है कि यह एक दिलचस्प जानकारी है :)
— इफी
10

जावा, 55 बाइट्स

void f(){System.err.write('c'-2);System.err.println();}

चूंकि कोड को प्रिंट करना होता है, इसलिए दो निर्मित लेखकों में से एक की आवश्यकता होती है। System.outयह अच्छी तरह से है, क्योंकि इसमें शामिल है u। System.errहालांकि, काम करता है।

अगली बाधा जावा की हैंडलिंग charऔर है int। चूंकि इसमें शामिल होने की अनुमति नहीं है , charक्योंकि इसमें शामिल है a, और क्योंकि 'c' - 2पदोन्नत हो जाता है int, एक और तंत्र की आवश्यकता होती है। System.errएक है PrintWriter, जो एक write(char)विधि है, लेकिन नहीं है write(int)। 'c' - 2वहाँ डाल में यह charएक डाली के बिना मजबूर करता है ।

अंत में, हर बार जब मैं कार्यक्रम चलाता था तो बफर System.errऐसा नहीं होता था जैसा कि माना जाता है, और कार्यक्रम ने कुछ भी नहीं छापा। इसलिए मुझे इसे मैन्युअल रूप से फ्लश करना पड़ा। हालांकि, System.err.flush()इसकी अनुमति नहीं है, इसलिए मैंने फोन किया println()जो अंतर्निहित धारा को स्पष्ट रूप से प्रवाहित करता है।

9

MATL, 5 बाइट्स

YNVH)

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

व्याख्या

YN      % Creates a NaN value (not a number)
V       % Convert it to a string
H)      % Grab the second letter ('a')
        % Implicitly display the result

मेरे मूल जवाब सीधे आगे पूर्व निर्धारित शाब्दिक का उपयोग कर दृष्टिकोण था lY2जो पैदावार 'A'...'Z', और फिर पहला तत्व का चयन 'A'।

lY2l)
— Suever
स्रोत
9

जावास्क्रिप्ट, 18 बाइट्स 16 बाइट्स 12 बाइट्स 11 बाइट्स

` ${!2}`[2]

संशोधित आधार पर jsfuck मूल बातें (यह पता लगाने की को बदलने के लिए कैसे पड़ा +साथ -)।

Ungolfed?

ठीक है, कम से कम एक संस्करण टिप्पणी के साथ (ध्यान दें कि यह संस्करण शायद नहीं चलेगा):

` ${      // whitespace to make "a" the third letter
  !2      // returns false
}`        // convert to string "false"
[2]       // index the third letter in " false" (note the whitespace)

पुराना हल:

`${![]}`[-(-!![])]
— slebetman
स्रोत
आप कोष्ठक को माइनस संकेतों के बीच के स्थान से बदल सकते हैं।
— PurkkaKoodari
@ Pietu1998: मैंने देखा है कि 3इतना अनुमति दी है उबाऊ पुराने के साथ पूरी बात की जगह 3-2पाने के लिए1
— slebetman
कॉनर ओ'ब्रायन के जवाब के लिए एक बाइट के लिए धन्यवाद
— स्लीबेटमैन 15
1
उह, कोई अपराध नहीं है, लेकिन यह बहुत ज्यादा मेरा जवाब है। सिवाय आप NaN के बजाय गलत का उपयोग करें और एक फ़ंक्शन का उपयोग न करें।
— कॉनर ओ'ब्रायन
8

विम, 16 13 11 10 कीस्ट्रोक्स

दो चाबी बचाने के लिए एच वाल्टर्स का धन्यवाद

एक और बचत के लिए DJMcMayhem के लिए धन्यवाद!

:h%<cr>jvyZZp

:h%<cr> #open help for percent
jvy     #move down one char (to the letter "a"), visual mode the character, yank
ZZ      #exit help for percent
p       #put yanked character
— विनाशकारी नींबू
स्रोत
बहुत अच्छा तरीका!
— यतिजीएनएन
2
3 बाइट्स बचाओ; इसके बजाय :h<cr>, प्रयास करें :h%<cr>। यह एक अतिरिक्त चरित्र है, लेकिन आप %अपने कर्सर के साथ मदद के लिए हवा देते हैं । तो यहाँ से आप की जगह ले सकता 33llसाथ j।
— एच वाल्टर्स
स्पष्ट टाइपो के लिए क्षमा याचना ( 2 बाइट बचाओ )
— एच वाल्टर्स
आप एक दूसरे को बचाने के ZZबजाय उपयोग कर सकते हैं :q<cr>।
— DJMcMayhem
8

आर, 27 12 बाइट्स

EDIT: नया संस्करण, @ जारको डबेलडैम के एक उत्कृष्ट विचार से

LETTERS[T*T]

काफी मजेदार चुनौती!

मूल रूप से, यह 26thउल्टे वेक्टर के तत्व को अपरकेस अक्षर से युक्त करता है ( LETTERS, जो कि R का अंतर्निहित वेक्टर है)

पिछला संस्करण s (बाइट्स की समान संख्या) : 

L=LETTERS;rev(L)[length(L)]
rev((L=LETTERS))[length(L)]
— फ़्रेडरिक
स्रोत
1
थोड़ी देर, लेकिन आप के साथ काफी कुछ बचा सकते हैं LETTERS[T*T]। आंकिक संचालन करते समय Tमूल्यांकन करता है 1।
— JAD
— ग्यूसेप
यह तकनीकी रूप से एक समाधान नहीं है --- यह '[1] "a" प्रिंट करता है, बजाय केवल' a '
— JDL
8

> <> , 7 4 बाइट्स

टील पेलिकन के लिए धन्यवाद 3 बाइट्स सहेजे गए

"-o.

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

व्याख्या

"-o."   # pushes the string "-o."
-       # subtracts the charcode of o from the charcode of . (dot), 111-46=65
o       # prints as character
.       # tries to pop 2 coordinates to jump to, but as nothing is left on the stack
        # the program ends in an error
— Emigna
स्रोत
मैंने किया होगा"B"1-o;
— DanTheMan
@DanTheMan अधिक स्पष्ट समाधान होना चाहिए था। मुझे आश्चर्य है कि मैंने ऐसा क्यों नहीं सोचा: पी
— एमिग्ना
@ डैन मैन: - डैन ने जो पोस्ट किया है उसे देखते हुए आप इसे और कम कर सकते हैं; "1-ओ; बी या उससे भी बेहतर" + ओ; और या तो मामले में इस 5 बाइट्स बनाने की अनुमति है :) - आप इसे एक त्रुटि के साथ 4 बाइट्स भी बना सकते हैं; "-ओ।
— चैले पेलिकन
@ Tealpelican: यह शानदार है! स्ट्रिंग्स का उपयोग करना अक्सर इन जैसी चुनौतियों में सबसे छोटा होता है, लेकिन मैंने इस पर भी विचार नहीं किया :)
— Emigna
एक बार जब मैंने डैन की टिप्पणी को देखा, तो यह मुझे एक बड़ी चुनौती की तरह याद दिलाया, जैसे कि बस एक ही अवधारणा का उपयोग किया :)
— चैती पेलिकन
7

विम, 2 कीस्ट्रोक्स

vim -u NONEफिर निम्नलिखित को चलाएं ( -u NONEअनुकूलन बंद करता है)

i<up>

जब विम को संगत मोड में चलाया जाता है तो एरो कीज़ को ठीक से व्याख्यायित नहीं किया जाता है। <up>व्याख्या की जाती है <esc>OAजो डालने के मोड में निम्नलिखित छोड़ते हैं। जो छोड़ देगा (नई अनुगामी के एक जोड़े के साथ)

A

iसम्मिलित मोड शुरू होता है।
<up>सम्मिलित मोड से बाहर निकलता है, ऊपर एक लाइन खोलता है और ए बफर में प्रवेश करता है

जंगली में इसका सामना करने वाले लोगों का उदाहरण। https://stackoverflow.com/questions/6987317/while-moving-the-cursor-across-a-vim-process-open-in-a-tmux-session-every-now-a/6988748#6988748

— FDinoff
स्रोत
पढ़ते ही मुझे हंसी आ गई। यह अच्छा काम है। मुझे पता है कि कुछ का महान शस्त्रीकरण, लेकिन नहीं सोचा होगा।
— --डियोका
6

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

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

Hella बाइट को बचाने में मेरी मदद करने के लिए @NinjaBearMonkey का शुक्रिया

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------------------------------------।

मैं ब्रेनफक में अच्छा नहीं हूँ, इसलिए मुझे यकीन है कि एक छोटे से घोल का उपयोग किया जाता है, लेकिन यह 0 से नीचे घटने से काम करता है, बाइट को लुढ़काता है, और जब तक यह 'ए' तक नीचे नहीं जाता है, तब तक यह प्रिंट करता है।

— कोड़ी
स्रोत
1
गंभीर प्रतियोगी नहीं। यदि आप वास्तव में इसे नीचे गिराते हैं, तो नीचेवाला उनके वोट को पलट सकता है
— विनाशकारी नींबू
क्या यह सिर्फ 65 की संख्या के साथ 65 तक गिने जाने के लिए बहुत कम नहीं होगा?
— निन्जाबियरमोनकी
2
'+' की अनुमति नहीं है, इसलिए मुझे पीछे जाना पड़ा
— कोडी
क्षमा करें, मैंने ऐसा नहीं देखा। 191 बनाने के लिए अभी भी बहुत कम तरीके हैं , हालांकि।
— निन्जाबियरमॉन्की
2
यह 192 बाइट समाधान था, मैंने इसे छोड़ दिया और स्ट्राइकथ्रू को हटाने के बजाय किया क्योंकि मुझे लगा कि यह 192 से 19 तक अजीब था
— कोड़ी
6

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

_=>(8^2).toString(22)

मैंने मूल रूप falseसे इसे करने के लिए स्ट्रिंग में बदलने की कोशिश की , लेकिन उस समय मुझे 23 बाइट्स लगीं। मैं तब से एक छोटा रास्ता तय कर रहा हूं, जो 14 बाइट्स के लिए है:

_=>`!${!2}`[2]

मुझे नहीं लगता कि आप एक अपरकेस प्राप्त कर सकते हैं करते हैं A, क्योंकि आप में से एक की जरूरत नियमों के तहत, String.fromCharCodeया .toUpperCase(), जो दोनों के होते हैं a।

— नील
स्रोत
आप जेएसएफ का उपयोग कर अपरकेस प्राप्त कर सकते हैं या कम्प्यूटेड गुणों का उपयोग कर एक व्युत्पन्न कर सकते हैं
— डाउनगेट
1
@Downgoat कॉनर ओ'ब्रायन ने पहले ही दिखाया कि कैसे।
— नील
6

सी, (19?) 24 बाइट्स

डेनिस को धन्यवाद:

f(){printf("%c",88-23);}

एक ही लंबाई:

f(){printf("%c",'C'-2);}

जो भी कम सक्षम बनाता है:

f(){printf("%c",'c'-2);}

वहाँ एक है 19 बाइट्स एक समारोह अपने पैरामीटर है, जो एक दोष है को संशोधित करने के रूप में समाधान:

g(int*p){*p='C'-2;}

//Usage:

main(){
  int c; //cannot be char
  g(&c);
  printf("%c\n",c);
}

यदि cघोषित किया गया था char, तो यह gपूरी तरह से संशोधित हो जाता है intइसलिए यह स्टैक को नष्ट कर देता है जिसके कारण अन्य मान संशोधित होते हैं या प्रोग्राम त्रुटि संदेश के साथ निरस्त हो जाता है। इसे दरकिनार करने का एकमात्र तरीका यह है कि int c;आप इसे घोषित करें mainऔर इसके साथ प्रिंट करें "%c", लेकिन यह एक खामियों जैसा लगता है।

पुराने समाधान

f(){printf("%c",'B'-2/2);} //26 bytes
f(i){i='B';printf("%c",--i);} //29 bytes
f(){int*i="B";int j[]={*i-(2/2),2-2};printf("%s",j);} //53 bytes

सिर्फ एक कार्य, क्योंकि mainनिषिद्ध है।

— कार्ल नेफ
स्रोत
3
88-23कुछ बाइट्स बचाना चाहिए।
— डेनिस
लोअर केस के लिए, आप (333-33) / 3-3 का उपयोग कर सकते हैं। यह 'c'-2 जितना छोटा नहीं है, लेकिन यह 3er है। 33 * 3-2 भी संभव है।
— रिस्की
यदि आप प्रिंटफ के बजाय लेखन () का उपयोग करते हैं तो आप इसे एक कार्यक्रम बना सकते हैं; बिल्ड चरणों को सुनिश्चित करें कि आप किसी भी लिबास के खिलाफ लिंक नहीं करते हैं; अगर कोई _start नहीं है, तो पहला प्रतीक कूद जाता है और _exit को अनुमति दी जाती है, इसलिए यह सुरक्षित है। Gcc का कम से कम एक वर्जन डायरेक्ट syscall में राइट (a) होगा जिसमें कोई फंक्शन कॉल नहीं होगा।
— जोशुआ
आपकी आईडीई के आधार पर आप कुछ इस तरह से कर सकते हैं: printf("%c",~'ɦ');हालांकि "ए" में एक उच्चारण चिह्न होगा हेह
— अल्बर्ट रेनशॉ
@AlbertRenshaw ɦएक 2-बाइट-कैरेक्टर
— कार्ल नैप
6

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

833P

UCHAR_MAX 65 पर उतरने से पहले टेबल छह से तीन बार ओवरफ्लो होता है ।

— brhfl
स्रोत
6

लुआ, 36 बाइट्स

यह भी मुझे कुछ समय लिया मानक लुआ कार्यों के कई नियमों से दूर ले जाया जाता है, क्योंकि (के सभी math, string.char, string.match, pairs, यहां तक कि next)

यह इस तथ्य का लाभ उठाता है कि लूआ में एक वैश्विक है _VERSIONजो आमतौर पर "लुआ" (उदाहरण के लिए Lua 5.1, या अन्य संस्करणों के लिए समान) से शुरू होता है, इसलिए जब तक कि यह एक गैर-मुख्यधारा दुभाषिया पर नहीं चलाया जाता है, तीसरा चरित्र एक 'ए' होगा

print(({_VERSION:find("..(.)")})[3])

{...}[3]समूह के लिए परिणामों की है findजो भी सूचकांक जहां यह मेल नहीं खाते भी शामिल है, और फिर तीसरे आइटम जो मिलान चरित्र है (वापसी a)

— PiGuy
स्रोत
1
print(({type{}:find".(.)"})[3]) 31 बाइट्स
— Egor Skriptunoff
6

हास्केल, 10 बाइट्स

एक समारोह के रूप में (या कोई बयान के रूप में कोई इनपुट की आवश्यकता है)

f=pred 'B'

उसने चाल चली। Ideone पर इसे आज़माएं। एक पूर्ण कार्यक्रम असंभव है क्योंकि इसमें एक को शामिल करने की आवश्यकता होगी main।

— Laikoni
स्रोत
मुझे नहीं लगता कि यह मान्य है। कार्य को "प्रिंट" या "डिस्प्ले" करने की आवश्यकता होती है A। आपके फ़ंक्शंस बस इसे वापस कर देते हैं और लिंक किए गए प्रोग्राम इसे प्रदर्शित करते हैं putCharजिसके माध्यम से उपयोग किया जाता है u।
— निमि
आप सही हैं, हालाँकि नियमों को अपडेट कर दिया गया है और अब किसी फ़ंक्शन से वापस जाना ठीक लग रहा है।
— लैकोनी
नहीं, नियम अभी भी कहते हैं printऔर / या display।
— nimi
2
डेनिस ने स्पष्ट रूप से पूछा कि क्या प्रिंटिंग के बजाय एक फ़ंक्शन से वापस जाना ठीक है और ओपी ने हां के साथ उत्तर दिया, लेकिन बाद में प्रश्न का अद्यतन शब्दांकन अभी भी इसे प्रतिबिंबित नहीं करता है। मुझे लगता है कि हमें अभी और स्पष्टीकरण के लिए इंतजार करना होगा।
— लाकोनी
1
ओपी ने पुष्टि की कि Aमुद्रित / प्रदर्शित किया जाना चाहिए और वापस नहीं किया जाना चाहिए।
— nimi
5

डीसी, 8 7 बाइट्स

-1 बी डेनिस के लिए धन्यवाद

88 23-P

पुश 88, धक्का 23, घटाना, 65 जा रहा है। ढेर के ऊपर प्रिंट (65) एक ASCII स्ट्रिंग के रूप में, अनुगामी अनुगामी newline।

संपादित करें:

ये कुछ और तरीके हैं, जिनके साथ मैं आया था। यह मूल रूप से "केवल [238B-F]और बिना जोड़ का उपयोग करके" संख्या 65 और 97 उत्पन्न करने का खेल बन गया । विडंबना यह है कि मैं सबसे लंबे लोगों को सबसे दिलचस्प लगता हूं।

_Fdd/r-oC 2-n  # involves changing the base
2_2/8d*3*2/-P
Idd2/2/-2*on   # also changes base
2d8r^r_2/-P
8d*2_2/-P
B 3d**2-P
33 3*2-P
— जो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.