उच्चतम पासा

19

चुनौती:

यहां हमारे पास अनुक्रम के पहले 100 आइटम हैं:

6,5,4,3,2,1,66,65,64,63,62,61,56,55,54,53,52,51,46,45,44,43,42,41,36,35,34,33,32,31,26,25,24,23,22,21,16,15,14,13,12,11,666,665,664,663,662,661,656,655,654,653,652,651,646,645,644,643,642,641,636,635,634,633,632,631,626,625,624,623,622,621,616,615,614,613,612,611,566,565,564,563,562,561,556,555,554,553,552,551,546,545,544,543,542,541,536,535,534,533,...

यह क्रम कैसे बनता है? हमारे पास सबसे पहले रेंज में संख्या है [6, 1](उच्चतम से निम्नतम तक एक एकल मरने के सभी संभावित मूल्य)। फिर हमारे पास संख्याएँ हैं [66..61, 56..51, 46..41, 36..31, 26..21, 16..11](दो पासा के सभी संभव समतुल्य मूल्य उच्चतम से निम्नतम तक)। आदि
यह OEIS अनुक्रम A057436 से संबंधित है : इसमें केवल 6 के माध्यम से अंक 1 शामिल है , लेकिन सभी अंकों की समान संख्या के साथ अनुक्रम में पीछे की ओर छांटे गए हैं।

चुनौती ऊपर दिए गए अनुक्रम के साथ आपके फ़ंक्शन / प्रोग्राम के लिए इन तीन विकल्पों में से एक को चुनना है:

  1. एक इनपुट लें और इस क्रम के 'वें मान को आउटपुट करें , जहाँ यह 0-इंडेक्स या 1-इंडेक्स किया जा सकता है।nn
  2. एक इनपुट लें और इस क्रम के पहले या मान को आउटपुट करें ।nnn+1
  3. अनुक्रम से मूल्यों को अनिश्चित काल तक आउटपुट करें।

बेशक, किसी भी उचित आउटपुट प्रारूप का उपयोग किया जा सकता है। तार / पूर्णांक / दशमलव / आदि के रूप में हो सकता है; एक (अनंत) सूची / सरणी / धारा / आदि के रूप में हो सकता है; अंतरिक्ष / अल्पविराम / newline / अन्य सीमांकक के साथ उत्पादन किया जा सकता है; आदि आदि कृपया बताएं कि I / O और विकल्प का उपयोग आप अपने उत्तर में कर रहे हैं!

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

यदि आप विकल्प 1 चुनते हैं तो यहां कुछ बड़े परीक्षण मामले हैं:

n         0-indexed output    1-indexed output

500       5624                5625
750       4526                4531
1000      3432                3433
9329      11111               11112
9330      666666              11111
9331      666665              666666
10000     663632              663633
100000    6131232             6131233
code-golf  number  sequence  integer 
— केविन क्रूज़सेन
स्रोत
1
सुझाए गए संपादन के अनुसार, कोल्मोगोरोव जटिलता टैग अनुक्रमों पर लागू नहीं होता है, केवल एक निरंतर, परिमित, निश्चित आउटपुट के लिए। एक क्रम हमेशा चलता रहता है।
— mbomb007
@ Mbomb007 ने जो कहा, इसके अलावा, मैं इनपुट के आधार पर n'th मान या पहले n / n + 1 मानों को आउटपुट करने की भी अनुमति देता हूं, जबकि KC चुनौतियों में इनपुट कभी नहीं होंगे।
— केविन क्रूज़सेन

जवाबों:

12

पर्ल 6 , 24 23 बाइट्स

-1 बाइट धन्यवाद nwellnhof के लिए

{.put;.[]X~(6...1)}...*

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

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

पर्ल 6 , 27 बाइट्स

{flat {@=.[]X~(6...1)}...*}

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

स्पष्टीकरण:

{                         }    # Anonymous code block
 flat                          # Return the flattened
                      ...*       # Infinite sequence
      {              }             # Defined as
         .[]                       # The previous element arrayified
            X~                     # Each concatenated with
              (6...1)              # All of 6 to 1
       @=                          # Arrayified
— मजाक कर रहा है
स्रोत
6

आर , 43 बाइट्स

p='';repeat cat(p<-sapply(p,paste0,6:1),'')

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

अनुक्रम को अनिश्चित काल तक प्रिंट करता है

  • -9 धन्यवाद @Kirill एल।
— digEmAll
स्रोत
1
@ tk3: दूसरे पैरामीटर के बिना यह n-अंकीय तत्वों के उप-अनुक्रम के अंतिम मान को घटाएगा, n + 1 अंक तत्वों के उप-अनुक्रम के पहले मूल्य के साथ। जैसे6 5 4 3 2 166 65 64...
— डाइजेक्सिल
6

बैश, 31 बाइट्स

f()(x+={6..1};eval echo $x;f);f

TIO

टिप्पणियों से अपडेट करें, n'th मान 1-अनुक्रमित, + GNU उपकरण + पर्ल, 64 बाइट्स, 7 बाइट्स @manatwork के लिए धन्यवाद सहेजे गए

dc<<<6o$1p|perl -pe 's/(.)0/($1-1).6/e?redo:s/0//'|tr 1-6 654321

64 बाइट्स

— नहुएल फौलीउल
स्रोत
ज्यादा मदद नहीं करता है, लेकिन 2 वें समाधान में अर्धविराम से बचने के लिए पूरी अभिव्यक्ति को दोहराते हुए भागना कम है bc<<<obase=6\;$1:। लेकिन अगर आप स्विच करते हैं dc, तो बचने के लिए कुछ भी नहीं है dc<<<6o$1p:।
— manatwork
धन्यवाद वास्तव में यह 7bytes बचाता है, लेकिन विशेषण संख्या के कारण यह अभी भी मिक्स बैश पर्ल (66bytes) काम नहीं कर रहा हैdc<<<6o$1p|perl -pe '1while s/(.)0/($1-1).6/e;s/0//'|tr 1-6 654321
— नहुएल फौलीउल
5

MATL , 11 बाइट्स

`6:P!V@Z^DT

मूल्यों को अनिश्चित काल तक आउटपुट करता है।

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

व्याख्या

`      % Do...while
  6:   %   Push [1 2 3 4 5 6]
  P    %   Flip: gives [6 5 4 3 2 1]
  !    %   Transpose: turns the row vector into a column vector
  V    %   Convert the number in each row to the corresponding char
  @    %   Push current iteration index, starting from 1
  Z^   %   Cartesian power. Gives a matrix where each row is a Cartesian tuple
  D    %   Display immediately
  T    %   Push true. This is used as loop condition, to give an infinite loop
       % End (implicit)
— लुइस मेंडो
स्रोत
5

हास्केल, 38 34 बाइट्स

संख्याओं की एक अनंत सूची:

d=[6,5..1]
l=d++[10*m+n|m<-l,n<-d]

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

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

[1..]>>=sequence.(`replicate`"654321")

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

do n<-[1..];mapM id$[1..n]>>["654321"]

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

— क्रिश्चियन सिवर्स
स्रोत
एक 36; बाइट संस्करण , आपके replicateएक के आधार पर ।
— dfeuer
5

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

l=(+).(10*)<$>0:l<*>[6,5..1]

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

संख्याओं की एक अनंत सूची तैयार करता है l। बाइट का उपयोग <$>और <*>कटौती:

29 बाइट्स

l=[10*n+d|n<-0:l,d<-[6,5..1]]

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

दृष्टिकोण हास्केल आउटपुट सभी स्ट्रिंग उत्तर फिक्स्ड इनपुट स्ट्रिंग "654321" के समान है, और जहां यह पूर्वनिर्मित है उसे बदलकर खाली स्ट्रिंग आउटपुट को छोड़ देना है।

30 बाइट्स

l=[n++[d]|n<-"":l,d<-"654321"]

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

— XNOR
स्रोत
एक दम बढ़िया! मैंने देखा कि इसे 0(या "") से शुरू करने के लिए कम है , लेकिन परिणाम में इसे नहीं करने का एक सस्ता तरीका नहीं मिला ...
— क्रिश्चियन सेवर्स
4

05AB1E , 10 बाइट्स

अनुक्रम को अनिश्चित काल तक आउटपुट करता है।

¸[6LRâJD»,

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

व्याख्या

¸           # initialize the stack with a list containing the empty string
 [          # loop
  6L        # push [1 ... 6]
    R       # reverse
     â      # cartesian product
      J     # join each inner list
       D    # duplicate (saving a copy for next iteration)
        »,  # join on newline and print
— Emigna
स्रोत
1
¸शुरू में कभी नहीं पता था कि एक खाली स्ट्रिंग वाली एक सूची बनाता है। और 2 बाइट्स उस समाधान की तुलना में कम थे जो मैंने परीक्षण मामलों को उत्पन्न करने के लिए इस्तेमाल किया था, इसलिए निश्चित रूप से मेरे से +1। :)
— केविन क्रूज़सेन
3

जावा (JDK) , 48 बाइट्स

String f(int n){return n-->0?f(n/6)+(6-n%6):"";}

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

यह 1-अनुक्रमित n वें तत्व को लौटाता है ।

पुनरावृत्ति पुनरावृत्ति मेमने को हराती हुई प्रतीत होती है।

Iterative संस्करण, 49 बाइट्स

n->{var r="";for(;n-->0;n/=6)r=6-n%6+r;return r;}

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

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

ब्रेकीलॉग , 13 11 बाइट्स

2 बाइट्स के लिए घातक परिणाम

6~d{⟧₁∋}ᵐẉ⊥

अनिश्चित काल के लिए आउटपुट। इसे ऑनलाइन आज़माएं!

n

व्याख्या

6~d           Start with a number, all of whose digits are 6's
              Brachylog considers these in the order 6, 66, 666, 6666...
   {   }ᵐ     Map this predicate to each of those digits:
    ⟧₁         1-based reverse range: [6,5,4,3,2,1]
      ∋        The output digit must be a number in that range
              Brachylog considers possible outputs in this order: 6, 5, 4, 3, 2, 1, 66, 65...
         ẉ    Write a possible output with newline
          ⊥   Force the predicate to fail and backtrack to the next possibility
— DLosc
स्रोत
आप ब्रेकीलॉग रोल पर हैं!
— घातक
1
विफलता-चालित लूप का उपयोग करके आप 2 बाइट्स बचा सकते हैं, क्योंकि उन्हें प्रोलॉग में कहा जाता है 6~d{⟧₁∋}ᵐẉ⊥:। आप मूल रूप से "झूठा" के साथ अपने कार्यक्रम को समाप्त करते हैं जो इसे सभी समाधानों को प्रिंट करने के लिए मजबूर करेगा।
— घातक
अरे वाह। हाँ, मुझे बहुत मजा आ रहा है!
— DLosc
3

सी # (.NET कोर) , 38 बाइट्स

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;

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

एन-वें मान (1-आधारित) आउटपुट करता है।

— दाना
स्रोत
यह कौन सा हल है?
— स्टैकस्टक
@Stackstuck - मैंने अब इसे अपने उत्तर में निर्दिष्ट कर दिया है।
— दना
1
ओह अच्छा! हम ओवरलैपिंग नहीं कर रहे हैं। मैंने सिर्फ अनंत प्रिंटर लिखा है।
— स्टैकस्टक
2

जाप, 14 बाइट्स

वहाँ समारोह विधियों और / या कार्टेशियन उत्पाद का उपयोग कर एक छोटा सा समाधान होना चाहिए, लेकिन (अब के लिए?) सबसे अच्छा मैं प्रबंधन कर सकता हूँ Arnauld के जेएस समाधान का एक बंदरगाह है इसलिए उसे भी उखाड़ना सुनिश्चित करें।

©ß´Uz6)s+6-Uu6

इसे आज़माएँ या शर्तों को परखें0-1000

— झबरा
स्रोत
2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 88 78 बाइट्स

(l=d=c=7-Range@6;While[Length@c<#,d=Flatten[(10#+l)&/@d];c=c~Join~d;];c[[#]])&

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

@IanMiller की बदौलत 4 + 6 बाइट्स बचाए

सूची 1 अनुक्रमित है, n'th संख्या को आउटपुट करता है।

— काई
स्रोत
1
आप 4 वर्णों को बचाने के लिए रेंज [6,1, -1] को 7-रेंज @ 6 से बदल सकते हैं
— इयान मिलर
1
कोडगुल्फ नियमों के लिए आप इसे एक अनाम फ़ंक्शन के रूप में भी लिख सकते हैं: (l = d = c = 7-Range @ 6; जबकि [लंबाई @ c <#, d = Flatten [(10 # + l) & / @ d]; c = c ~ ज्वाइन ~ d?]; c [[#]] &
— इयान मिलर
@IanMiller धन्यवाद! मुझे यकीन नहीं था कि प्रारूप के बारे में नियम क्या थे।
— काई
2

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

Flatten[FromDigits/@Tuples[7-Range@6,#]&/@Range@#][[#]]&

वास्तव में चलाने के लिए अत्यधिक मात्रा में मेमोरी की आवश्यकता होती है क्योंकि यह अनुक्रम में सभी संख्याएं बनाता है जिनकी लंबाई इनपुट के बराबर या उससे कम होती है (अर्थात यह बनाता है)65(6n−1)

— इयान मिलर
स्रोत
+1, यह राक्षसी ओवरकिल है, लेकिन संक्षिप्तता के लिए पूरी तरह से काम करता है!
— काई
@JonathanFrech मेरे मैथजैक्स को ठीक करने के लिए धन्यवाद। मुझे यकीन नहीं था कि इसे यहां कैसे अलग किया जा सकता है क्योंकि यह गणित से अलग है। ईएस
— इयान मिलर
कृपया ध्यान दें कि मूल संपादन इस उपयोगकर्ता द्वारा किया गया था ।
— जोनाथन फ्रीच
उफ़ मेरी बुर @ भूजा- kerecsenyi को भी धन्यवाद।
— इयान मिलर
1

पिप -l , 16 बाइट्स

x:YP6-,6W1PxCP:y

अनुक्रम को अनिश्चित काल तक आउटपुट करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

-lध्वज का मतलब है कि सूचियों अपनी पंक्ति में प्रत्येक आइटम के साथ मुद्रित कर रहे हैं; यदि कोई वस्तु अपने आप में एक सूची है, तो उसके तत्वों को अलग नहीं किया जाता है। उदाहरण के लिए सूची [1 [2 3] [4 [5 6]]]को मुद्रित किया जाएगा

1
23
456

इसके साथ ही यह साफ हो गया:

x:YP6-,6W1PxCP:y
      ,6          Range(6): [0 1 2 3 4 5]
    6-            Subtract each element from 6: [6 5 4 3 2 1]
  YP              Yank that value into the y variable, and also print it
x:                Assign that value also to x
        W1        While 1 (infinite loop):
           xCP:    Assign to x the cartesian product of x with
               y   the list [6 5 4 3 2 1]
          P        Print it

पहले लूप पुनरावृत्ति के बाद, xजैसा दिखता है [[6;6];[6;5];[6;4];...;[1;1]]; दूसरी पुनरावृत्ति के बाद [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; और इसी तरह। हमें उपलेटा को समतल करने के बारे में चिंता करने की आवश्यकता नहीं है, क्योंकि -lयह प्रभावी रूप से हमारे लिए है।

— DLosc
स्रोत
1

चारकोल , 18 बाइट्स

ＮθＷθ«←Ｉ⊕﹪±θ⁶≔÷⊖θ⁶θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 1 अनुक्रमित। स्पष्टीकरण:

Ｎθ

इनपुट n

Ｗθ«

nशून्य होने तक दोहराएं ।

←Ｉ⊕﹪±θ⁶

-nमोडुलो को कम करें 6, फिर परिणाम और आउटपुट को दाएं से बाएं तरफ बढ़ाएं ।

≔÷⊖θ⁶θ

कमी nऔर पूर्णांक इसे विभाजित करते हैं 6।

— नील
स्रोत
1

रेटिना 0.8.2 , 36 बाइट्स

.+
$*_
+`(_*)\1{5}(_+)
$1$.2
T`7-1`d

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। 1 अनुक्रमित। स्पष्टीकरण:

.+
$*_

यूनीरी में बदलें। (रेटिना 1 यहाँ 2 बाइट्स बचाएगा।)

+`(_*)\1{5}(_+)
$1$.2

बार-बार divmod द्वारा विशेषण आधार 6 में परिवर्तित करें। ध्यान दें कि +निकाले गए अंकों का उपयोग हमेशा आधार 6 के रूपांतरण के लिए 0 से 5 के बजाय 1 से 6 तक की संख्या है। ( (_{6})*तेज है, लेकिन भागफल निकालने की लागत बाइट्स है।)

T`7-1`d

अंकों को स्थानांतरित करें ताकि 6s पहले आएं और 1s अंतिम हो। (कोई 7 या 0 s नहीं हैं, लेकिन यह मुझे dशॉर्टकट का उपयोग करने की अनुमति देता है ।

— नील
स्रोत
1

क्यूबिक्स , 22 बाइट्स

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

..w.06+ONo*w;|uW!(pq;;

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

    . .
    w .
0 6 + O N o * w
; | u W ! ( p q
    ; ;
    . .

यह देखो भागो

— MickyT
स्रोत
1

C # (.NET Core) , अनंत मुद्रण, 181 180 88 बाइट्स।

string[] s=new string[]{" "},t;int i,j,k,l=1;while(true){j=l;t=new string[l=6*j];for(i=6;i>0;i--)for(k=(6-i)*j;k<l;)t[k]=i+s[k++%j];
for(k=0;k<l;)System.Console.Write(t[k++]);s=t;}

अफसोस की बात है कि यह लिखित रूप में अनंत संस्करण में ठीक से आउटपुट करने के बजाय repl.it करता है (मेरा मानना ​​है कि इसे repl.it में एक त्रुटि माना जाता है, क्योंकि यह आउटपुट नहीं करता है जैसे कि प्रोग्राम को लूप चाहिए), इसलिए किसी को भी परीक्षण की उम्मीद है संगणक। यदि आप लूप के सामने एक रीड जोड़ते हैं तो यह रिप्लाई में भी काम करता है।

कंसोल को आउटपुट, जाहिर है।

किसी भी परिमित प्रणाली पर कोड अंततः मेमोरी त्रुटि के साथ दुर्घटनाग्रस्त हो जाएगा।

@Dana के लंबो का उपयोग करने के लिए कोड का उपयोग किया।

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;++i>0;)System.Console.Write(f(i)+" ");

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

— Stackstuck
स्रोत
मुझे कोई अंदाजा नहीं है कि मैंने इसे अच्छी तरह से गोल्फ किया है या नहीं।
— स्टैकस्टक
अनावश्यक k ++ को हटाकर एक बाइट को बचाया।
— स्टैकस्टक
(यह भी, मैं गोल्फ की सहायता का बहुत स्वागत करता हूं, मैं इसके लिए बहुत नया हूं।)
— स्टैकस्टक
2
आपका स्वागत है :) यदि आप C # में गोल्फिंग में रुचि रखते हैं, तो आप कुछ युक्तियों के लिए इस पोस्ट को देखना चाहते हैं: codegolf.stackexchange.com/q/173/8340
— dana
1

फोर्थ (gforth) , 63 बाइट्स

: f recursive dup 6 < if 6 - abs 1 .r else 6 /mod 1- f f then ;

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

0-अनुक्रमित आउटपुट nth मान

व्याख्या

यदि N 6 से कम है, तो N - 6 का निरपेक्ष मान आउटपुट करें। अन्यथा, भाग 6 से एन को विभाजित करने का भागफल और शेष प्राप्त करें। भाग को फ़ंक्शन को पुनरावर्ती पर कॉल करें, फिर शेष पर कॉल करें।

कोड स्पष्टीकरण

: f                 \ start a new word definition
  recursive         \ declare that this word is recursive so we can call it from itself
  dup 6 <           \ check if n is less than 6
  if                \ if it is:
    6 - abs 1 .r    \ subtract 6, get the absolute value, then print with no appended space
  else              \ else if it's greater than 6:
    6 /mod          \ get the quotient and remainder of dividing n by 6
    1-              \ subtract 1 from the quotient (because we're 0-indexed)
    f               \ call f on the result
    f               \ call f on the remainder (shortcut to format and print, it's always < 6)
  then              \ end the if/else
;                   \ end the word definition
— reffu
स्रोत
1

एपीएल (एनएआरएस), 27 चार्ट, 54 बाइट्स

{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}

APL में dana /codegolf//a/179980 द्वारा समाधान का परीक्षण करें:

  f←{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}
  f 500
5625
  f¨750 1000 9329 9331 10000 100000
4531 3433 11112 666666 663633 6131233 
  f¨⍳9
6 5 4 3 2 1 66 65 64
— RosLuP
स्रोत
0

सी #, शुरू से एन तक प्रिंट करें, ??? बाइट्स

लाम्बा अभिव्यक्ति के लिए @dana को श्रेय।

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;i<int.Parse(a[0]);)System.Console.Write(f(++i)+" ");

ऑपरेशन: पूर्णांक के बराबर कमांड लाइन 0 वें तर्क के साथ चलाएं जिसे आप गिनना चाहते हैं। (यह ध्यान दिया जाना चाहिए कि a[0]अन्यथा असंबद्ध कमांड लाइन आर्ग्स सरणी का एक संदर्भ है, और मुझे नहीं पता कि इसे कैसे गिनना है।)

— Stackstuck
स्रोत
चूंकि कोड का हिस्सा एक पूर्ण कार्यक्रम या फ़ंक्शन के बजाय एक स्निपर है, मुझे लगता है कि आप विज़ुअल सी # इंटरएक्टिव कंपाइलर का उपयोग कर रहे हैं? क्या आप शायद परीक्षण कोड के साथ इसे आज़माएं ऑनलाइन लिंक जोड़ सकते हैं ? पुनश्च: आपकी वर्तमान बाइट-गिनती 102 है
— केविन क्रूज़सेन
आह बकवास यह काम नहीं कर रहा है बिल्ली में ।
— स्टैकस्टक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.