कृपया मुझे गिनें!

24

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

उदाहरण

अगर स्निपेट है ABCतो परीक्षण का मामला है

ABC 
1 1 1
ABCABC
2 2 2
ABCABCABCABCABCABCABCABCABC
9 11 9
ABCABCABCABCABCABCABCABCABCABCABCABC
12 14 C
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
18 22 12
code-golf 
— Akangka
स्रोत
4
क्या मैं प्रिंट 1 01 0x1करूँ तो ठीक है ? (उपसर्ग शामिल हैं)
— ब्लू
यदि आपके पास निहित इनपुट / आउटपुट के साथ एक भाषा है, तो आपके पास 1 बाइट समाधान हो सकता है जो कि केवल मूल्य बढ़ाता है ...
— 5

जवाबों:

11

जाप, 12 बाइट्स

[°TTs8 TsG]¸

2 बाइट्स बचाने के लिए @ETHproductions को धन्यवाद !

मेरे as जवाब के समान।

— मामा फन रोल
स्रोत
7
: ओ तुम डेनिस को हरा दो!
— डाउनगेट
समझदार do यह नहीं कर सका, और आप पहले से ही टीस्क्रिप्ट कर चुके थे, और मैं जोल्फ को नहीं जानता था, इसलिए मैंने जाप्ट का उपयोग किया।
— मामा फन रोल
बहुत बढ़िया :) यहाँ 2 बाइट्स बचाए गए हैं:[°TTs8 TsG]¸
— ETHproductions
ओह, यह नहीं देखा। धन्यवाद!
— मामा फन रोल
14

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

printf"\r%d %o %x",++$n,$n,$n;

लाइन की शुरुआत में वापस जाएं, इंक्रीमेंट काउंटर और पुराने आउटपुट को ओवरराइट करते हुए प्रिंट काउंटर।

— nimi
स्रोत
स्पेसिफिकेशन में छेद करने के लिए +1, आउटपुट इरेज़र इस चुनौती को मामूली बनाते हैं।
— आकांक्षा
1
@ChristianIrwan: वास्तव में यह मिट नहीं रहा है, लेकिन ओवरराइटिंग (मैंने अपना विवरण सही कर लिया है)
— nimi
1
कि दोनों चुनौती को बर्बाद कर देते हैं।
— अकांग्खा
12

जावास्क्रिप्ट, 54 53 51 47 बाइट्स

सहेजे गए 4 बाइट @ user81655 के लिए धन्यवाद

var d=-~d;d+` ${d[b='toString'](8)} `+d[b](16);

मैं वास्तव में थोड़े आश्चर्यचकित हूं कि यह काम करता है।

व्याख्या

var d=-~d;  // `var` let's `d` not throw an error if it's not defined 
            // -~ essentially increments the variable
d+                    // decimal
` ${                  // space character
   d[b='toString'](8) // octal
} `                   // space character
+d[b](16)             // Hexadecimal

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

— Downgoat
स्रोत
IIRC आप वर को हटा सकते हैं
— कोनोर ओ ब्रायन
@ C @O'Bʀɪᴇɴ जो एक त्रुटि का कारण बनता है: ReferenceError: Can't find variable: dयहां तक ​​कि ढीली मोड पर D:
— डाउनगेट
d=d?d+1:1काम करता है ?
— कोनोर ओ ब्रायन
@ C @O'Bʀɪᴇɴ नोप, अभी भी एक रेफरेंस एरर फेंकता है, ढीले मोड को देखते हुए अजीब लगता है ...
— डाउनगेट
ओह्ह, क्योंकि हम डी का उपयोग करने की कोशिश कर रहे हैं हालांकि यह अपरिभाषित है
— कॉनर ओ'ब्रायन
7

सी ++, 205 179 बाइट्स

int main(){};static int c=1;
#define v(x) A##x
#define u(x) v(x)
#define z u(__LINE__)
#include <cstdio>
class z{public:z(){++c;};~z(){if(c){printf("%d %o %x",--c,c,c);c=0;}}}z;//

(कोई अनुगामी न्यूलाइन नहीं - जब कॉपी की जाती है, तो कॉपी की पहली पंक्ति और मूल की अंतिम पंक्ति को मेल खाना चाहिए)

मूल रूप से, यह एक स्थिर वैरिएबल का अनुक्रम बनाकर काम करता है, जो निर्माण पर, एक वैश्विक वैरिएबल काउंटर को बढ़ाता है। फिर, विनाश पर, यदि काउंटर 0 नहीं है, तो यह अपने सभी आउटपुट करता है और काउंटर को शून्य पर सेट करता है।

बिना किसी नाम के टकराव के चर के अनुक्रम को परिभाषित करने के लिए, हम इस प्रकार समझाए गए मैक्रो का उपयोग करते हैं:

#define v(x) A##x    //This concatenates the string "A" with the input x.
#define u(x) v(x)    //This slows down the preprocessor so it expands __LINE__ rather than yielding A__LINE__ as v(__LINE__) would do.
#define z u(__LINE__)//Gives a name which is unique to each line.

जो कुछ हद तक स्ट्रिंग प्रोसेसर के quirks पर निर्भर करता है। हम zकई बार वर्गों / चर को परिभाषित करने के लिए उपयोग करते हैं जो अलग-अलग लाइनों पर कॉपी होने पर एक दूसरे के साथ संघर्ष नहीं करेंगे। इसके अलावा, परिभाषाएँ जो केवल एक बार होती हैं उन्हें पहली पंक्ति में रखा जाता है, जिसे कोड की प्रतियों में टिप्पणी की जाती है। #defineऔर #includeबयान परवाह नहीं है कि वे दोहराया है, इसलिए कोई विशेष हैंडलिंग की जरूरत है।

इस कोड में कथन में अपरिभाषित व्यवहार भी शामिल है:

printf("%d %o %x",--c,c,c)

चूंकि कोई अनुक्रम बिंदु नहीं हैं, लेकिन c को संशोधित और एक्सेस किया गया है। एलएलवीएम 6.0 एक चेतावनी देता है, लेकिन इसे वांछित के रूप में संकलित करता है - जो --cपहले मूल्यांकन करता है c। एक, दो बाइट्स की कीमत पर, बयान जोड़ सकता है --c;आउटपुट और परिवर्तन से पहले --cमें printfकरने के लिए cहै, जो चेतावनी से छुटकारा पाने होगा।

मेरे भाई के एक सुझाव के लिए 26 बाइट्स बचाने के std::coutसाथ प्रतिस्थापित printf।

— मिलो ब्रांड
स्रोत
6

सीजाम, 20 19 18 बाइट्स

];U):USU8bSU"%X"e%

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

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

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

]                  e# Wrap the entire stack in an array.
 ;                 e# Discard the array.
  U                e# Push U (initially 0).
   ):U             e# Increment and save in U.
      S            e# Push a space.
       U8b         e# Convert U to base 8 (array of integers).
          S        e# Push a space.
           U"%X"e% e# Convert U to hexadecimal (string).
— डेनिस
स्रोत
4

S, 14 चार्ट / 28 बाइट्स

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭;

Try it here (Firefox only).

पहले जवाब! हालांकि इसे संभालने के बेहतर तरीके शायद हैं।

व्याख्या

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭; // implicit: Ḁ = 0
[⧺Ḁ,             // increment Ḁ by 1
    Ḁß8,         // octal representation of Ḁ
        Ḁⓧ]     // hex representation of Ḁ
            ø⬭; // join above array with spaces
                 // repeat as desired until implicit output
— मामा फन रोल
स्रोत
7
यह भाषा भी क्या है?
— कोल जॉनसन
— मामा फन रोल
3

MATL , 26 बाइट्स

वर्तमान रिलीज़ (6.0.0) का उपयोग करता है । ऑक्टेव पर काम करता है।

0$N1+ttYUb8YAb16YA3$XhZc1$

उदाहरण

एक बार:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$
1 1 1

दो बार:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
2 2 2

16 बार:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
16 20 10

व्याख्या

स्टैक में तत्वों की संख्या यह इंगित करने के लिए उपयोग की जाती है कि हमने कितनी बार स्निपेट चलाया है

0$         % specify zero inputs for next function, in case this is not the first
           % occurence of the snippet.
N          % number of elements in stack
1+         % add one
tt         % duplicate twice. We now have three copies of the number
YU         % convert to string (decimal)
b8YA       % bubble up number and convert to octal string
b16YA      % bubble up number and convert to hex string
3$XhZc     % join top three elements (strings) with a space
1$         % specify one input for next function. If the program ends here, that next
           % function will be implicit display, so it will print the top of the stack.
           % Else the stack will be left with one element more than at the beginning of
           % the current snippet
— लुइस मेंडो
स्रोत
2

OCaml, 198 बाइट्स

;;open Char
;;(if Sys.argv.(0).[0]='~'then Sys.argv.(0).[0]<-'\000'else Sys.argv.(0).[0]<-chr(1+int_of_char Sys.argv.(0).[0]));let n=1+int_of_char Sys.argv.(0).[0]in Printf.printf"\r%d %o %x"n n n

एक अनुगामी न्यूलाइन शामिल है और यह आवश्यक है कि फ़ाइल नाम एक टिल्ड के साथ शुरू होता है (मैंने इस्तेमाल किया ~.ml; आप इसे साथ चला सकते हैं ocaml \~.ml) क्योंकि यह उच्चतम मूल्यवान मानक मुद्रण योग्य ASCII चरित्र है। इस तथ्य का दुरुपयोग करता है कि एक स्ट्रिंग में सभी वर्ण परस्पर हैं और Sys.argv.(0).[0]फ़ाइल नाम में पहला वर्ण है।

यह केवल n = 1 से 126 के लिए काम करना चाहिए, क्योंकि ASCII कोड ~126 है और मैं आउटपुट में एक जोड़ रहा हूं। यदि हम केवल n = 1 से 125 चाहते हैं तो इसे दो बाइट्स छोटे किए जा सकते हैं। 126 बार दोहराया जाने के बाद, यह n = 1 पर वापस आ जाएगा।

यह मेरा पहला गोल्फ है इसलिए किसी भी टिप्पणी या सुधार की बहुत सराहना की जाएगी।

Ungolfed संस्करण:

;; open Char
;; if Sys.argv.(0).[0] = '~' 
   then Sys.argv.(0).[0] <- '\000'
   else Sys.argv.(0).[0] <- chr (1 + int_of_char Sys.argv.(0).[0])
;; let n = 1 + int_of_char Sys.argv.(0).[0] in
   Printf.printf "\r%d %o %x" n n n
— सताना
स्रोत
+ 1, मेरे सवाल में कई छेद मुझे अपने सवाल को कम करने के लिए चुनते हैं। (हालांकि, मैं ऐसा नहीं कर सकता।)
— अकांगका
मुझे बार-बार शक होता है Sys.argv.(0).[0]। मैं OCaml के बारे में ज्यादा नहीं जानता, हालाँकि।
— 5
2

TeaScript , 21 20 बाइट्स

[┼d,dT8),dT16)]j(p);

मुझे इसे स्वतः-बंद करना चाहिए ;

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

व्याख्या

┼ हो जाता है ++

    // Implicit: d = 0
[   // Start array
 ++d,  // Increment d, decimal value
dT8),  // d to base 8
dT16)  // d to base 16
]j(p); // Join by spaces
    // Implicit: Output *last* expression
— Downgoat
स्रोत
Downvote? क्या इस जवाब में कुछ गड़बड़ है? क्या इसे ASCII कैरेक्टर जंबल के साथ करना है क्योंकि यह भी मिनटों के भीतर कम हो गया है अगर कम नहीं है
— डाउनगेट
1

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

$_=<<'';printf"%d %o %x",(1+y/z//)x3;
:

बृहदान्त्र के पीछे एक अंतिम न्यूलाइन है।

पहली पंक्ति के बाद सब कुछ यहाँ एक दस्तावेज़ के रूप में व्यवहार करता है और इसमें मायने रखता zहै। कोड की आगे की प्रति के लिए एक zजोड़ा जाता है। हमें 1गिनती में जोड़ना होगा, क्योंकि पहले स्निपेट (जिसे निष्पादित किया जाता है) के लिए कोई नहीं है।

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

— nimi
स्रोत
1

मैथमेटिका, 76 बाइट्स

ध्यान दें कि nपहले कोई परिभाषा नहीं होनी चाहिए।

0;If[ValueQ@n,++n,n=1];StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

यहाँ, के व्यवहार का ;उपयोग किया जाता है। ऊपर वाला स्निपेट एक एकल है CompoundExpression, हालांकि, जब स्निपेट के एक जोड़े को एक साथ रखा जाता है, तब भी एक होता हैCompoundExpression जैसा कि नीचे दिखाया गया है। (कुछ अनावश्यक पुनर्व्यवस्था की जाती है।)

0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

(* 3 3 3 *)

यदि कोई स्पष्ट लिखता है तो ऐसा कोई स्निपेट काम नहीं कर सकता है CompoundExpression। इसके अलावा, आपकी पसंद की लगभग हर चीज़ को पहले ;जैसे E, Piया MandelbrotSetPlot[], के सामने रखा जा सकता है ।

— njpipeorgan
स्रोत
1

बैश, 49 बाइट्स

फ़ाइल count.bash:

((++n));trap 'printf "%d %o %x\n" $n $n $n' exit;

... कोई अनुगामी न्यूलाइन नहीं।

चलाएँ:

$ bash count.bash
1 1 1
$ cat count.bash count.bash count.bash | bash
3 3 3
$ for i in $(seq 10) ; do cat count.bash ; done | bash
10 12 a
1

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

n=len(open(__file__).read())/54;print n,oct(n),hex(n)#

कोई अनुगामी न्यूलाइन नहीं। रूप में आउटपुट 1 01 0x1।

यदि यह ठीक नहीं है, तो 56 बाइट्स

n=len(open(__file__).read())/56;print"%d %o %x"%(n,n,n)#

जब एक-दूसरे के सामने चिपकाया जाता है, तो हर बार चिपकाई गई फ़ाइल की लंबाई 1 लाइन से लंबी हो जाती है। बेस केस 2 लाइनों से शुरू होता है इसलिए आपको लाइन की लंबाई से 1 घटाना होगा। अभिकलन को टिप्पणी से दबा दिया जाता है।

— नीला
स्रोत
"%d %o %x"%(n,n,n), यह बहुत अच्छा है। मुझे नहीं पता था कि आप ऐसा कर सकते हैं। अगर यह पता चला है कि उपसर्ग को छोड़ना ठीक नहीं है तो मुझे वह उधार लेना होगा।
— rp.beltran
1

पायथन 2.x 140 बाइट्स

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

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

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

कुछ उदाहरण विन्यास और उनके आउटपुट:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

Outputs 1 01 0x1

और पंद्रह कॉपी पेस्ट:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;

...


Outputs 15 017 0xf
— rp.beltran
स्रोत
thread.start_new_threadक्या अजगर ने कोड गोल्फिंग के लिए एक बदतर विधि नाम के बारे में सोचा होगा?
— rp.beltran
मुझे यह देखने में दिलचस्पी होगी कि अगर यह अजगर 3.x में काम करता है, तो मुझे ऐसा कुछ भी दिखाई नहीं देता है जिसके बारे में मुझे पता है कि मैं नहीं करूँगा, लेकिन मैंने अजगर में 3 कभी भी थ्रेडिंग नहीं की है।
— rp.beltran
0

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

1;$.+=1;$><<"#$. %1$o %1$x"%$.*-~-0

प्रत्येक स्निपेट वेतन वृद्धि $.(जो 0 के रूप में शुरू होती है यदि कोई फाइल नहीं पढ़ी गई है), लेकिन केवल अंतिम आउटपुट कुछ भी। *-~-0मूल्यांकन करता है *1, जिसका अर्थ है स्ट्रिंग को एक बार प्रिंट करना, लेकिन संगति के साथ यह हो जाता है *-~-01, एक अष्टांगिक अभिव्यक्ति का मूल्यांकन 0.। चूंकि $><<इसमें अनुगामी न्यूलाइन शामिल नहीं है, खाली स्ट्रिंग को प्रिंट करने का मतलब है कुछ भी नहीं प्रिंट करना।

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