42

एक शैतानी संख्या एक धनात्मक पूर्णांक है जिसका दशमलव निरूपण केवल 6 से होता है। आसुरी संख्या की सूची 6, 66, 666, 6666 से शुरू होती है।

एक सकारात्मक पूर्णांक को देखते हुए, निकटतम आसुरी संख्या का उत्पादन होता है। यदि दो हैं, तो बड़ा एक आउटपुट।

परीक्षण के मामलों:

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

code-golf number arithmetic

— लीक नन
स्रोत

1

हमें अधिकतम कितनी संख्या का समर्थन करना है?

— मिस्टर एक्सकोडर

1

@ Mr.Xcoder आप समर्थन कर सकते हैं के रूप में बड़े।

— लीक नून

3

@ LeakyNun, जबकि मैं एक नियमित नहीं हूं अगर PPCG, मैं कहूंगा कि नियम वास्तव में बहुत अच्छा नहीं है, क्योंकि मैं सिर्फ यह कह सकता हूं कि "मैं केवल 34 तक संख्याओं का समर्थन कर सकता हूं क्योंकि मैं सबसे छोटा कोड चाहता था"

— फेरीबाग

5

@ फेरीबग जितना बड़ा आप समर्थन कर सकते हैं , उतना ही मूल रूप से उतना बड़ा है जितना भाषा आपको सीमित करती है।

— लीक नून

3

जाहिरा तौर पर निकटतम दानव Jörg W Mittag है ।

— user2357112

51

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

lambda n:'6'*len(`-~n*3/11`)

— orlp
स्रोत

3

यह एक साफ समाधान है।

— लीक नून

वाह यह प्रभावशाली है। मेरा तुच्छ विधि चीर का उपयोग कर 105 बाइट्स था। अच्छा!

— हाइपरएन्यूट्रीनो

4

बहुत ही शांत। आप इस एल्गोरिथम के साथ कैसे आए?

— डेविड जेड

वह तो कमाल है। जेएस में समकक्ष थोड़ा लंबा है:x=>'6'.repeat((''+-~(x*3/11)).length)

— स्टीव बेनेट

8

@ दाविदज हिंट: 666 और 6666 का औसत 3666 है 3.6666... = 11/3।

— orlp

14

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

f=(x,s='6')=>x<3+s?s:f(x,s+6)

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

f=(x,s='6')=>x<3+s?s:f(x,s+6)

;[1,2,3,6,35,36,37,100,365,366,666,999,1000].forEach(x=>console.log(x,f(x)))

Expand snippet

"यही कारण है कि, मैं कमजोरियों में खुश हूं [...] जब मैं कमजोर होता हूं, तब मैं मजबूत होता हूं।"

— eush77
स्रोत

वाह, एक बार जावास्क्रिप्ट के प्रकार के रूपांतरण के लिए वास्तव में आपको क्या चाहिए :) यह कमाल है।

— स्टीव बेनेट

"यही कारण है कि, मैं कमजोरियों में प्रसन्न हूं [...] जब मैं कमजोर होता हूं, तब मैं मजबूत होता हूं।" ~~ 2 कुरिन्थियों 12:10

— जॉन ड्वोरक

@ जोंडवोरक "इसलिए मैं दुर्बलताओं में आनंद लेता हूं [...] जब मैं कमजोर होता हूं, तब मैं मजबूत होता हूं।" बेहतर लगता है।

— मूंछें

8

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

;I≜+{6}ᵐ

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

व्याख्या

;I          The list [Input, I]
  ≜         Assign a value to I: 0, then 1, then -1, then 2, etc.
   +        Sum Input with I
    {6}ᵐ    All its digits must be 6

— Fatalize
स्रोत

5

जावा 7, 96 93 66 बाइट्स

String c(int n){String r="";for(n*=11/3;n>1;r+=6,n/=10);return r;}

पोर्ट ऑफ @orlp अद्भुत पायथन 2 उत्तर ।

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

मुझे लगता है कि मेरी 66 -गिनती एक दानव के रूप में अच्छी तरह से है। ;)
(सबसे छोटा जावा उत्तर btw नहीं, इसके बजाय @JollyJoker का उत्तर देखें ।

— केविन क्रूज़सेन
स्रोत

पूर्णांक अंकगणितीय का उपयोग कम होना चाहिए।

— लीक नून

1

चलो, गोल्फ बस एक और बाइट कृपया! : पी

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

1

आपकी कोई भी जांच सही नहीं है।

— लीक

1

@ OlivierGrégoire की जरूरत है r = "" वैसे भी बगफिक्स के रूप में, ताकि आप अपनी इच्छा

— पाएं

@LeakyNun उप्स .. गलत कोड को कॉपी किया .. "6"होना चाहिए था ""।

— केविन क्रूज़सेन

4

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

Ẇa6ḌạÐṂ⁸Ṫ

एक मोनडिक लिंक।

इसे ऑनलाइन आज़माएं! - इस लिंक का लगभग कोई मतलब नहीं है (नीचे देखें)!

कैसे?

सच्चे गोल्फ खिलाड़ी की शैली में यह वास्तव में अक्षम है - यह 365 टेस्ट केस के लिए 60 के समय में TIO पर हिट करता है ! स्थानीय रूप से यह 37 में समाप्त होता है।

Ẇa6ḌạÐṂ⁸Ṫ - Main link: n
Ẇ         - all sublists - this has an implicit make_range on it's input
          -   so, for example, an input of 3 yields [[1],[2],[3],[1,2],[2,3],[1,2,3]]
          -   the important things are: that it contains both a list of the length of the
          -   decimal number, and a list 1 shorter; and that it's lists only contain
          -   non-zero numbers and are monotonically increasing in length.
  6       - literal 6
 a        - and (vectorises), this changes all the values to 6s
          -    so, the example above becomes [[6],[6],[6],[6,6],[6,6],[6,6,6]]
   Ḍ      - convert to decimal (vectorises)  [ 6,  6,, 6,  66,   66,   666   ]
       ⁸  - link's right argument, n
     ÐṂ   - filter keep those with minimal:
    ạ     -   absolute difference (for 366 this keeps 66 AND 666; same goes for 3666; etc.)
        Ṫ - tail - get the rightmost result (for 366 keeps 666, since it's longer)

भीतर 60 के दशकों के लिए सीमित कर एक पैच एक ही एल्गोरिथ्म रन बनाने के लिए 365 और 366 TIO पर की अंतर्निहित vectorisation से बचने के लिए है Ḍके साथ Ẇa6Ḍ€ạÐṂ⁸Ṫ( कि कोशिश ), लेकिन इस जाएगा अब के इनपुट के लिए SEG गलती 999 ( त्रिभुज (999) ही है 499,500 लेकिन प्रत्येक पूर्णांकों की एक सूची है, कुल टेट्राहेड्रल (999) = 166,666,500 पूर्णांक, स्मृति कुशल नहीं, कम से कम पायथन में) बना रही है।

— जोनाथन एलन
स्रोत

3

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

RD6ṁḌạÐṂ¹Ṫ

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

— डेनिस
स्रोत

एक बंदरगाह छोटा नहीं होगा?

— लीक नून

मैंने कोशिश की और 10 भी मिला।

— डेनिस

ओह, क्या समस्या यह है कि एक जगह को 11 और 6 के बीच डाला जाना चाहिए?

— लीक नून

सुनिश्चित नहीं हैं कि आप एक दूसरे के बगल में 11 और 6 कैसे डालेंगे ; शायद मुझे कुछ याद आ रहा है। मुझे ‘×3:11Ṿ”6ṁस्ट्रिंग आउटपुट के लिए मिला , ‘×3:11D6ṁḌपूर्णांक के लिए।

— डेनिस

3

सी, 118 बाइट्स

ऑनलाइन प्रयास करें

a;b;d(n,m){return(m*6)+(n>0?d(n-1,m*10):0);}
f(n){a=d((int)log10(n)-1,1);b=d((int)log10(n),1);return(n-a<(b-a)/2)?a:b;}

— Khaled.K
स्रोत

97 बाइट्स

— छत

3

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

f=(n,i=0,j=6)=>n*2<j?i||6:f(n-j,i+j,j*10)

परीक्षण के मामलों

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

f=(n,i=0,j=6)=>n*2<j?i||6:f(n-j,i+j,j*10)

console.log(f(1))   // 6
console.log(f(2))   // 6
console.log(f(3))   // 6
console.log(f(6))   // 6
console.log(f(35))  // 6
console.log(f(36))  // 66
console.log(f(37))  // 66
console.log(f(100)) // 66
console.log(f(365)) // 66
console.log(f(366)) // 666
console.log(f(666)) // 666
console.log(f(999)) // 666

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

— Arnauld
स्रोत

3

गणितज्ञ, 36 बाइट्स

शुद्ध कार्य:

Max[NestList[6+10#&,6,#]~Nearest~#]&

स्पष्टीकरण:

    NestList[6+10#&,6,#]

Iterative उस इनपुट के बराबर लंबाई की एक सूची बनाता है , जिसके मूल्य से शुरू होने NestListवाले पैटर्न का उपयोग करके ।6+10x(previous_value)6

                        ~Nearest~#

फिर इनपुट के निकटतम इस सूची में मान ढूंढें।

Max[                              ]

अंत में निकटतम मानों की सूची से अधिकतम मूल्य लें।

जब तक सूची की लंबाई सुपर अकुशल हो जाती है क्योंकि गणितज्ञ मनमाने ढंग से सटीक लंबाई संख्या के साथ काम कर सकता है यह कार्यक्रम केवल भौतिक स्मृति द्वारा सीमित है।

— इयान मिलर
स्रोत

3

हानिकारक माना जाने वाला टेंपलेट , 118 बाइट्स

Fun<Ap<Fun<If<lt<A<1>,Add<A<2>,A<3>>>,A<3>,Ap<A<0>,A<1>,Mul<A<2>,I<10>>,Add<Mul<A<3>,I<10>>,I<6>>>>>,A<1>,I<30>,I<6>>>

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

Ungolfed:

Fun<Ap<Fun<If<lt<A<1>, Add<A<2>, A<3>>>,
           A<3>,
           Ap<A<0>, A<1>, Mul<A<2>, I<10>>, Add<Mul<A<3>, I<10>>, I<6>>>>>,
       A<1>, I<30>, I<6>>>

— eush77
स्रोत

3

05AB1E , 10 9 बाइट्स

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

6×ŒΣI-Ä}¬

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

उपरोक्त कोड में प्रदर्शन समस्याएं हो सकती हैं, यहां 10 बाइट्स के साथ थोड़ा अधिक कुशल संस्करण है: टीआईओ विकल्प

व्याख्या

6×ŒΣI-Ä}¬   Main link. Argument n
6×          Push string containing '6' n times
  Œ         Push substrings
   Σ   }    Sort by result of code
    I-Ä     Absolute difference between n
        ¬   Head, implicit output

— kalsowerus
स्रोत

हाँ, लेकिन तब इसमें अंतिम टेस्टकेस पर प्रदर्शन के मुद्दे थे। TIO पर अधिकतम 60 सेकंड इसे चलाने के लिए पर्याप्त नहीं थे):

— kalsowerus

@ रिले धन्यवाद, मैंने अपना उत्तर अपडेट किया :)

— कलसोवरस

2

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

Max[Take[LinearRecurrence[{11,-10},{0,6},IntegerLength[#]+1],-2]~Nearest~#]&

— J42161217
स्रोत

2

नीम , 12 10 बाइट्स (गैर-प्रतिस्पर्धात्मक)

-1 बाइट स्टैनबर्ग के लिए धन्यवाद

𝐥𝐈Γ6Θℝ)₁>𝕔

स्पष्टीकरण:

               Implicit input: [366]
𝐥               Push the length of the input
                [3]
  𝐈             Inclusive range
                [[1, 2, 3]]
   Γ            For each
       ℝ         Repeat
    6            6
     Θ           currently looped value times
                 [[6, 66, 666]]
          )     End for each
             𝕔  Get the closest value to
           ₁    The first line of input...
            >   ...incremented by one
                [666]
                Implicitly print entire stack

दुर्भाग्य से, 𝕔 एक सूची में कम मूल्य वापस आ जाएगा यदि दो संख्याओं में समान अंतर है, तो हमें उसके लिए खाते में 2 बाइट्स जोड़ना होगा।

के रूप में गैर-प्रतिस्पर्धा >, <और ℝइस सवाल के पूछे जाने के बाद जोड़े गए थे (और𝐥 न केवल सूचियों के साथ काम करने के लिए तय किया गया था)

नोट: 19 या उससे अधिक की लंबाई के साथ संख्याओं के लिए काम नहीं करेगा - क्योंकि वे जावा के लोंगों को संभालने के लिए बहुत बड़े हैं। (लेकिन यह काफी बड़ा मूल्य है, और ठीक होना चाहिए)

कोशिश करो

— Okx
स्रोत

निश्चित रूप से आप इस उत्तर का मुकाबला कर सकते हैं ....

— लीक नून

यदि आप के Γ6Θℝ)साथ प्रतिस्थापित करते हैं तो यह काम करेगा ΓΘ𝐈Γ6)𝐣)?

— लीक नून

@LeakyNun मैं इसे देखूंगा।

— ओकेक्स

@LeakyNun नहीं, मुझे नहीं लगता कि इसका मुकाबला करने का कोई तरीका है, क्योंकि एम्बेडेड लूप के साथ एक बग (अब तय) था।

— ओकेक्स

किसने अपमानित किया, और क्यों?

— ओकेक्स

2

जावा 8, 37 बाइट्स

 n->(""+-~n*3/11).replaceAll(".","6");

द्वारा जा रहे केविन Cruijssen के उदाहरण और बस एक स्ट्रिंग लौट रहे हैं।

सही लंबाई पाने के लिए * 3/11 चाल करें, फिर सभी छक्कों के साथ बदलें।

— जॉली विदूषक
स्रोत

@ LeakyNun, -~मुझे इस पृष्ठ पर दस बार देखना चाहिए था अगर मैंने ध्यान दिया होता ...

— जॉलीजोकर

2

मैं 36 बाइट्स गिनता हूं। आपके कोड में एक अनावश्यक अनुगामी अर्धविराम और प्रमुख स्थान है।

— फल

1

QBIC , 37 27 बाइट्स

≈!@36`!<=:|A=A+!6$]?_sA,2,a

मैथ्स ™ का उपयोग करने के बजाय अब यह डेमो डोमेन (36, 366, ...) में ब्रेक खोजने के लिए स्ट्रिंग हेरफेर का उपयोग करता है। @ Eush77 जेएस जवाब से प्रेरित है।

व्याख्या

≈         |  WHILE <condition> 
 !    !        a numerical cast of
  @  `         the string literal A$
   36          starting out as "36"
       <=    is smaller than or equal to
         :   cmd line argument 'a'
A=A+ 6       Add a 6 to the end of A$ (36 ==> 366 ==> 3666)
    ! $         as a string-cast
]            WEND (ends the WHIOLE loop body)
?_sA         PRINT a substring of A$            n=37, A$ = 366
  ,2           starting at index 2                          ^
  ,a           running well past the end of the string      66

— steenbergh
स्रोत

1

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

dsxZ1-10r^d11*2-3/dsylx[0r-]s.<.3*ly+d[6]s.0=.

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

dsxZ1-10r^d11*2-3/dsylx[0r-]s.<.3*ly+d[6]s.0=.
   Z1-10r^                                      Nearest power of 10
           11*2-3/                              The number in between 6ⁿ and 6ⁿ6
          d          lx[0r-]s.<.                Check which side we're on
                                3*ly+           Get the answer for x≥3
                                     d[6]s.0=.  Return 6 for x<3

— eush77
स्रोत

1

सी #, 142 बाइट्स

a=>{var c=(a+"").Length;return int.Parse(a<int.Parse(3+new string('6',c==1?2:(c==10?1:c)))?new string('6',c-1):new string('6',c==10?c-1:c));};

यह इस तथ्य का उपयोग करता है, कि हमें हर 36666 पर अगले डीमॉनिक नंबर पर जाने की आवश्यकता है ... अधिक पठनीय रूप में:

var c = (a + "").Length; 
    return int.Parse(a < int.Parse(3 + new string('6', 
        c == 1 ? 2 : (c == 10 ? 1 : c))) 
        ? new string('6', c - 1) 
        : new string('6', c == 10 ? c - 1 : c));

— होर्वाथ डेविड
स्रोत

2

मुझे लगता है कि स्ट्रिंग के बजाय पूर्णांक अंकगणित का उपयोग करने से आप बहुत सारे बाइट बचा सकते हैं।

— लीक नून

ठीक है, आप एक संख्या को c # में एक स्ट्रिंग में जोड़कर इसे केवल एक स्ट्रिंग में बदल सकते हैं क्योंकि इसमें एक अतिभारित + ऑपरेटर है, जैसा कि मेरे 102 बाइट्स उत्तर में दिखाया गया है .. मुझे भी नहीं लगता कि आपको इसे वापस पार्स करने की आवश्यकता है int के रूप में सवाल बस हमें "निकटतम आसुरी संख्या का उत्पादन करने के लिए कहा"

— ली

1

ब्रिंगस्म , 15 बाइट्स

;3*11/z+[6:10/]

ऑर्लप के पायथन समाधान से अंकगणित का उपयोग करना :

;                   Read an integer from stdin
 3*11/              Multiply by 3 and divide by 11
      z+            If result is zero, add one
        [6:10/]     While not zero, print '6' and divide by 10

— daniero
स्रोत

1

मैंने फ़ीड में यह प्रश्न नहीं देखा, और केवल दुर्घटना से उस पर ठोकर खाई। यहाँ मेरा जवाब वैसे भी है:

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

n=>`${-~n*3/11|0}`.replace(/./g,6)

अंकीय उत्तर के लिए 1 बाइट जोड़ें। मूल रूप से इस ungolfed ES7 उत्तर (37 बाइट्स, पहले से ही संख्यात्मक) पर आधारित है:

n=>(10**(Math.log10(-~n*3/11)|0)*2-2)/3

वार्षिक रूप से ओपी चाहता है कि 36 की तुलना में 66 से 6. अधिक हो। स्पष्टीकरण: 11/3 = 3.666 ..., इसलिए इसे विभाजित करके 7..36, 37..366 आदि की सीमाएँ 1..9.9, 10 तक होती हैं। ..99.9 आदि यह 10 की अगली उच्च शक्ति की तुलना में 2/3 का कम से कम संख्यात्मक रूप से हल किया जा सकता है, हालांकि यह छोटा करने के लिए गोल्फर है, स्ट्रिंग में कनवर्ट करें, फिर सभी वर्णों को अंक में बदलें 6. (हालांकि अभी भी) गोल्फ के रूप में नहीं है कि वास्तव में चतुर पुनरावर्ती जवाब के रूप में।)

— नील
स्रोत

1

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

जोनाथन एलन के जेली प्रस्तुत करने के रूप में धीमा नहीं है, लेकिन इसके लिए O (n memory ) मेमोरी की आवश्यकता है, जहां n इनपुट संख्या है। हाँ।

ri)__{)'6*i}%f-_:z_:e<#=-

यह निम्नलिखित पायथन के बराबर है:

num = int(input()) + 1                                      # CJam: ri)__
demondiffs = [int("6" * (i + 1)) - num for i in range(num)] # CJam: {)'6*i}%f-
absdiffs = [abs(i) for i in demondiffs]                     # CJam: _:z
mindex = absdiffs.index(min(absdiffs))                      # CJam: _:e<#
print(num - demondiffs[mindex])                             # CJam: =-

वैकल्पिक समाधान, 12 बाइट्स

ri)3*B/s,'6*

यह CJam में orlp के एल्गोरिथ्म का अनुवाद है।

स्पष्टीकरण:

ri           e# Read integer:       | 36
  )          e# Increment:          | 37
   3*        e# Multiply by 3:      | 111
     B/      e# Divide by 0xB (11): | 10
       s     e# Convert to string:  | "10"
        ,    e# String length:      | 2
         '6  e# Push character '6': | 2 '6
           * e# Repeat character:   | "66"
e# Implicit output: 66

— फल तोड़ना
स्रोत

1

PHP, 49 बाइट्स

चरित्र को छाँटो ६

for(;trim($x=$argn+$i,6)>"";)$i=($i<1)-$i;echo$x;

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

trim($x=$argn+$i,6)>""आप के बजाय एक Regex समाधान !preg_match("#^6+$#",$x=$argn+$i)+11 बाइट्स या एक स्ट्रिंग लंबाई का उपयोग कर सकते हैं 6तुलना strlen($x=$argn+$i)-strspn($x,6)+10 बाइट्स की गणना करने के लिए

— जार्ग हुल्सरमैन
स्रोत

1

LOLCODE 1.4, 471 बाइट्स

HAI 1.4
CAN HAS STRING?
I HAS A i
GIMMEH i
I HAS A l ITZ I IZ STRING'Z LEN YR i MKAY
I HAS A s ITZ "3"
IM IN YR a
BOTH SAEM I IZ STRING'Z LEN YR s MKAY AN l
O RLY?
YA RLY
GTFO
OIC
s R SMOOSH s AN 6
IM OUTTA YR l
I HAS A o
DIFFRINT i AN BIGGR of i AN 4
O RLY?
YA RLY
VISIBLE 6
NO WAI
BOTH SAEM i AN SMALLR of i AN s
O RLY?
YA RLY
o R DIFF OF l AN 1
NO WAI
o R l
OIC
I HAS A f
IM IN YR b UPPIN YR k TIL BOTH SAEM k AN o
f R SMOOSH f AN 6
IM OUTTA YR b
VISIBLE f
OIC
KTHXBYE

वाह। यहाँ बताया गया है कि Ungolfed और समझाया गया:

HAI 1.4
CAN HAS STRING?
I HAS A input
GIMMEH input
I HAS A length ITZ I IZ STRING'Z LEN YR input MKAY BTW this is using the length function of the STRING library.
I HAS A sixes ITZ "3" BTW the average of for example [6...] and 6[6...] is 3[6...].
IM IN YR foreverloop BTW this loop fills the sixes variable.
    BOTH SAEM I IZ STRING'Z LEN YR sixes MKAY AN length # In LOLCODE, a statement containing only an expression assigns the implicit variable IT.
    O RLY? # Tests the current value in IT.
      YA RLY
        GTFO
    OIC
    sixes R SMOOSH sixes AN 6 BTW SMOOSH automatically casts things to YARN. It also does not need a MKAY unless there's something after it on the line.
IM OUTTA YR foreverloop
I HAS A outputlength
DIFFRINT input AN BIGGR of input AN 4 BTW LOLCODE doesn't have a built-in inequality operator. This just means input < 4
O RLY?
  YA RLY
    VISIBLE 6 BTW If it's less than 4, the algorithm of comparing to the nearest 3.6*10^n.
  NO WAI
    BOTH SAEM input AN SMALLR of input AN sixes BTW input<=sixes
    O RLY? BTW This if statement makes sure that if the input is less than 3.6*10^length, it goes to the previous place value's demon number.
      YA RLY
        outputlength R DIFF OF length AN 1
      NO WAI
        outputlength R length
    OIC
    I HAS A final
    IM IN YR forloop UPPIN YR iterator TIL BOTH SAEM iterator and outputlength
        final R SMOOSH final AN 6
    IM OUTTA YR forloop
    VISIBLE final
OIC
KTHXBYE

फिर भी वाह। यहाँ कुछ pseudojavascrython आपके लिए है।

hello()
import string
var i
i=input()
var l=string.len(i)
var s="3"
while True:
  if(string.len(s)==l):
    break
  s=s+6
var o
if(i!=max(i,4)): # Basically if(i<4)
  print 6
else:
  if(i==min(i,s)): # Basically if(i<=s)
    o=l-1
  else:
    o=l
  var f
  for(var k=0;k<o;k++):
    f=f+6
  print(f)
exit()

अभी भी नहीं मिलता है? यह प्रोग्राम मूल रूप से सिर्फ (इनपुट्स 1-3 को छोड़कर) इनपुट की तुलना 3.6 * 10 ^ n, इनपुट की लंबाई के रूप में करता है। यदि यह उस संख्या से छोटा है, तो यह लंबाई से कम 6s की संख्या को प्रिंट करता है। यदि यह उस संख्या से अधिक या बराबर है, तो छक्के की संख्या वर्तमान लंबाई है।

कुछ मदद गोल्फ प्यार करेंगे!

— OldBunny2800
स्रोत

0

हैक्स, 70 बाइट्स

function(x){x*=3;x/=11;do{Sys.print('6');}while((x=Std.int(x/10))>0);}

इनपुट को टाइप के रूप में पास करना होगा Floatपूर्णांक होने के बावजूद , अन्यथा हेक्स एक पूर्णांक को विभाजित करने की कोशिश के बारे में शिकायत करेगा (हाँ हैक्स यदि आप किसी भी चीज़ से पूर्णांक को विभाजित करने के लिए संकलित करने से इनकार करेंगे)

अन्य सभी उत्तरों के समान। 3 से गुणा करें, 11 से विभाजित करें, 6प्रत्येक अंक के लिए 1 प्रिंट करें ।

— Skidsdev
स्रोत

0

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

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

इसे यहां चलाएं । सेल आकार का चयन करें जो 3 * (n + 1) के मूल्यों को संभाल सकता है, इसलिए सभी परीक्षण मामलों को काम करने के लिए, 16 का चयन करें। काम करने के लिए डायनामिक (अनंत) मेमोरी को चालू करना होगा। यह टेप को बाईं ओर विस्तारित करने की अनुमति देता है। एक पूर्णांक इनपुट करने के लिए, इनपुट टाइप करें\366 लिए, n = 366 ।

Ungolfed:

इस समाधान के रूप में एक ही एल्गोरिथ्म का उपयोग करता है । प्रत्येक व्यक्तिगत चरण के लिए उपयोग किए जाने वाले एल्गोरिदम इस पृष्ठ से लिए गए हैं । उपयोग किए गए सभी एल्गोरिदम गैर-रैपिंग हैं, ताकि प्रोग्राम बड़े इनपुट के लिए टूट न जाए।

,+ # n = n plus 1
>+++ # 3
[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-] # n = n*3
<+++++++++++ # 10
<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>] # n = n/10
<[-]+<[>-]>[<+>->] # if (n == 0) { n = n plus 1 }
++++++[<+++++++++>-] # '6' (54)
<<<[-]++++++++++> # 10
[ # while (n above 0)
  >.< # print '6'
  [<<+>>-]<<[>[<<+<+>>>-]<<<[>>>+<<<-]>[<+>>-[<<[-]<+>>>-]<<<[>>>+<<<-]>[>-[>>>-<<<[-]]+<-]>-]>>>+<<]>> # n = n/10
]

— mbomb007
स्रोत

निश्चित रूप से n=n*3जैसे कुछ करने के लिए गोल्फ हो सकता है [->+++<]? और divmod एल्गोरिथ्म 10 से विभाजित करने के लिए?

— जो किंग

134 बाइट्स , जिसे और बेहतर किया जा सकता था

— जो किंग

@JoKing आपको बड़े परीक्षण मामलों का समर्थन करने के लिए गैर-रैपिंग एल्गोरिदम का उपयोग करना होगा, इसलिए आपका समाधान वास्तव में काम नहीं करता है। वहाँ एक कारण है कि मैं TIO का उपयोग नहीं किया है।

— mbomb007

ओह, मैं रैपिंग भाग को हटा दूंगा, जो केवल संख्या थी। 140 बाइट्स (TIO क्योंकि कोड देना आसान है) (EOF = 0)

— Jo King

0

05AB1E , 7 बाइट्स

6s×ηs.x

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

Program # Input ====================|> 2
--------#---------------------------+--------
6s×     # Push N 6's as a string.   | 66
   ηs   # Prefixes of this.         | [6, 66]
     .x # Closest element to input. | 6

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

0

जाप , 9 बाइट्स

_ì e¥6}cU

कोशिश करो

— झबरा
स्रोत

0

सी #, 102 बाइट्स

string a(int j,int k=0)=>(j+"|"+(k=k==0?j:k)).Split('|').Where(s=>s.All(c=>c=='6')).Max()??a(j+1,k-1);

की लंबाई में निराश Kinda, जावा में छोटे जवाब के रूप में बिल्कुल वैसा ही कर सकता था, लेकिन मैं वास्तव में इसे समझ नहीं पाया क्योंकि मैं एक आलसी, बेवकूफ .NET डेवलपर हूं :)

— ली
स्रोत

मुझे निकटतम दानव दिखाओ

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

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

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

व्याख्या

जावा 7, 96 93 66 बाइट्स

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

कैसे?

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

सी, 118 बाइट्स

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

परीक्षण के मामलों

गणितज्ञ, 36 बाइट्स

हानिकारक माना जाने वाला टेंपलेट , 118 बाइट्स

05AB1E , 10 9 बाइट्स

व्याख्या

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

नीम , 12 10 बाइट्स (गैर-प्रतिस्पर्धात्मक)

जावा 8, 37 बाइट्स

QBIC , 37 27 बाइट्स

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

सी #, 142 बाइट्स

ब्रिंगस्म , 15 बाइट्स

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

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

वैकल्पिक समाधान, 12 बाइट्स

PHP, 49 बाइट्स

LOLCODE 1.4, 471 बाइट्स

हैक्स, 70 बाइट्स

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

Ungolfed:

05AB1E , 7 बाइट्स

जाप , 9 बाइट्स

सी #, 102 बाइट्स