दी गई सीमा के भीतर भाग्यशाली टिकटों की गणना करें

Question

रूस में हमारे पास एक परंपरा की तरह कुछ है: हम भाग्यशाली टिकट की तलाश में हैं।

यहाँ एक नियमित टिकट कैसा दिखता है:

जैसा कि आप देख सकते हैं, टिकट में छह अंकों की संख्या होती है।

छह अंकों की संख्या भाग्यशाली मानी जाती है यदि पहले तीन अंकों का योग पिछले तीन के योग के बराबर है।

फोटो पर संख्या भाग्यशाली नहीं है:

038937
038 937
0 + 3 + 8 = 11
9 + 3 + 7 = 19
11 != 19

चुनौती

एक सीमा (समावेशी) की सीमाओं को देखते हुए, इसके भीतर निहित भाग्यशाली टिकट संख्याओं की संख्या वापस करें।

पैरामीटर

• इनपुट: 2 पूर्णांक: सीमा में पहला और अंतिम पूर्णांक
• इनपुट 0 और 999999 के बीच होंगे
• आउटपुट: 1 पूर्णांक: सीमा में कितने भाग्यशाली नंबर हैं
• आप इनपुट ले सकते हैं और आउटपुट को किसी भी स्वीकार्य प्रारूप में वापस कर सकते हैं
• 100000 से कम संख्या के लिए अग्रणी शून्य मान लें।

उदाहरण

0, 1 => 1
100000, 200000 => 5280
123456, 654321 => 31607
0, 999999 => 55252

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

अद्यतन: यहाँ भाग्यशाली एक है

Comments

संबंधित ।

— user202729

Answer 1

05AB1E , 8 (या 10?) 11 (या 13?) बाइट्स

Ÿʒ₄n+¦S3ôOË

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

नोट: 05AB1E में तार और पूर्णांक विनिमेय हैं, इसलिए आउटपुट संख्या में अग्रणी शून्य शामिल नहीं हैं। यह हालांकि 1 अतिरिक्त बाइट ( 12 बाइट ) के साथ तय किया जा सकता है :

Ÿ₄n+€¦ʒS3ôOË

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

+3 बाइट्स को 3 या उससे कम (रेंज [000000, 000999]) की संख्या के साथ बग-फिक्स नंबर ।

स्पष्टीकरण:

Ÿ          # Create an inclusive (on both sides) range from the two inputs
           #  i.e. 038920 and 038910 → 
           #   [38910,38911,38912,38913,38914,38915,38916,38917,38918,38919,38920]
 ʒ         # Filter this list by:
  ₄n+      #  Add 1,000,000 to the number
     |     #  And remove the leading 1
           #   i.e. 38910 → 1038910 → '038910'
  S        #  Transform it to a list of digits
           #   i.e. '038910' → ['0','3','8','9','1','0']
   3ô      #  Split it into chunks of length 3
           #   i.e. ['0','3','8','9','1','0'] → [['0','3','8'],['9','1','0']]
     O     #  Sum the digits in both parts
           #   i.e. [['0','3','8'],['9','1','0']] → [11,10]
      Ë    #  Check if they are equal (if they are, they remain in the filtered list)
           #   i.e. [11,10] → 0

---

संपादित करें: मुझे लगता है (और अधिकांश अन्य उत्तर) चुनौती को थोड़ा गलत करते हैं और सीमा के भीतर संख्याओं के बजाय संख्याओं की मात्रा पूछी जाती है। उस स्थिति में एक अनुगामी }gजोड़ा जा सकता है (फ़िल्टर को बंद करें; और फ़िल्टर्ड सूची में छोड़ दिए गए नंबरों की मात्रा प्राप्त करें), इसलिए इसके बजाय 10 13 बाइट्स हैं:

Ÿʒ₄n+¦S3ôOË}g

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

Comments

1000 से कम की सीमा के लिए (उदाहरण के लिए [0; 1000]), आपका परिणाम थोड़ा हटकर लगता है (1000 भाग्यशाली संख्याएँ पाई जाती हैं)।

— फ्रोसक

अगर मैं चुनौती को सही ढंग से समझता हूं, तो प्रत्येक संख्या में 1.000.000 जोड़कर और पहले वर्ण को हटाकर इस समस्या को हल किया जाएगा। इसका उपयोग करने से भी छुटकारा मिलेगा R।

— अदनान

@ अदनान धन्यवाद, यह वास्तव में एक बहुत अच्छा तरीका है इसे संभालना है।

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

यह वह गणना है जो आवश्यक है (और आउटपुट को अग्रणी शून्य की आवश्यकता नहीं है), इसलिए 13.

— जोनाथन एलन

Answer 2

सी # (.NET कोर) , 93 + 18 = 111 बाइट्स

a=>b=>Enumerable.Range(a,b-a+1).Select(e=>$"{e:D6}").Count(e=>e[0]+e[1]+e[2]==e[3]+e[4]+e[5])

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

के लिए 18 बाइट्स using System.Linq;। मेरा मानना ​​था कि इनपुट और आउटपुट प्रारूप लचीले हो सकते हैं। इसलिए मैं दो पूर्णांक इनपुट के रूप में लेता हूं (रेंज, समावेशी)।

कुछ परीक्षा परिणाम:

a=1000
b=1100

Lucky numbers = 3 [001001, 001010, 001100]

a=2000
b=2100

Lucky numbers = 3 [002002, 002011, 002020]

a=222000
b=222100

Lucky numbers = 7 [222006, 222015, 222024, 222033, 222042, 222051, 222060]

a=0
b=999999

Lucky numbers = 55252 (that's 5.5% of the total numbers)

Answer 3

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

वाक्य रचना currying में इनपुट लेता है (m)(n), जहां मीटर है अनन्य समावेशी ऊपरी बाध्य और एन समावेशी कम बाध्य है।

m=>g=n=>n<=m&&![...n+=''].reduce((t,d,i)=>t-=n[i+3]?d:-d,0)+g(-~n)

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

कैसे?

हम प्रत्येक संख्या को उसके अंकों d i के माध्यम से चलते हुए और कुल t को अपडेट करके परीक्षण करते हैं :$n$$d_i$$t$

• अगर वहाँ इस एक के बाद कम से कम 3 शेष अंक हैं$t \gets t - d_i$
• अन्यथा$t \gets t + d_i$

यदि हमारे पास प्रक्रिया के अंत में है, तो n एक भाग्यशाली संख्या है।$t=0$$n$

---

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

एक ही इनपुट प्रारूप।

m=>g=n=>n<=m&&!eval([...n/1e3+''].join`+`.split`+.`.join`^`)+g(n+1)

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

कैसे?

प्रत्येक संख्या :$n$

• इसे विभाजित करें : जैसे$1000$38937 --> 38.937
• एक स्ट्रिंग और विभाजन के लिए मोटे: ['3','8','.','9','3','7']
• के साथ जुड़ें +:"3+8+.+9+3+7"
• इसके +.साथ बदलें ^:"3+8^+9+3+7"
• जेएस कोड के रूप में मूल्यांकन करें और देखें कि क्या परिणाम : ( 11 XOR 19 )$0$24$11$$19$

यदि , कोई दशमलव बिंदु उत्पन्न नहीं होता है और मूल्यांकन की गई अभिव्यक्ति सिर्फ एक सकारात्मक योग (मिथ्या) है, जब तक कि n = 0 (सत्य) नहीं। यह दोनों मामलों में अपेक्षित परिणाम है।$n \equiv 0 \pmod{1000}$$n=0$

Comments

इसे समावेशी बनाया गया है।

— जोनाथन एलन

Answer 4

रूबी , 56 54 बाइट्स

->a,b{(a..b).count{|i|j=i.digits;j[0,3].sum*2==j.sum}}

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

तरीका:

1. हर संख्या के लिए, अंकों की एक सरणी बनाता है (जो उलटा निकलता है)
2. सरणी में पहले 3 अंकों की संख्या की तुलना करता है (संख्या में अंतिम 3) पूरे सरणी के योग को 2 से गुणा करता है
3. उन संख्याओं को गिनाता है जिनके लिए दो रकम बराबर हैं

Answer 5

जाप , 38 15 बाइट्स

õV Ëì ò3n)mx r¥

-23 शैगी को धन्यवाद!

मेरा पहला जाप प्रस्तुत; सभी मदद के लिए झबरा धन्यवाद!

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

Comments

Japt में आपका स्वागत है! :)

— झबरा

@ शगुन थैंक्स! यह एक बहुत साफ भाषा है!

— उभयचर जूल

आरंभ करने में सहायता के लिए । अगर आपको कोई सवाल है तो बेझिझक मुझे चैट में पिंग करें ।

— झबरा

@ शगुन यह कमाल है। मैंने निश्चित रूप से उससे बहुत कुछ सीखा है। क्या आप इसे अपने उत्तर के रूप में पोस्ट करने की योजना बना रहे हैं? तुम्हे करना चाहिए!

— उभयचर जूल

नहीं, आपके पास यह हो सकता है :) जैसे मैंने कहा, शुरू करने में आपकी मदद करने के लिए।

— झबरा

Answer 6

पायथन 3, 117 113 106 135 बाइट्स

यह मेरा पहला उत्तर है इसलिए मुझे यकीन है कि सुधार की गुंजाइश है।

def x(a,b):
    n=0
    for i in range(a,b+1):
        if sum(map(int,str(i//1000)))==sum(map(int,str(i%1000))):n+=1
    print(n)

• -4 बाइट्स WW के लिए धन्यवाद
• -7 बाइट्स आसोन तुहिद का धन्यवाद
• +29 बाइट्स एक फंक्शन बनाने के लिए

पूर्णांक विभाजन के माध्यम से पहले तीन अंक और अंतिम तीन modulo के माध्यम से प्राप्त होता है। सीमा में पहले और अंतिम पूर्णांक क्रमशः x, के रूप में aऔर b, फ़ंक्शन के तर्कों के रूप में इनपुट किए जाते हैं। आउटपुट है n, मुद्रित है।

Ungolfed:

def x(a, b):
    n = 0
    for i in range(a, b + 1):
        if sum(map(int, str(i // 1000))) == sum(map(int, str(i % 1000))):
            n += 1
    print(n)

Comments

अगर btw के बाद आपको इंडेंटेशन की आवश्यकता नहीं है। पहले या अंतिम 3 अंक लेने से पहले स्ट्रिंग में बदलना भी सस्ता होगा।

— पोस्ट रॉक गार्फ हंटर

PPCG में आपका स्वागत है! की जाँच करें अजगर में गोल्फ के लिए टिप्स युक्तियाँ और चालें के लिए, वहाँ यदि आप रुचि रखते हैं अधिकांश भाषाओं के लिए एक समान धागा है। साथ ही, TIO लिंक को प्रदर्शन के रूप में शामिल करना अच्छा है ।

— असोन तुहिद

मैं जगह सुझाव देंगे n=n+1साथ n+=1और सही अगर बयान के बाद यह आगे बढ़ ( if...:n+=1)

— Asone Tuhid

आप नहीं ले सकते aऔर bके रूप में पूर्व घोषित चर। आपको या तो एक फंक्शन करना है या उन्हें इनपुट के माध्यम से लेना है

— Jo King

यदि आप इसे एक फ़ंक्शन के रूप में रख रहे हैं, तो आप n=0भाग को हेडर में स्थानांतरित कर सकते हैं , जैसेdef x(a,b,n=0)

— जो किंग

Answer 7

आर , 93 86 बाइट्स

@ Giuseppe /

function(a,b){for(i in sprintf("%06d",a:b)){x=utf8ToInt(i);F=F+!sum(x[1:3]-x[4:6])}
F}

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

पूर्णांक जानकारी। उनके साथ पैड 0। छह ASCII कोड बिंदुओं में परिवर्तित करें। Fबिलिन का दुरुपयोग करें ।

Comments

मैं एक एनए मिल रहा है कि समारोह से लौट आए।

— राबर्ट एस।

मैंने संपादन वापस ले लिया है। नया संस्करण scipenसमस्या के कारण 0 पर विफल रहता है। ओह अच्छा।

— एन जी एम

91 बाइट्स

— Giuseppe

86 बाइट्स

— Giuseppe

Answer 8

भूसी , 12 बाइट्स

#ȯ§¤=Σ↓↑3↔d…

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

व्याख्या

#(§¤=Σ↓↑3↔d)…  -- example input: 100000 101000
            …  -- inclusive range: [100000,100001..100999,101000]
#(         )   -- count elements where (example with 100010)
          d    -- | digits: [1,0,0,0,1,0]
         ↔     -- | reversed: [0,1,0,0,0,1]
  §     3      -- | fork elements (3 and [0,1,0,0,0,1])
       ↑       -- | | take: [0,1,0]
      ↓        -- | | drop: [0,0,1]
   ¤=          -- | > compare the results by equality of their
     Σ         -- | | sums 1 == 1
               -- | : 1
               -- : 3

Comments

ऐसा लगता है कि आपके समाधान में वही दोष है जो मेरे शुरुआती संस्करण में था: [000000, 001001]परिणाम 2( 000000और 001001) में होना चाहिए , लेकिन 1001इसके बजाय परिणाम । (मैंने इसके लिए फिक्सिंग के रूप 1,000,000में ट्रेलिंग 1को जोड़ा और हटा दिया , यकीन नहीं होता कि हस्क में कितना आसान / बाइट-कुशल है, हालांकि।)

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

@ केविनक्रूजसेन: मुझे लगता है कि मुझे याद है कि यह चुनौती शुरू में स्पष्ट नहीं थी, मेरे पास इस आरएन में देखने के लिए समय नहीं है, इसलिए मैंने अभी अपने प्रारंभिक प्रस्तुत पर वापस प्रवेश किया जो कि सही प्रतीत होता है।

— ।

Answer 9

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

ＩＬΦ…·ＮＮ⁼Σι⊗Σ÷ιφ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: मैंने मूल रूप से सोचा था कि यह भाग्यशाली संख्याओं की सूची थी जिनकी आवश्यकता थी। यह 14 बाइट्स में किया जा सकता है (सूची को हटाकर Ｌ, जो सूची की लंबाई लेता है), या 20 बाइट्स में यदि आप कुछ अच्छा स्वरूपण चाहते हैं:

ＥΦ…·ＮＮ⁼Σι⊗Σ÷ιφ﹪%06dι

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

    ＮＮ                  Input the range endpoints
  …·                    Inclusive range
 Φ                      Filter
        ι               Current value
       Σ                Sum of digits
            ι           Current value
             φ          Predefined variable 1000
           ÷            Integer divide
          Σ             Sum of digits
         ⊗              Doubled
      ⁼                 Equals
Ｅ                       Map over results
                   ι    Current value
               %06d     Literal string
              ﹪         Format value
                        Implicitly print each result on its own line

Answer 10

पर्ल 5 + -pl -MList::Util+(sum), 49 बाइट्स

@F=/./g,$\+=sum@F[5,4,3]==sum@F[2,1,0]for$_..<>}{

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

---

पर्ल 5 +-nl -MList::Util+(sum) -M5.010 , 50 बाइट्स

इसके बजाय प्रत्येक टिकट का उत्पादन +1 बाइट है:

@F=/./g,sum@F[5,4,3]-sum(@F[2,1,0])||say for$_..<>

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

Answer 11

पायथन 3 , 89 86 बाइट्स

-2 श्री एक्सकोडर को धन्यवाद।

-3 असोन तुहिद के उत्तर से प्रेरणादायक।

lambda a,b:sum(sum(map(int,str(i)))==2*sum(map(int,str(i)[-3:]))for i in range(a,b+1))

परीक्षण के परिणाम:

Example 1 : 
a = 0
b = 1
Lucky numbers : 1 

Example 2 : 
a = 100000
b = 200000
Lucky numbers : 5280 

Example 3 : 
a = 123456
b = 654321
Lucky numbers : 31607 

Example 3 : 
a = 0
b = 999999
Lucky numbers : 55252 

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

Comments

मतगणना संस्करण में, sumकोई भी जनरेटर बना सकता है ताकि कोष्ठक की [...] आवश्यकता न हो

— श्री एक्सकोडर

range(a,b+1)कल्पना अब "समावेशी" बताती है (यदि यह आप के *rस्थान पर उपयोग नहीं कर सकते थे a,b- मेरे अजगर 2 उत्तर देखें)। यह भी ध्यान दें कि कल्पना अब यह पुष्टि करती है कि वास्तव में वह गणना होनी चाहिए जो आउटपुट है।

— जोनाथन एलन

Answer 12

MATL , 24 बाइट्स

&:1e3&\,!'%03d'&V2&sw]=s

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

(-2 बाइट्स लुइस मेन्डो के लिए धन्यवाद।)

&: - दो दी गई संख्याओं के बीच एक समावेशी सीमा बनाएं

1e3&\ - 'divrem' - 1000 से विभाजित करें और दो सरणियों में अनुस्मारक और फ़्लोट किए गए उद्धरण प्राप्त करें।

, - दो बार करें

!'03d'&V - प्रत्येक मान को शून्य-गद्देदार तीन-चौड़ाई वाले स्ट्रिंग में परिवर्तित करें और परिवर्तित करें

&s - प्रत्येक पंक्ति के मूल्यों का योग

w - अनुस्मारक सरणी को बाहर लाने के लिए स्विच करें और उस पर फिर से करें

] - अंत लूप

= - समानता के लिए जाँच करें (उन स्थानों पर 1s लौटाएं जहाँ सरणियाँ समान हैं)

s - गणना (अनुमानित आउटपुट) प्राप्त करने के लिए उन्हें राशि

Answer 13

कोटलिन , 152 119 बाइट्स

{a:Int,b:Int->(a..b).map{String.format("%06d",it)}.filter{it[0].toInt()+it[1].toInt()+it[2].toInt()==it[3].toInt()+it[4].toInt()+it[5].toInt()}.count()}

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

दो पूर्णांकों को लेने से इसे छह प्रतीक तार और गिनती में परिवर्तित करें।

यह mazzy और 119 बाइट्स के लिए उसके समाधान के लिए धन्यवाद ।

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);(d[0]-'0')+(d[1]-'0')+(d[2]-'0')==(d[3]-'0')+(d[4]-'0')+(d[5]-'0')}}

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

Comments

आप इसे 133 बाइट्स तक ले सकते हैं{a:Int,b:Int->(a..b).map{"%06d".format(it)}.filter{(it[0]-'0')+(it[1]-'0')+(it[2]-'0')==(it[3]-'0')+(it[4]-'0')+(it[5]-'0')}.count()}

— mazzy

Answer 14

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

sb[d]sD[dA00~[rA~rA~++rx]dx=D1+dlb!<L]dsLxkz

अन्यथा खाली स्टैक से दो तर्क देता है, स्टैक के शीर्ष पर आउटपुट।

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

यहाँ चतुर बिट एक अनाम (यानी, बिना रुके) मैक्रो का उपयोग होता है जिसे अन्य तीन-अंकीय भाग पर स्वयं की प्रतिलिपि चलाने के लिए निष्पादन से पहले डुप्लिकेट किया जाता है।

व्याख्या

आंतरिक मैक्रो [rA~rA~++rx]का प्रभाव "तीन अंकों की संख्या के अंकों की संख्या की गणना करना है जो स्टैक पर दूसरा-टू-टॉप है, फिर स्टैक के मूल शीर्ष को मैक्रो के रूप में निष्पादित करें"।

मुख्य कार्यक्रम:

sb             Saves the upper bound as b so we'll know when to quit
[d]sD          Defines the macro D, which contextually is "increment stack depth"
[              Start the main loop - the next number to test is on top 
  d              Make a copy to increment later for loop purposes
  A00            The literal "1000"
  ~              Quotient and remainder, so "123456" is now "123 456"
  [rA~rA~++rx]d  Stack is now "123 456 M M", where M is the anonymous macro
  x              Run M on the stack "123 456 M", which (see definition 
                 above) ends up running M on the stack "123 15", which
                 leaves "15 6" (and executes the 6, which is a no-op)
  =D             If the two sums were equal, increment the stack depth
  1+             Increment the current test number
  dlb!<L         Loop unless the test number is now larger than b
]dsLx          Name and start the loop
kz             Current depth is 1+answer, so throw away top and return

Answer 15

पास्कल (FPC) , 163 153 बाइट्स

var a,b:Int32;begin read(a,b);for a:=a to b do if a div$186A0+a div$2710mod$A+a div$3E8mod$A=a div$64mod$A+a div$Amod$A+a mod$Athen b:=b+1;write(b-a)end.

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

व्याख्या

यहाँ पहले कुछ सामान्य दिखने वाला कोड है:

var a,b,i,s,c,d:Int32;
begin
  read(a,b);
  s:=0;
  for i:=a to b do begin
    c:=i div 1000;
    d:=i mod 1000;
    if c div 100+(c div 10) mod 10+c mod 10=d div 100+(d div 10) mod 10+d mod 10 then begin s:=s+1; {writeln(i)} end;
  end;
  write('There are ',s,' numbers');
end.

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

फिर मैंने लूप के व्यवहार का दुरुपयोग किया:

• पाश मूल्यों (से पहले से स्थापित कर रहे हैं aकरने के लिए b), इसलिएa पाश चर, छोड़ने के रूप में पुन: उपयोग किया जा सकता है i;
• लूप के अंत में, लूप वेरिएबल को अंतिम मूल्य ( bलूप से पहले का मान ) पर छोड़ दिया जाता है । मैंने bएक कंटेनर के रूप में उपयोग किया , एक भाग्यशाली संख्या मिलने पर इसे बढ़ाना और लूप के अंत bमें भाग्यशाली संख्याओं की मात्रा से अपने पुराने मूल्य से दूर है, इसलिए b-aसही परिणाम देता है। यह गिराs ।

की जगह daलूप को सीधे शॉर्ट्स पर संचालन के साथ । की जगह cसीधे पर कार्रवाई के साथ aखुराक पाश को छोटा नहीं है, लेकिन, छोड़ने के बाद d, पाश की beginऔरend अनावश्यक हैं और मैं केवल 2 वैरिएबल का उपयोग कर के साथ समाप्त हो :)

$गोल्फ कोड में हेक्साडेसिमल स्थिरांक शुरू करता है। जबकि वे बाइट्स नहीं बचाते हैं, वे दशमलव स्थिरांक से पहले आवश्यक रिक्त स्थान को समाप्त करते हैं।

Answer 16

जावा (ओपनजेडके 8) , 162 बाइट्स

... ऊपर कोटलिन उदाहरण से उधार लेता है।

import java.util.stream.IntStream;

(a,b)->IntStream.range(a,b+1).mapToObj(i->String.format("%06d",i).getBytes()).filter(c->c[0]+c[1]+c[2]==c[3]+c[4]+c[5]).count();

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

स्ट्रिंग के बाइट्स के योग की तुलना वास्तविक अंकों के योग के रूप में अच्छी है।

Comments

आप एक बाइट को करीने से बचा सकते हैं ( a->b->), लेकिन आपको पूरी तरह से योग्य IntStreamहोने की आवश्यकता होगी क्योंकि यह अंदर नहीं है java.lang।

— जैकब

PPCG में आपका स्वागत है! जैसा कि @ जाकोब ने उल्लेख किया है, आयात बाइट-काउंट का हिस्सा हैं, इसलिए आपको अपने कोड और बाइट-काउंट के java.util.stream.सामने जोड़ना होगा IntStream। भी द्वारा उल्लेख किया है जेकब , आप का उपयोग करके एक बाइट को बचा सकता है a->b->, और बदल कर कुछ अतिरिक्त बाइट्स बचाने आप भी कर सकते हैं String.formatकरने के लिए "".format। इसे ऑनलाइन आज़माएं: 139 बाइट्स । हालांकि पहला जवाब अच्छा लगा। मुझ से +1। यहां रहने का आनंद!

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

Answer 17

PHP , 131 बाइट्स

<?$f='array_sum(str_split(str_split(sprintf("%06d",$i),3)[';for($i=$argv[1]-1;$i++<$argv[2];)eval("\$a+=$f 0]))==$f 1]));");echo$a;

इसे चलाने के लिए:

php -n <filename> <from> <to>

उदाहरण:

php -n lucky_tickets.php 100 100000

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

Answer 18

पर्ल 6 , 51 49 बाइट्स

{+grep {[==] .flip.comb[^3,3..*]>>.sum},$^a..$^b}

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

अनाम कोड ब्लॉक जो दो नंबर लेता है और भाग्यशाली लोगों की संख्या लौटाता है। बड़े आदानों के लिए समय निकालें

Answer 19

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

डेनिस के लिए -1 धन्यवाद ( rµ...E)S-> r...E€Sसब कुछ वेक्टर के बाद से।)

rdȷD§E€S

रेंज के दो एंडपॉइंट (दोनों तरह से) को स्वीकार करने वाला एक डियाडिक लिंक जो भाग्यशाली टिकटों की गिनती का पैदावार देता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

कैसे?

ध्यान दें कि किसी भी गैर-नकारात्मक पूर्णांक से कम के लिए $1000000$, $N$, हम पूर्णांक डिवीजन का उपयोग करके जांच करने के लिए आवश्यक मानों के लिए अंकों के साथ दो नंबर प्राप्त कर सकते हैं $1000$
(उपज, कहते हैं, $X=\lfloor\frac{N}{1000}\rfloor$)
और उसके शेष
(कहते हैं$Y=N\mod{1000}$)
... वह है,$N=1000\times X+Y$

अब हम अंकों की तुलना करना चाहते हैं $X$ तथा $Y$ प्रत्येक के लिए $N$ एक सीमा में और उन लोगों को गिनें जो समान हैं।

rdȷD§E€S - Link: integer a; integer b
r        - inclusive range [a,b] (either [a,a+1,a+2,...,b] or [a,a-1,a-2,...,b])
         -                              e.g.: 0       or 78        or 7241
  ȷ      - literal 1000
 d       - divmod (vectorises)                [0,0]      [0,78]       [7,241]
   D     - to decimal lists (vectorises)      [[0],[0]]  [[0],[7,8]]  [[7],[2,4,1]]
    §    - sum each (vectorises)              [0,0]      [0,15]       [7,7]
     E€  - for €ach: all equal?               1          0            1
       S - sum (counts the 1s in the resulting list)

Comments

E€Sबचाता है µ।

— डेनिस

@ डेनिस आह हाँ, मैं एक और समाधान से काम कर रहा था जो रास्ते में सब कुछ वेक्टर नहीं करता था!

— जोनाथन एलन

Answer 20

पॉवरशेल, 85 बाइट्स

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

टेस्ट स्क्रिप्ट:

$f = {

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

}

@(
    ,((0,1), 1)
    ,((1000,2000), 3)
    ,((2000,3000), 6)
    ,((10000, 20000), 282)
    ,((101000, 102000), 6)
    ,((201000, 202000), 10)
    ,((901000, 902000), 63)
    ,((100000, 200000), 5280)
    ,((123456, 654321), 31607)
    #,((0, 999999), 55252)
) | % {
    $c, $e = $_
    "      $c"
    $r = &$f $c[0] $c[1]
    "$($e-eq$r): actual=$r expected=$e"
}

आउटपुट:

      0 1
True: actual=1 expected=1
      1000 2000
True: actual=3 expected=3
      2000 3000
True: actual=6 expected=6
      10000 20000
True: actual=282 expected=282
      101000 102000
True: actual=6 expected=6
      201000 202000
True: actual=10 expected=10
      901000 902000
True: actual=63 expected=63
      100000 200000
True: actual=5280 expected=5280
      123456 654321
True: actual=31607 expected=31607

Comments

शक्ति कोशिका? मैंने वास्तव में यह नहीं देखा कि एक आ रहा है: D

— Дмитрий Архипенко

Answer 21

कोटलिन, 95 बाइट्स

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

.kt परीक्षण के लिए:

var  f = {a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

fun main(args: Array<String>) {
    println(f(0,1))             // 1
    println(f(1000,2000))       // 3
    println(f(2000,3000))       // 6
    println(f(101000, 102000))  // 6
    println(f(201000, 202000))  // 10
    println(f(901000, 902000))  // 63
    println(f(10000, 20000))    // 282
    println(f(100000, 200000))  // 5280
    println(f(123456, 654321))  // 31607
    println(f(0, 999999))       // 55252
}

व्याख्या

श्रेणी से संख्याओं की गणना करें जहां सभी संख्या अंकों का योग पहले 3 अंकों के दोहरे योग के बराबर है।

Answer 22

स्टैक्स , 14 बाइट्स

ît║l`Yµß╖vYü╢^

इसे चलाएं और डीबग करें , लेकिन धैर्य रखें!

Answer 23

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

-3 असोन तुहिद के अवलोकन का उपयोग करके - क्रेडिट दें!

lambda a,b:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(a,b+1))

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

बहुत कुछ मेरे जेली उत्तर की तरह है (लेकिन इनपुट को यहां हल करना होगा a<=b)

---

इनपुट के लिए 75 बाइट्सa, b+1 (यानी रेंज सही बाउंड को बाहर करती है):

lambda*r:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(*r))

इसको आजमाओ

Answer 24

क्लोजर, 102 बाइट्स

#(count(for[i(range %(inc %2)):when(=(let[d(map int(format"%06d"i))](apply +(map -(drop 3 d)d)))0)]i))

मिश्रण तार और गणित बहुत मजेदार नहीं है।

Answer 25

जे , 35 बाइट्स

[:+/(6#10)([:=/_3+/\])@#:[+i.@>:@-~

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

Answer 26

सी (जीसीसी), 90 88 बाइट्स

l=10;u(c,k,y){for(y=0;c<=k;)c++%l+c/l%l+c/100%l-c/1000%l-c/10000%l-c/100000%l?:++y;c=y;}

मेरे जावा उत्तर का पोर्ट । इसे यहाँ ऑनलाइन आज़माएँ । धन्यवाद सीलिंग के लिएदो बाइट्स लिए ।

Ungolfed:

l=10; // constant, we will be using the number 10 rather a lot
u(c, k, // function returning an integer and taking two integer arguments: lower and upper bound
  y) { // abusing the argument list to declare a variable of type integer: the number of lucky tickets found in the range
    for(y = 0; c <= k; ) // set count to 0 and loop through the range
        c++ %l + c/l %l + c/100 %l // if the digit sum of the second half of the ticket number ...
        - c/1000 %l - c/10000 %l - c/100000 %l // ... is the same as the digit sum of the first half ...
        ?: ++y; // ... it's a lucky ticket: increment the count
    c = y; // return the count
}

Comments

L'✐'इसके बजाय सुझाव दें 10000और 10किसी वैरिएबल को असाइन करें।

— सीलिंगकैट

@ceilingcat मुझे यह पसंद है कि यह मुझे एक अतिरिक्त परिवर्तनशील नाम देता है, लेकिन मैं 10: bit.ly/2O5ND2Y को बताकर किसी भी बाइट को नहीं बचा सकता था, जैसा L'…'कि चाल के लिए, यह साफ है; लेकिन क्या यह बाइट्स को बचाता है? मुझे लगता है कि एक बहु-बाइट चरित्र है, इसलिए चरस की बचत करते समय, यह बाइट्स नहीं बचा सकता है ... या क्या यह कर सकता है?

— OOBalance

@ceilingcat मेरी गलती, दो बाइट्स को एक चर में 10 असाइन करके बचाया जा सकता है। धन्यवाद।

— OOBalance

Answer 27

जावा 8, 101 99 बाइट्स

u->l->{int n=0,d=10;for(;l<=u;)if(l++%d+l/d%d+l/100%d==l/1000%d+l/10000%d+l/100000%d)++n;return n;}

अन्य जावा उत्तर की तुलना में एक अलग दृष्टिकोण । धाराओं और स्ट्रिंग्स का उपयोग करने के बजाय, यह एक लूप का उपयोग करता है और सीधे संख्याओं का मूल्यांकन करता है। इसे ऑनलाइन आज़माएं यहाँ ।

धन्यवाद सीलिंग के लिएदो बाइट्स लिए ।

Ungolfed:

u -> l -> { // lambda taking two integer arguments in currying syntax and returning an integer
    int n = 0, // the counter
        d = 10; // auxiliary constant, we will be using the number 10 rather a lot
    for(; l <=u ; ) // loop over all ticket numbers in the range
        if(l++ %d + l/d %d + l/100 %d // if the digit sum of the second half of the number ...
           == l/1000 %d + l/10000 %d + l/100000 %d) // ... is the same as the digit sum of the first half ...
            ++n; // ... it's a lucky ticket, add 1 to the counter
    return n; // return the count
}

Answer 28

VBA (एक्सेल), 159 बाइट्स

[A1] [A2]इनपुट के रूप में तत्काल विंडो और सेल का उपयोग करना ।

c=[A1]-[A2]:d=IIf(c<0,[A1],[A2]):For x=d To d+Abs(c):e=String(6-Len(x),"0")&x:For y=1To 3:i=i+Mid(e,y,1):j=j+Mid(e,7-y,1):Next:z=IIf(i=j,z+1,z):i=0:j=0:Next:?z

Answer 29

एफ #, 110 बाइट्स

let t=string>>Seq.sumBy(int>>(-)48)
let r s e=Seq.where(fun n->t(n/1000)=t(n-(n/1000)*1000)){s..e}|>Seq.length

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

tस्ट्रिंग को संख्याओं में परिवर्तित करता है और उन्हें जमा करता है। rसे संख्याओं की सीमा लेता sहै e, और उन संख्याओं को फ़िल्टर करता है जो अशुभ हैं। पहले तीन अंक एकत्रित किए जाते हैं n/1000। दूसरे तीन अंकों की गणना द्वारा की जाती है n-(n/1000)*1000।