ASCII तालिका प्रिंट करें


28

कार्य ASCII तालिका के n अक्षर प्रदर्शित करना है ।

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

यह कार्य काफी सरल है, इसलिए यहां एक उदाहरण के रूप में पायथन 2.7 में एक संभावित कार्यान्वयन है:

(lambda n:map(chr, range(n)))(256)

जैसा कि मैंने कहा कि यह एक आसान काम है। तो यह कोड-गोल्फ है और सबसे छोटा कोड जीतता है!

संपादित करें

जैसा कि आप में से कुछ ने बताया कि यह कोड परिणाम को प्रिंट नहीं करता है। यह सिर्फ एक उदाहरण है क्योंकि मैं अंग्रेजी में समस्या को समझा सकता हूं; ;-)।

EDIT2

किसी भी प्रोग्रामिंग भाषा में उत्तर पोस्ट करने के लिए स्वतंत्र महसूस करें, भले ही यह सबसे छोटा कोड न हो। शायद वहाँ कुछ दिलचस्प कार्यान्वयन कर रहे हैं!

EDIT3

उदाहरण को निर्धारित करता है इसलिए यह परिणाम प्रिंट करता है।


1. क्या यह एक समारोह होना चाहिए? 2. आपके संदर्भ कोड के अनुसार, n पहला ऐसा अक्षर होगा जो मुद्रित नहीं है।
डेनिस

2
वास्तव में संदर्भ कोड कुछ भी नहीं छापता है। यह सिर्फ पात्रों की एक सूची देता है और REPL को परिणाम के साथ जो कुछ भी करना है, करने देता है।
मैनटवर्क

1
किसी को कृपया नीचे की व्याख्या कर सकते हैं? मुझे खेद है अगर मेरी अंग्रेजी अच्छी नहीं है। यदि प्रश्न के भीतर कुछ अस्पष्ट है तो कृपया मुझे बताएं।
oopbase

1
for x in range(input()):print chr(x)यदि आप अपना उदाहरण संपादित करना चाहते हैं, तो वास्तव में वर्णों को प्रिंट करेंगे।
FryAmTheEggman

2
नोटा [i for i in range(n)]काफी समान हैrange(n)
njzk2

जवाबों:


19

CJam, 4 बाइट्स

ric,

पूरा कार्यक्रम जो एसटीडीआईएन ( ऑनलाइन इंटरप्रेटर में इनपुट क्षेत्र ) से पढ़ता है ।

यह बस निष्पादित करता है range(chr(int(input()))), इस तथ्य का लाभ उठाते हुए कि ,रिटर्न का एक वर्ण देता है यदि इसका तर्क एक चरित्र है।

मैं dibs को c,(2 बाइट्स) पर कॉल करता हूं , बस यह मानकर कि इनपुट पहले से ही स्टैक पर है अनुमति दी जा रही है।


क्या आपको कुछ इनपुट निर्दिष्ट करना है? ऑनलाइन धावक सिर्फ कोड को ही आउटपुट करता है।
12-28 बजे मैनटवर्क

12
@manatwork: बस एक सेकंड। जब आप ये पोस्ट करते हैं तो आपको जल्दी करनी होगी ...;)
डेनिस

मैं इससे थोड़ा भ्रमित हूं। 0 (उर्फ 0 सी) का चरित्र इसके बाद कुछ और मुद्रित होने से रोकता है। रिक, (ठीक काम करने लगता है। इसका मतलब है कि कोड काम नहीं करता है।
kaine

1
@kaine: इंटरनेट एक्सप्लोरर C ++ में लिखा गया है, जिसमें अशक्त-शब्द का उपयोग नहीं किया गया है। के अनुसार इस , अशक्त पात्रों HTML 5 में पार्स त्रुटि कर रहे हैं; ब्राउज़र को दस्तावेज़ को संसाधित करने के लिए इसे या गर्भपात से बदलना चाहिए।
डेनिस

4
ध्यान रखें कि आपको पर्याप्त रूप से बड़ा प्रवेश करना है n, क्योंकि ASCII वर्णों के पहले कुछ दर्जन गैर-मुद्रण योग्य वर्ण हैं। मजेदार तथ्य: यह कार्यक्रम यूनिकोड तालिका का भी उदाहरण देता है, उदाहरण के लिए n = 9999
Sanchises

25

ब्रेनफक - 169 146 142 बाइट्स

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

सीमाएं:

  • EOF 0 होना चाहिए
  • 8-बिट रैपिंग सेल की आवश्यकता होती है
  • ^ के कारण, mods इनपुट 256 से

यहाँ कम से कम जवाब नहीं है, लेकिन हे, बुद्धू! यह इस तथ्य को छोड़कर, वास्तव में, एक अच्छी दिमागी चुनौती होगी, जिसमें अंकों की संख्या की गारंटी के बिना मानव पठनीय इनपुट की आवश्यकता होती है। मुझे इनपुट के लिए आवश्यक होना चाहिए कि इसमें 3 अक्षर लंबे हों, लेकिन इसमें क्या मजा है? : डी इस तरह से इनपुट के साथ एक बड़ी समस्या यह है कि ब्रेनफॉक की केवल ब्रांचिंग या लूपिंग संरचना की जांच करता है कि वर्तमान सेल शून्य है या नहीं। जब इनपुट में शून्य हो सकते हैं, तो यह आपके कोड को उन शाखाओं को लेने का कारण बन सकता है जिन्हें यह नहीं लेना चाहिए। इस समस्या को हल करने के लिए, मैं इनपुट 1 के प्रत्येक अंक को संग्रहीत करता हूं , फिर अंतिम संभव दूसरे पर अतिरिक्त को घटाता हूं । इस तरह, मुझे हमेशा पता है कि मेरे शून्य कहां हैं।

मैंने कहा कि इनपुट को पार्स किए बिना यह एक बड़ी दिमागी चुनौती होगी। ऐसा क्यों है? ठीक है, चलो बहाना करते हैं कि हम एक संख्यात्मक इनपुट नहीं लेते हैं। हम कहेंगे कि चुनौती है "इनपुट बाइट को देखते हुए, उस बाइट के नीचे सभी ASCII वर्णों को आउटपुट"। यहाँ मेरा जवाब क्या होगा:


brainfuck - 8 बाइट्स

,[->.+<]

यह काफी अंतर है! वास्तविक कार्यक्रम इनपुट इकट्ठा करने के लिए 135 निर्देशों का उपयोग करता है (कार्यक्रम का 95% से अधिक!), सिर्फ इसलिए कि यह एक मानव टाइपिंग है। संख्या को बाइट के रूप में संग्रहीत करें और मुझे वह दें, और यह केवल एक लेता है।

(मजेदार तथ्य: यदि आप काल्पनिक कार्यक्रम को समझ गए हैं, तो बधाई! आप इसकी संपूर्णता के बारे में समझ सकते हैं। पूरी भाषा में केवल आठ आदेश हैं, और यह कार्यक्रम हर एक को एक बार उपयोग करने के लिए होता है।)

व्याख्या

-[+>+[+<]>+]>+               abuse 8 bit wrapping to put 47 in cell 4

>>,[>,]                      starting in cell 6; get each character of input

<[<]<[->>[->]<[<]<]          subtract the value of cell 4 from each input character
                             '0' has an ascii value of 47 so subtracting 47 from each
                             digit gives you that digit's value plus 1

>>>[                         if the number is in more than one cell
                             (when the program first starts this means "if the input has
                             more than one digit")

[<[-<+<+<+>>>]               copy first input cell to 3 new cells

+++++++++[<[-<+>]<<          do some fancy addition magic to multiply that value by 10
[-<+>>>+<<]<[->+<]>>>>-]]

<,<<,>                       clean up a bit (abusing comma to set cells to 0)

[->>>+<<<]>>>                add the value to the next cell of input

----------                   because we multiplied (the digit plus 1) by 10; the answer
                             is 10 too high; so subtract 10

>]                           if the input is still in multiple cells; do the song and
                             dance again (multiply by 10; add to next cell; subtract 10)

<-                           we never got a chance to fix the final digit; so it's still 1
                             too high

               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
               ;;         we have now finished processing input         ;;
               ;;     the tape is empty except for the current cell     ;;
               ;;  the current cell contains the number that was input  ;;
               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

[                            while the cell containing input != 0

-                            subtract 1 from it

>.+                          go a cell to the right; output that cell; then add 1

<]                           repeat

अच्छा! निश्चित रूप से प्रयास के लिए +1 :-)
oopbase

1
आप आउटपुट भाग पर कुछ बाइट्स बचा सकते हैं: >[-]<[->.+<]सेल को वर्तमान सेल के बगल में 0 पर सेट करें, फिर वर्तमान सेल को उसके बगल में सेल बढ़ाते हुए और साथ ही साथ मान को प्रिंट करते हुए गिनें।
शुजल

@shu यह एक उत्कृष्ट बिंदु है! मैंने ऐसा बिल्कुल नहीं सोचा था। छोटे होने के अलावा, यह उस समस्या को ठीक करता है जो मुझे बड़े इनपुट्स पर चोक करने के साथ हुई थी और यह शायद तेज है! धन्यवाद :)
अंडरग्राउंडोरेल

हाँ, यह बहुत, अब बहुत तेज है। मुझे भी >[-]<भाग की आवश्यकता नहीं थी क्योंकि मैं पहले से ही एक खाली सेल के बगल में था। :)
अंडरग्राउंडोरेल


12

अजगर , 4 बाइट्स

VQCN

मूल रूप से पायथन 3 कार्यक्रम का अनुवाद:

for N in range(eval(input())):print(chr(N))

11

बेफुज 93 - 23 21

&> :#v_,>:#,_@
 ^-1:<

बेफुज 93 - 15 13 (इंगो बुर्क द्वारा)

यह सूची को उल्टा छापता है, लेकिन ओपी ने कहा कि हमें पहले nपात्रों को प्रिंट करने की आवश्यकता है , न कि यह कि इसे क्रम में होना चाहिए।

&>::>v
@^-1,_

Befunge98 ("?" ऑपरेटर के लिए, @ Kasran का जवाब देखें ) पर आगे बढ़े बिना किसी भी स्थान पर गोल्फ नहीं हो सकता है

इसे यहाँ आज़माएँ:


मुझे आशा है कि आपको कोई आपत्ति नहीं है कि मैंने यहाँ से इनलाइन इंटरप्रेटर का उपयोग किया है :)
इंगो बुर्क

प्रश्न में यह नहीं &> #- #1:# :#,_@
लिखा है

मैंने कुल 15. के लिए एक और बाइट का मुंडन कर दिया। नई कहानियों के कारण मैं इसे आपकी पोस्ट में संपादित करूंगा।
इंगो बुर्क

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

लिंक किए गए चैलेंज से दुभाषिया नया है। मुझे लगा कि जब मैं आपका जवाब देखूंगा तो वास्तव में इसका इस्तेमाल करूंगा। :)
इंगु बैर्क

8

जावा, 151 128 77 62 56 बाइट्स

पहले कोड-गोल्फिंग पर प्रयास करें।

void f(int n){for(char i=0;++i<=n;System.out.print(i));}

उपयोग:

import java.util.Scanner;
class A {

    public static void main(String[] a) {
        int num = new Scanner(System.in).nextInt();
        new A().f(num);
    }

    void f(int n) {
        for (char i = 0; ++i <= n; System.out.print(i));
    }
}

गंभीर बाइट में कमी के लिए @ शुजल, @flawr, @Ingo Bürk और @Loovjo को धन्यवाद।


1
आप स्कैनर को खोलने के दौरान इंट की घोषणा करके कुछ int i,n=new Scanner(...लूप बचा सकते हैं: और लूप को बदलकर for(;++i<n;)। इसके अलावा, आपको आह्वान करने की आवश्यकता नहीं है Character.toString। आप सिर्फ़ System.out को एक मूल्य दे सकते हैं और यह ख़ुशी से इसका उत्पादन करेगा।
शुजल

1
चुनौती aइनपुट के रूप में आपके उपयोग की अनुमति देती है । और मुझे लगता है कि आप forवेतन वृद्धि वाली जगह को लूप बॉडी के रूप में गाली देकर लूप को छोटा कर सकते हैं : for(;++i<n;System.out.print((char)i));(लेकिन आपको इनिशियलाइज़ेशन या एंड वैल्यू को + 1 से बदलना पड़ सकता है)
त्रुटी

1
आपको एक फ़ंक्शन लिखने की अनुमति है, इसलिए पूरी कक्षा और सब कुछ की आवश्यकता नहीं है।
इंगो बुर्क

1
क्या आप निश्चित हैं? जाहिर है, के ++i<n+1बराबर होना चाहिए ++i<=n=हालाँकि, वहाँ ध्यान दें ! यह सिर्फ एक बाइट बचाता है। इससे मेरा काम बनता है।
इंगो बुर्क

1
तो हम नीचे आते हैं void f(int n){int i=0;for(;++i<=n;System.out.print((char)i));}जो कि 62 बाइट्स है। कम से कम मैं अब गोल्फ को ज्यादा नहीं देखता। :)
इंगो बुर्क

6

एपीएल, 5

⎕UCS⍳

उदाहरण का उपयोग:

⎕UCS⍳256

1
आप एक dfn बनाने की जरूरत नहीं है। बस JustUCS⎕ ठीक काम करेगा। तो 5 चर
मोरिस ज़ुक्का

1
आपको 127 से अधिक कोड बिंदुओं का समर्थन करने की आवश्यकता नहीं है। बस would workAV ठीक काम करेगा। तो 4
चरस

6

जावास्क्रिप्ट, ईएस 6 - 52 58 56 53 44 42 बाइट्स

n=>String.fromCharCode(...Array(n).keys())

इसे फ़ायरफ़ॉक्स कंसोल में पेस्ट करें। के रूप में चलाएँ f(NUM)

पहले इसे ठीक से स्वीकार नहीं करने के कारण इसे अधिक लंबा करना पड़ा।

नीचे 3, धन्यवाद edc65! नीचे 44 करने के लिए कुंडा धन्यवाद!


1
यह वास्तव में न तो पैरामीटर और न ही इनपुट संभालती है।
मैनटवर्क

बस 70 को एक अलग संख्या में बदलें; वह इनपुट है।
शिमोनस्टर

ठीक है, मैंने इसे 6 बाइट्स की कीमत पर, इनपुट लेने के लिए अपडेट किया।
शिमोनस्टर

3
-2: f = n => [... अर्रे (n)]। नक्शा ((v, i) => String.fromCharCode (i))
edc65

2
४४ वर्ण! f=n=>String.fromCharCode(...Array(n).keys())
कुंडा

6

हास्केल, 17 23 बाइट्स

flip take['\0'..]

यह सुनिश्चित नहीं है कि आयात के बिना कोई भी बेहतर करना संभव है।

संपादित करें

मेरा पहला समाधान वास्तव में परिणाम का प्रिंट नहीं था , इसलिए उसके लिए 6 और वर्णों की अनुमति दें:

print.flip take['\0'..]

इसके अलावा, कम नहीं (मुद्रण के साथ 25 वर्ण, 19 बिना), लेकिन एक दिलचस्प वैकल्पिक दृष्टिकोण (इसके लिए 'Data.List' की आवश्यकता होती है):

print.((inits['\0'..])!!)

यह वास्तव में परिणाम प्रिंट नहीं करता है।
nyuszika7h

@ nyuszika7h अब यह करता है
जॉन ड्वोरक

(`take`['\0'..])एक बाइट बचाता है।
लकोनी


4

सी, 31 30 28 27

k;f(n){putch(k++)<n&&f(n);}

चूँकि गैर-मानक है, यहाँ पूरी तरह से आज्ञाकारी संस्करण है:

k;f(n){putchar(k++)<n&&f(n);}

मुख्य से बुलाया जाना चाहिए:

main(){f(255);}

EDIT: पुश्चर रिटर्न वैल्यू का लाभ उठाकर सुधार किया गया
EDIT 2: पुनरावृत्ति के माध्यम से किसी अन्य वर्ण द्वारा कम किया गया


1
पुट एक गैर-मानक फ़ंक्शन है। इसके अलावा, क्या मैं पूछ सकता हूं कि यह जवाब क्यों नहीं दिया गया?
स्टुअंटडूड

@Stuntddude मैं एक वैकल्पिक संस्करण जोड़ूंगा जो पुटचर का उपयोग करता है, और पता नहीं क्यों इसे डाउनवोट किया गया है। आखिरकार, यह छोटे लोगों में से एक है।
टेकरा

4

पर्ल, 17 बाइट्स

say chr for 0..$_

1
बहुत सारे कोष्ठक। print chr for 0..$ARGV[0]
मैनटवर्क

आप सही हे! कुछ समय हो गया है जब मैंने
डेमनोगोनिस

1
आप 2 बाइट्स को बचाने के shiftबजाय उपयोग कर सकते हैं $ARGV[0]
nyuszika7h

यदि आपको विभिन्न लाइनों पर वर्णों को मुद्रित करने की अनुमति है, तो आप उपयोग कर सकते हैं say। इसके अलावा, यदि आप इसे एक-लाइनर के रूप में करते हैं तो वर्ण गणना कम है -n। पात्रों के echo "90" | perl -nE'say chr for 0..$_'रूप में गिना जाएगा 1817के लिए say chr for 0..$_प्लस 1के लिए n
hmatt1

आप सही हे। लेकिन sayपर्ल के हर संस्करण के साथ काम नहीं करेगा।
डेमनोगोनिस

3

सीजाम, ३

,:c

मैंने तर्क को शीर्ष स्टैक तत्व माना।

उदाहरण का उपयोग:

256,:c

ri,:c


3

जाग - २ -

{while(i<$0)printf"%c",i++}

स्टड पर पैरामीटर देने के लिए इसे ऐसे चलाएं:

awk '{while(i<$0)printf"%c",i++}' <<<96

बस मज़े के लिए: "सकारात्मक संस्करण सोचें" एक निश्चित के साथ शुरू होता है yes:

yes|head -96|awk '{printf"%c",NR-1}'

NR-1मुद्रित करने के लिए की जरूरत है (char)0के लिए NR==1। :-(

और हमारे पास noकमांड क्यों नहीं है ? यह थोड़े मतलब है!


1
alias no='yes no'
nyuszika7h

... लेकिन तब मुझे उस उपनाम की परिभाषा को भी

3

जे - 5 बाइट्स

{.&a.

{.हेड है, a.वर्णमाला है (सभी वर्णों की एक सूची है) और &उन्हें बांड करता है, जैसे एक राक्षसी क्रिया उत्पन्न करता है:

{.&a. 100 NB. first 100 characters

नोट : ऐसा लगता है कि यह अंतःक्रियात्मक रूप से काम नहीं करता है: कुछ नियंत्रण वर्णों के बजाय Jconsole और jQt एक अनुवाद, आउटपुट बॉक्स वर्ण सेट करता है। एक स्क्रिप्ट में या कमांडलाइन से, हालांकि यह काम करता है:

  ijconsole <<< '127 {. a.' | hd

ध्यान दें कि वर्णमाला वास्तव में ASCII नहीं है।
FUZxxl

{.&a. 127यह करने के लिए , यह नहीं है?
jpjacobs

नहीं, क्योंकि J में नियंत्रण पात्रों में से कुछ के बजाय बॉक्स ड्राइंग वर्ण हैं।
फ़ूजएक्सल जूल

दरअसल, इसे एक फाइल पर लिखना और हेक्स व्यूअर के साथ इसका निरीक्षण करना मुझे बताता है कि जे सही मान (0x00 0x01, ...) को आउटपुट करता है। यह केवल जे इंटरप्रेटर / आईडीई है जो नियंत्रण वर्णों के बजाय उन मूल्यों को बॉक्सिंग वर्ण के रूप में व्याख्या करते हैं। यह बिल्कुल वैसा ही करता है जैसा अन्य सभी भाषाएं charया समकक्ष उपयोग करते हैं।
jpjacobs

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

3

gs2, 2 बाइट्स

V.

यह प्रतिस्पर्धा होनी चाहिए, मुझे लगता है! यह gs2 के शुरुआती दिनों में भी काम करता था। इसे यहाँ आज़माएँ।


1
इस संस्करण के साथ सफलतापूर्वक परीक्षण किया गया है , जो एक महीने से चुनौती का अनुमान लगाता है।
डेनिस

3

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

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

एक अनुगामी न्यूलाइन के बिना एक दशमलव स्ट्रिंग की अपेक्षा करता है।

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

[0, max_cell_size]Brainfuck में रेंज में पूर्णांक पढ़ना मुश्किल नहीं है। मैं आपको अपने दम पर एक स्वच्छ विधि का आविष्कार करने के लिए प्रोत्साहित करता हूं। मैं इसे शुरुआती स्तर का अभ्यास मानता हूं। (सेल के संख्यात्मक मान को प्रिंट करने का रिवर्स ऑपरेशन अधिक शामिल है, और इसे मध्यवर्ती स्तर का कार्य माना जा सकता है।)

यहां 58-बाइट संस्करण है जो 2568-बिट कार्यान्वयन पर संभाल सकता है :

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


मैंने ऐसा क्यों नहीं सोचा ??? यह सरल है !!!
19

क्या मैं भविष्य के उत्तरों पर उपयोग करने के लिए इसे उधार ले सकता हूं?
FinW

1
@FinW मैं अनुमान लगा रहा हूँ कि आप इस मेटा पोस्ट के बारे में नहीं जानते हैं ।
मिच श्वार्ट्ज

2

गोल्फस्क्रिप्ट - 5

@Dennis को धन्यवाद

~,''+

1
~,""+छोटा और सही ढंग से STDIN से इनपुट प्रोसेस करता है।
डेनिस

@ डेनिस जो मेरे लिए कोई आउटपुट नहीं देता ...
बीटा

1
क्या आप ऑनलाइन इंटरपीटर का उपयोग कर रहे हैं? एसटीडीआईएन से इनपुट को सही ढंग से अनुकरण करने के लिए, आपको उपयोग करना होगा, उदाहरण के लिए ;"65", चूंकि एसटीडीआईएन से इनपुट हमेशा एक स्ट्रिंग होगा।
डेनिस

1
@ डेनिस ओह धन्यवाद जो अब काम करता है!
बीटा डेके


2

Befunge 98, 22

&:00pv>0gk,@
0::-1<^j`

दुख की बात है कि यह इतना लंबा है।

&:00p        ; gets numerical input, stores a copy at cell (0,0)               ;
     v       ; IP goes down                                                    ;

     <       ; IP goes left, so I execute 1-::0`j^                             ;
 ::-1        ; (1-::) subtract one from our number and duplicate it twice      ;
0       `    ; (0`) compare the number with 0, push 1 if greater else 0        ;
     <^j     ; if the result was 0, go up, otherwise continue going left       ;

      >0gk,  ; get the value at cell (0,0), print that many numbers from stack ;
           @ ; terminate program                                               ;

2

पायथन 3.4 - 36 बाइट्स / 43 बाइट्स

print(*map(chr,range(int(input()))))
print(*map(chr,range(int(input()))),sep='')

255 इनपुट ()

यह कैसे काम करता है:

  1. रेंज की ऊपरी सीमा प्राप्त करें
  2. तालिका की एक श्रेणी बनाएँ।
  3. Chr फ़ंक्शन की श्रेणी को मैप करें (int, रिटर्न ascii)।
  4. मानचित्र को स्पैट तर्क विस्तार (संख्या -> वर्ण -> प्रिंट!) के माध्यम से ग्रहण करें

दूसरा केवल 7 बाइट्स के बदले में प्रत्येक वर्ण को अलग करने वाले स्थान को हटा देता है।


आप इसे एक मेमने में शामिल कर सकते हैं, जैसा कि यह सवाल बताता है, और अजगर 2 में, mapएक सूची देता है, इसलिए आप बस कर सकते हैंf=lambda i:map(chr,range(i))
जस्टिन

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

2

पास्कल 87

program _;var c:char;n:byte;begin n:=0;readln(n);for c:=chr(0)to chr(n)do write(c);end.

पास्कल 73

program _;var c,n:byte;begin readln(n);for c:=0to n do write(chr(c));end.

Http://www.onlinecompiler.net/pascal से बनाता है और ठीक चलता है


1
FreePascal (और अगर मुझे सही से याद है, टर्बो पास्कल भी) को केवल उन पात्रों में से 60 की आवश्यकता है: var c,n:byte;begin read(n);for c:=0to n do write(chr(c))end. pastebin.com/aFLVTuvh
manatwork

संभवतः, मैंने केवल डेल्फी का उपयोग किया है। लेकिन किसी ने इसे शीर्षक से संपादित किया।
मार्क के कोवान

2

x86 एएसएम (लिनक्स) (कई बाइट्स जब तक आप इसे संकलित नहीं करते हैं)

एक फ़ंक्शन के रूप में लिखा गया है, मान लिया गया है कि मानदंड AX में पास किया गया है (मैं पढ़े गए syscall के लिए संख्या भूल जाता हूं) इसके अलावा [SP] या BX को संरक्षित नहीं करता है।

test ax,ax
jz @Done
mov [sp],ax
@Loop:
mov ax,4
mov bx,1
mov cx,sp
mov dx,1
int 0x80
sub [sp],1  ; Can I do this?  Or do I need to load/sub/store separately?
jnz @Loop
@Done:
ret

2
(मैं वहाँ एक F00F शोषण करना चाहिए था, यह किसी को भी इसे चलाने की तरह नहीं होगा)
मार्क के कोवान

7
मैं इसे चलाने वाला था। मैं अब इसे चलाने वाला नहीं हूं।
अपराह्न


2

रूबी, २३

f=->n{puts *?\0..n.chr}

व्याख्या

  • इनपुट को लंबोदर के तर्क के रूप में लिया जाता है। यह एक पूर्णांक की उम्मीद करता है।
  • "विनाशकारी ऑपरेटर" ( *) #to_aryप्रत्येक वर्ण को अपनी लाइन पर प्रिंट करने के लिए रेंज पर आमंत्रित करता है ।

2

जूलिया: 20 अक्षर (REPL)

यह प्रश्न के उदाहरण के करीब है: बस पात्रों को उत्पन्न करता है और REPL को उनके साथ जो कुछ भी करना है उसे करने देता है।

f(n)=map(char,[0:n])

जूलिया: 33 अक्षर

प्रत्येक वर्ण को एक अलग लाइन में प्रिंट करता है।

print(map(char,[0:int(ARGS[1])]))

2

एम (MUMPS) - 21

R n F i=1:1:n W $C(i)

विस्तारित रूप में: READ n FOR i=1:1:n WRITE $CHAR(i)


2

टी-एसक्यूएल: 68 63

प्रिंट लूप के रूप में

DECLARE @i INT=64,@ INT=0A:PRINT CHAR(@)SET @+=1IF @<=@i GOTO A

टी-एसक्यूएल: 95 86

एक प्रश्न के रूप में

DECLARE @ INT=64SELECT TOP(@+1)CHAR(ROW_NUMBER()OVER(ORDER BY 0/0)-1)FROM sys.messages

संपादित करें: मुक्को द्वारा इंगित किए गए परिवर्तन और सुधार। धन्यवाद। फिक्स और गोल्फ @ t-clausen.dk द्वारा सुझाए गए


लूप के लिए, आप WHILE को GOTOलेबल के साथ परिवर्तित करने वाले 5 या इतने अक्षरों को सहेज सकते हैं । क्वेरी के लिए, शायद msdb.sys.objectsपर्याप्त वस्तुओं की गारंटी देने के लिए निर्दिष्ट करें । इसके अलावा, यह CHAR (0) का उत्पादन नहीं करता है। हालांकि, सांत्वना के रूप में आप कर सकते हैं ORDER BY @
मुको

दूसरा उत्तर अमान्य है। आप इसे इस तरह से और गोल्फ 9 के पात्रों को फिर से लिख सकते हैं: DECLARE @ INT = 64SELECT TOP (@ + 1) CHAR (ROW_NUMBER () OVER (ORDER BY 0/0) -1) Sys.messages से
t-clausen.dk

@ t-clausen.dk यकीन नहीं है कि मैं कैसे एक के माध्यम से है। उसके लिए धन्यवाद।
मिकटी

2

ब्रेनफैक - 140 112 बाइट्स

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

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

बदलकर 28 बाइट्स सहेजा [<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]करने के लिए [<<<->->->-]

यह क्या करता है

,>,>,>                                                              Takes three inputs
                                                                    in three separate cells

-[>+<-----]>---[<+>-]<[<<<->->->-]<                                 Takes 48 off of each to
                                                                    convert them to decimal

[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>    Combines them into a
                                                                    three digit number by
                                                                    multiplying the first
                                                                    by 100, the second by
                                                                    10 and then adding all
                                                                    three

[>.+<-]                                                             Repeatedly prints the
                                                                    value of the adjacent
                                                                    cell and then adds one
                                                                    to it until it reaches
                                                                    the input value.

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