इनपुट

एक पूर्णांक n () 1) और एक अंक d (एक पूर्णांक जैसे कि 0 n d ) 9)।

किसी भी क्रम में; स्टडिन या मापदंडों या जो कुछ भी; एक कार्यक्रम या समारोह के लिए; आदि।

उत्पादन

पूर्णांक 1 से n समावेशी (क्रम में) जिनके दशमलव निरूपण में सम संख्या d शामिल हैं । (अर्थात, सूची में पूर्णांक वे पूर्णांक हैं, जो क्रमशः, d s की एक समान संख्या है ।)

किसी भी मानक प्रारूप आदि में, विशेष रूप से, दशमलव में आउटपुट का प्रतिनिधित्व नहीं किया जाना चाहिए।

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

उदाहरण

in(d,n) ↦ out
1,12    ↦ 2 3 4 5 6 7 8 9 11
0,111   ↦ 1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,68,69,71,72,73,74,75,76,77,78,79,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,97,98,99,100,111

धन्यवाद

शीर्षक के लिए क्विंटोपिया ।

code-golf integer

— msh210
स्रोत

क्या 0 को एक समान संख्या के रूप में गिना जाता है?

— MilkyWay90

@ मिल्कीवेय 90, निश्चित रूप से।

— msh210 8

3

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

RDċ€Ḃ¬T

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

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

RDċ€Ḃ¬T  Main link. Arguments: n, d

R        Range; yield [1, ..., n].
 D       Convert each integer in the range to base 10.
  ċ€     Count the occurrences of d in each array of decimal digits.
    Ḃ    Compute the parities.
     ¬   Negate, so even amounts evaluate to 1, odds to 0.
      T  Find all indices of truthy elements.

— डेनिस
स्रोत

13

05AB1E , 11 10 बाइट्स

कोड:

\>GN¹¢ÈiN,

स्पष्टीकरण:

\           # Pop input, which saves the first input into ¹
 >          # Increment on second input
  G         # For N in range(1, input + 1)
   N        # Push N
    ¹       # Push the first input from the input register
     ¢      # Count the number of occurences of the digit in N
      È     # Is even?
       iN,  # If true, print N with a newline

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

CP-1252 एन्कोडिंग का उपयोग करता है ।

— अदनान
स्रोत

Ings दोनों तर्कों को तार के रूप में व्याख्यायित करता है?

— 16 स्पियर

@ शेपर जो निर्भर करता है, यह स्ट्रिंग्स युक्त सूचियों पर भी किया जा सकता है। लेकिन यहाँ, यह दोनों तर्कों को तार के रूप में व्याख्यायित करता है।

— अदनान

13

हास्केल, 69 63 52 50 बाइट्स

d#n=[i|i<-[1..n],even$sum[1|x<-show i,read[x]==d]]

यहाँ मेरी पहली पोस्ट के लिए सीधा समाधान। यह showसंख्या की गिनती करने के लिए उपयोग करता है d। मैंने स्पष्ट Charरूप से इनपुट के रूप में उपयोग नहीं किया था d, जो 12 6 (डेमियन के संपादन के बाद) बाइट्स को बचा लेता था।

संपादित: 11 बाइट्स डेमियन के लिए कम धन्यवाद! संपादित 2: एक और 2 बाइट्स निम्मी के लिए कम धन्यवाद!

— Renzeee
स्रोत

2

आप एक सुस्पष्ट सूची द्वारा फ़िल्टर को प्रतिस्थापित कर सकते हैं: fdn = [i | i <- [1..n], यहां तक कि योग [1 | x <-show i, [x] == d] पढ़ें

— डेमियन

12

Befunge, 1080 945 बाइट्स

vd>"000">" "v
&0      ^              p21-1+*68<
62            >        v
8           >-|        >12g68*-:|
*             >11g1+11p^        $
+                      v  <
5                         |%2g11<
5                      v.:<          
+         v            <        
0         >268*+12p68*11p"000"40p50p60pv
p
           v                             -1<
             v-g01p06+1g06<
>&         >:>:10g1-`     |            >:0`|
             v            <                @
             v-+55p05+1g05<      
             >:54+`       |
   v               p04+g04<
  ^          <                <      <
   >60g68*-0`|      >50g68*-0`|
             >" "60p^         >" "50p^

स्कोर दिया जाता है कि हम पूरे वर्ग की गणना करते हैं, जिसमें नए अंक शामिल हैं, जो समझ में आता है। आप कोड को इंटरपेटर में कॉपी कर सकते हैं । दो इनपुट प्रदान करें, पहले d और फिर n । यह समाधान n > 999 से बड़े मूल्यों के लिए काम नहीं करता है ।

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

स्पष्टीकरण पर प्रयास करें:

नीचे दिए गए पहले कॉलम में हमने इनपुट से एक पूर्णांक पढ़ा, इसमें 48 (6 * 8, आप इसे अधिक बार देखेंगे) को इसे संबंधित ASCII मान में बदलने के लिए और इसे करने के लिए डालता है (10, 0)।

& - इनपुट पढ़ें

68*+ - 48 जोड़ें

55+0p - मान डालें (10, 0)

ध्यान दें कि dपर (1, 0)सिर्फ ढेर पर संख्या 100 तक पहुंचने का आसान तरीका है।

उसके बाद, हम पूर्व में जाते हैं और एक और पूर्णांक और सिर को पढ़ते हैं जिसे मैं ASCIIfier कहता हूं। यह वर्तमान संख्या को ASCII वर्णों की एक श्रृंखला में बदल देता है। ASCIIfier से आयताकार टुकड़ा (13, 12)है (26, 17)। यह दो छोरों के होते हैं, पहले गड़गड़ाहट की गणना करते हैं और दसियों की तुलना में और उन्हें तीन अंकों में डालते हैं (6, 0)और (5, 0)। उसके बाद आखिरी अंक में डाला जाता है (4, 0)। तो संख्या वास्तव में रिवर्स है।

v-g01p06+1g06< - increment the "hunderds counter" located at (0, 6) and decrease current value by 100
>:10g1-`     | - ASCIIfier entry; check if the current value is > 99, if so, go up, else go down
v            < - go to start of "tens counter"
v-+55p05+1g05< - increment the "tens counter" located at (0, 5) and decrease current value by 10
>:54+`       | - check if current value is > 9, if so, go up, else go down
      p04+g04< - put the final value into the "singles counter" located at (0, 4)

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

फिर हम वापस ऊपर जाते हैं, उत्तर के सभी रास्ते, जहाँ हम तीन अंकों को स्टैक पर रखते हैं। हम शीर्ष लूप में तीन अंकों पर पुनरावृत्ति करते हैं, (1, 1)यदि वर्तमान अंक इनपुट d से मेल खाता है तो हर बार काउंटर पर वेतन वृद्धि होती है।

जब ऐसा किया जाता है, तो हम यह देखने के लिए जाते हैं कि क्या काउंटर स्थित (1, 1)है या विषम है। यदि यह समान है, तो हम वर्तमान संख्या को आउटपुट करते हैं और वर्तमान मूल्य को कम करने के लिए बड़े बाहरी लूप पर जाते हैं और फिर से शुरू करते हैं।

— rael_kid
स्रोत

यदि आपके पास समय हो तो कृपया एक स्पष्टीकरण पोस्ट करें!

— एक सीमन्स

मैंने एक विवरण में एक प्रयास जोड़ा है .. पता चला कि यह स्पष्ट करना इतना आसान नहीं था ... आगे पूछने में संकोच न करें ...

— rael_kid

वैसे, मुझे अभी पता चला है कि मुझे आरोही क्रम में परिणाम का उत्पादन करना है, जिससे यह आवश्यकताओं के लिए और भी अधिक

— अनुकूल हो जाता है

हमेशा एक काम कर रहे जवाब के लिए +1! BTW, यह वास्तव में 945 बाइट्स है? यह 679

— लुइस मेंडो

हेहे धन्यवाद। मैंने 945 की गिनती की क्योंकि मैंने 21 लाइनों के पूरे वर्ग को x 45 कॉलम (न्यूलाइन सहित)

— rael_kid

7

अजगर 2, 50 बाइट्स

f=lambda d,n:n*[0]and f(d,n-1)+~`n`.count(d)%2*[n]

एक पुनरावर्ती कार्य जो अंक dको एक स्ट्रिंग के रूप में लेता है और nएक संख्या के रूप में ऊपरी बाउंड ।

अंकों की गिनती dके में nभी यह थोड़ा पूरक सापेक्ष 2, जो देता है लेने के द्वारा होने के लिए परीक्षण किया जाता है 1और भी के लिए और 0अजीब के लिए। यह कई nसूची में जोड़ रहे हैं, और n-1जब खाली सूची पर तार्किक शॉर्ट-सर्किट के माध्यम से रुककर फ़ंक्शन फिर से उठता है n==0।

यदि आउटपुट घटते क्रम में दिया जा सकता है, तो एक बाइट को 49 बाइट्स के लिए बचाया जा सकता है:

f=lambda d,n:n*[0]and~`n`.count(d)%2*[n]+f(d,n-1)

पुराना 51-बाइट समाधान:

lambda d,n:[x+1for x in range(n)if~`~x`.count(d)&1]

एक अनाम फ़ंक्शन जो अंकों dको एक स्ट्रिंग के रूप में लेता है और nएक संख्या के रूप में ऊपरी बाध्य होता है ।

दो चालें उपयोग की जाती हैं:

पायथन rangeशून्य-अनुक्रमित है 0...n-1, इसलिए हम प्रत्येक संभावित मूल्य में एक जोड़ते हैं x। फिर, गिनती करने के लिए d'में है x+1, यह उसका निषेध उपयोग करने के लिए एक चरित्र की बचत होती है ~xबजाय।
यहां तक कि मानों को फ़िल्टर करने के लिए, हम करते हैं ~_%2, जो पहले बिट-फ़्लिप को स्विच करने के लिए करता है, फिर अंतिम बिट को &1( %2यहां के रूप में ) लेता है , केवल एक सत्य मूल्य का उत्पादन करता है यदि मूल भी था।

— XNOR
स्रोत

4

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

f!%/`Tz2SE

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

— PurkkaKoodari
स्रोत

4

लूआ, 86 बाइट्स

तो असंगत विभाजक का उपयोग कर अनुमति दी है, मैं बदल सकते io.writeद्वारा print, जिसका अर्थ है संख्या एक या एक से अधिक नई पंक्तियों द्वारा अलग किया जाएगा।

यह एक पूर्ण कार्यक्रम है, जिसे इस तरह से बुलाया जाना है lua file.lua d n:।

यह dमौजूदा संख्या से सभी गैर- चरित्र को हटा देता है और परिणामी स्ट्रिंग के आकार का उपयोग करता है ताकि यह तय किया जा सके कि यह आउटपुट होना चाहिए या नहीं।

for i=1,0+arg[2]do io.write(#(i..''):gsub("[^"..arg[1].."]","")%2<1 and i.." "or"")end

— Katenkyo
स्रोत

4

जावास्क्रिप्ट (ईएस 6) 64

कंसोल के साथ आउटपुट का एक अनाम फ़ंक्शन। splitअंकों को गिनने के लिए सीधा प्रयोग ।

(d,n)=>{for(i=0;i++<n;)(i+'').split(d).length&1&&console.log(i)}

उत्पादन का उपयोग alert6 बाइट कम होगा, लेकिन मुझे वास्तव में यह पसंद नहीं है (और मैं वैसे भी खिलौना भाषाओं को हरा नहीं सकता हूं)

— edc65
स्रोत

4

MATL , 12 10 बाइट्स

:!V!=s2\~f

पहला इनपुट n है , दूसरा एक स्ट्रिंग के रूप में d है । उदाहरण के लिए:

12
'1'

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

:       % implicitly take input n (number). Generate row vector [1,2,...,n]
!       % transpose into column vector
V       % convert each number to string. Gives 2D char array padded with spaces
!       % transpose
=       % implicitly take input d (string). Compare with each element of the array
s       % sum of each column: number of coincidences with d
2\~     % true for even values
f       % find indices of true values. Implicitly display

— लुइस मेंडो
स्रोत

4

रूबी, 47 42 बाइट्स

?1.upto $*[1]{|s|s.count($*[0])%2<1&&p(s)}

कमांड लाइन के मापदंडों के रूप में डी और एन के साथ चलाएं , जैसे

ruby golf.rb 1 12

— जॉर्डन
स्रोत

2

शानदार पहला जवाब! PPCG में आपका स्वागत है! : D

— mbomb007

बहुत बढ़िया! रूबी 1.9+ में, आप के ?1लिए उपयोग कर सकते हैं "1"। और यह कम सुंदर है, लेकिन बाइट कम है, %2>0इसके बजाय.odd?

— histocrat

4

पॉवरशेल, 62 55

param($1,$2);1..$2|?{!(([char[]]"$_"-match$1).Count%2)}

संपादित करें: इस मामले में एक परम ब्लॉक का उपयोग कम है। कुछ अनावश्यक स्थान हटा दिया

एक गोल्फ भाषा नहीं है, लेकिन इसकी एकमात्र मैं वास्तव में जानता हूं। यह एक स्क्रिप्ट के रूप में सहेजा गया और इस तरह से काम करेगा M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12। पहला तर्क अंक d है और दूसरा पूर्णांक n है ।

नंबर 1 से n तक की एक सरणी बनाएं । उनमें से प्रत्येक के लिए एक चरित्र सरणी में परिवर्तित। 10 1,0 होगा। -matchएक सरणी ऑपरेटर के रूप में उपयोग करके सभी तत्व वापस आते हैं जो अंक d से मेल खाते हैं । वापस लौटे तत्वों की मात्रा और परिणाम 2 की गणना करें। परिणाम 0 के लिए और विषम के लिए 1 होगा। एक बूलियन के रूप में गलत है, इसलिए हम !लूप के लिए उपयोग करते हैं ताकि गलत और यहां तक कि सही परिणाम के विषम परिणामों का मूल्यांकन किया जा सके।

आउटपुट कंसोल पर सीमांकित एक नई पंक्ति है।

— मैट
स्रोत

PPCG में आपका स्वागत है, अच्छा पहला जवाब! :)

— FryAmTheEggman

@FryAmTheEggman स्वीट। धन्यवाद के लिए धन्यवाद। हालांकि मुझे अन्य सभी उत्तरों के तहत दफनाया जाएगा।

— मैट

3

रेटिना , 99 105 बाइट्स

ट्रेलिंग रिक्त स्थान पर ध्यान दें। <empty>एक खाली लाइन का प्रतिनिधित्व करता है।

\d+$
$*
+`^(. )(1*)1\b
$1$2 1$2
1+
$.0
+`^(.)(.*) ((?!\1)\d)*\1((?!\1)\d|(\1)((?!\1)\d)*\1)*\b
$1$2
^.  
<empty>

जैसे इनपुट लेता है 1 12। आउटपुट घटते क्रम में अलग हो जाता है।

मैंने 0*1(0|10*1)*एक संख्या में विषम संख्या से मिलान करने के लिए संशोधित किया \1। मैं आपके द्वारा ऊपर देखी गई लंबी रेगेक्स रेखा बनाने के लिए बदल 0गया (?!\1)\d, और । यह समझना कि लिंक्ड रेगेक्स कैसे काम करता है, महत्वपूर्ण है।1\1

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

पुराने संस्करण की टिप्पणी की व्याख्या

यदि अवरोही क्रम ठीक था

\d+$            Convert last number N to unary
$*
+`1(1*)$        Create list N N-1 ... 1 in unary
$0 $1
 (1)+           Convert back to decimal
 $#1
+`^(.)(.*) ((?!\1)\d)*\1((?!\1)\d|(\1)((?!\1)\d)*\1)*   Remove numbers w/ odd num of D's
$1$2 
^.              Remove first parameter
<empty>

— mbomb007
स्रोत

1

आप यूरी बैक से दशमलव में रूपांतरण का उपयोग 1+और कर सकते हैं $.0।

— FryAmTheEggman

3

बैश + जीएनयू उपयोगिताओं, 37

1 बाइट @Rud को धन्यवाद दिया।

seq $1|egrep "^[^$2]*($2[^$2]*){2}*$"

— डिजिटल आघात
स्रोत

*निम्नलिखित आरंभिक कोष्ठक निरर्थक प्रतीत होता है। इसे हटाने से आपकी 1 बाइट बचती है।

— रूड हेलडरमैन 20

@Rudud हाँ - धन्यवाद - अब तय।

— डिजिटल ट्रामा

3

पायथन 3.4, 92 85 79 85 बाइट्स

सहेजे गए 7 बाइट्स मेगो की
बदौलत mbomb007 की बदौलत एक और 6 बाइट्स बचाए गए
उन 6 बाइट्स को पा लिया क्योंकि पायथन 3.x

यह कोड गोल्फ में मेरा पहला शॉट है, इसलिए यहां कुछ भी नहीं है!

lambda n,d:[i for i in range(n+1)if len([j for j in list(str(i))if j==str(d)])%2is 0]

— Nakaan
स्रोत

1

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

— मेगो

आप `d`इसके बजाय का उपयोग कर सकते हैं str(d), और यदि आप मानते हैं कि एन एक पूर्णांक है (<2 ** 32), तो आप `i`इसके बजाय उपयोग कर सकते हैं str(i)।

— mbomb007

क्या strt के लिए बैकहैंड शॉर्टहैंड () हैं?

— नैकन

1

बैकथिक्स __repr__अजगर 2 के लिए एक आशुलिपि थे , उन्हें अजगर 3 में हटा दिया गया था। आपको संभवतः उस प्रतिबंध को प्रतिबिंबित करने के लिए अपने हेडर को बदलना चाहिए।

— फ्राईअमईएग्गमैन

हाँ, मैंने पाया कि दुभाषिया में एक परीक्षण मामले को इधर-उधर फेंकते हुए और खोदते समय। उदास चेहरा।

— नैकन

2

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

{(1..$^n).grep(*.comb.Bag{~$^d} %% 2)}

— हॉटकी
स्रोत

2

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

:1reIlL,"":Ic:.xl-L=%2=0,Iw,@Sw\

N को इनपुट के रूप में और आउटपुट के रूप में अंक की अपेक्षा करता है brachylog_main(12,1).

व्याख्या

:1reI                            § I is a number between 1 and Input
     lL,                         § L is the length of I
        "":Ic                    § Convert I to a string
             :.x                 § Remove all occurences of Output in that string
                l-L=%2=0,        § Check that the length of that new string - L mod 2 is 0
                         Iw,@Sw  § Write I, then write a space
                               \ § Backtrack (i.e. try a new value of I)

— Fatalize
स्रोत

2

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

Position[Count[#2]/@IntegerDigits/@Range@#,x_/;2∣x]&

— एक सीमन्स
स्रोत

2

पर्ल, 28 29 31 बाइट्स

के लिए +2 शामिल है -an

विनिर्देश अंक के साथ चलाएँ और STDIN पर लगातार लाइनों पर भरोसा करें:

echo -e "0\n111" | perl -anE'map s/@F/$&/g%2||say,1..<>'

— टन हास्पेल
स्रोत

2

ओरेकल SQL 11.2, 111 82 बाइट्स

SELECT LEVEL FROM DUAL WHERE MOD(REGEXP_COUNT(LEVEL,:d),2)=0 CONNECT BY LEVEL<=:n;

— Jeto
स्रोत

2

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

fun main(a:Array<String>)=print({n:String,d:String->IntRange(1,n.toInt()).filter{"$it".count{"$it"==d}%2==0}.joinToString()}(a[0],a[1]))

पूरी तरह कार्यात्मक कार्यक्रम, तर्कों के रूप में लेता है: एन डी

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

— मैट सम्स
स्रोत

2

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

यह एक लंबोदर अभिव्यक्ति है BiConsumer< Integer, Integer>:

(d,n)->for(int x=0;x++<n;)if((""+x).split(""+d,-1).length%2>0)System.out.println(x);

स्पष्टीकरण:

1 और n के बीच प्रत्येक संख्या के लिए, संख्या को एक स्ट्रिंग में परिवर्तित करें और इसे डी का उपयोग करके विभाजित करें। यदि यह विषम संख्या में वर्गों में विभाजित था, तो एक नई पंक्ति के बाद संख्या का प्रिंट आउट लें।

— जैक अम्मो
स्रोत

2

रेटिना, 72 71 55

\d+$
$*
\B
¶$`
1+
$.0
G`(.),((?>.*?\1){2})*(?!.*\1)
.,
<empty>

मार्टिन के लिए महान धन्यवाद, जो पूरी तरह से दुर्घटना से मुझे परमाणु मिलान समूहों की याद दिलाते हैं!

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

स्पष्टीकरण:

\d+$
$*

संख्या को बदलें, लेकिन अंक नहीं, इसके बराबर समकक्ष के साथ।

\B
¶$`

\Bप्रत्येक स्थिति (शून्य-चौड़ाई) से मेल खाता है जो एक शब्द सीमा नहीं है। ध्यान दें कि यह निम्नलिखित में से किसी से भी मेल नहीं खाएगा: स्ट्रिंग की शुरुआत, स्ट्रिंग का अंत, या अल्पविराम चरित्र के आसपास की कोई भी स्थिति। इन गैर-सीमाओं में से प्रत्येक को फिर एक नई रेखा के साथ बदल दिया जाता है और फिर मैच से पहले आने वाली स्ट्रिंग ( $`)। यह एक सूची देता है जैसे:

d,1
d,11
d,111

dकोई एकल दशमलव अंक कहाँ है।

1+
$.0

यह 1s की सभी सूचियों को उनकी लंबाई के दशमलव प्रतिनिधित्व में परिवर्तित करता है । यह आसानी से प्रभावित नहीं करेगा जो 1कि अल्पविराम से पहले हो सकता है, क्योंकि इसकी लंबाई हमेशा की 1तरह है।

G`(.),((?>.*?\1){2})*(?!.*\1)

यहां, Ggrep मोड चालू करता है, जिसका अर्थ है कि रेगेक्स से मेल खाने वाली रेखाएं रखी जाती हैं, और अन्य लाइनें छोड़ दी जाती हैं। यह रेगेक्स जटिल है, लेकिन यह अनिवार्य रूप से अग्रणी अंक के 2 के समूहों से मेल खाता है (कैप्चर समूह 1 में संग्रहीत है, इसलिए हम इसे संदर्भित कर सकते हैं \1)।

यहाँ कुंजी यह है कि यदि यह अंकों के दो सबसे पहले दिखावे के लिए गैर-लालची मिलान का उपयोग करते समय विफल हो गया, तो यह फिर से अंक के साथ .मेल खाते हुए वापस रोल करेगा और फिर से प्रयास करेगा। जब हमारा अंक 1. होता है, तो यह 111 मैच की तरह संख्या बना देगा। इसलिए, हम ?>मैच को परमाणु बनाने के लिए उपयोग करते हैं, अनिवार्य रूप से इस मूल्य से मिलान करने से पहले regex को पीछे जाने से रोकते हैं। एक एटॉमिक मैच कुछ खास तरह के फ्लेवरों की तरह काम करता है। चूंकि *मेटा-चरित्र एक के बाद आता है वर्ण से मेल खाने लगेगा जब तक यह मैच के लिए क्या हम में संग्रहीत में सक्षम है । फिर एक बार जब हम दो बार ऐसा करते हैं, तो नियमित अभिव्यक्ति की "मेमोरी" नष्ट हो जाती है, जो सामान्य रूप से होने वाले व्यवहार को रोकती है, जहां वह जाती है और जाती है?.\1.एक अतिरिक्त चरित्र, हमारे \1अंक का मिलान करें, जो अमान्य मिलान बनाएगा।

फिर, हम जाँचते हैं कि अंतिम स्थिति से, इनपुट अंक के दो के दोहराए गए समूहों के मिलान के बाद, कि हम दूसरे इनपुट अंक से मेल नहीं खा सकते हैं।

.,
<empty>

यहां हम प्रत्येक स्ट्रिंग्स से केवल अंक और अल्पविराम को हटा रहे हैं, इसलिए हमें बस अपना अच्छा उत्तर मिलेगा।

— FryAmTheEggman
स्रोत

कृपया एक स्पष्टीकरण जोड़ें।

— mbomb007

@ mbomb007 ठीक है, कहा :)

— FryAmTheEggman

परमाणु मिलान एक ऐसी चीज़ है जो मुझे अभी तक समझ में नहीं आई है।

— mbomb007

@ mbomb007 मैंने स्पष्ट करने का प्रयास किया है कि क्या चल रहा है, मुझे बताएं कि क्या कुछ स्पष्ट नहीं है।

— FryAmTheEggman

1

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

lambda d,n:[i for i in range(1,n+1)if`i`.count(d)%2<1]

प्रयोग

>>> (lambda d,n:[i for i in range(1,n+1)if`i`.count(d)%2<1])('1', 12)
[2, 3, 4, 5, 6, 7, 8, 9, 11]

— Zach गेट्स
स्रोत

1

जूलिया, 44 बाइट्स

f(n,d)=filter(i->sum(d.==digits(i))%2<1,1:n)

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और एक सरणी देता है।

हम पूर्णांक से पूर्णांक के सेट से शुरू करते हैं n, समावेशी। प्रत्येक पूर्णांक के लिए i, हम यह निर्धारित करते हैं कि उसका कौन सा दशमलव अंक बराबर है d, जो एक बूलियन सरणी देता है। हम sumअंक के dरूप में होने वाली घटनाओं की संख्या iऔर filterमूल समता के आधार पर मूल सीमा प्राप्त करते हैं।

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

— एलेक्स ए।
स्रोत

1

गंभीरता से, 17 बाइट्स

╩╜R;`$╛@c2@%Y`M@░

n\n'd'(पूर्णांक, न्यूलाइन, स्ट्रिंग) के रूप में इनपुट लेता है ।

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

स्पष्टीकरण:

╩╜R;`$╛@c2@%Y`M@░
╩                  push all inputs to registers
 ╜R;               push two copies of range(1, n+1)
    `        `M    map:
     $╛@c            count the number of d's
         2@%Y        modulo 2, logical not (1 if even, 0 if odd)
               @░  filter: take only the values of range(1, n+1) where the count is even

— मेगो
स्रोत

1

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

Select[a=#2;Range@#,2∣DigitCount[#,10,a]&]&

बिल्ट-इन का उपयोग करता है DigitCount।

— LegionMammal978
स्रोत

1

जाप, 13 12 बाइट्स

Uò1 f_s èV v

इनपुट n है , फिर d को कोट में लपेटा गया है। इसे ऑनलाइन टेस्ट करें!

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

       // Implicit: U = input integer, V = input string
Uò1    // Create the inclusive range [1..U].
f_     // Filter to only the items Z that return truthily to this function:
s èV   //  Take Z.toString(), then count the number of matches of V.
v      //  Return 1 (truthy) if even, 0 (falsy) otherwise.
       // Implicit output, array separated by commas

— ETHproductions
स्रोत

1

CJam, 38 बाइट्स

r:P;r~1+,0-_{s{s}%Pe=2%!}%]z{~{}{;}?}%

व्याख्या

r:P;                                    e# set input d to variable P
    r~1+,0-                             e# create a range(1, n+1)
           _{s{s}%Pe=2%!}%              e# determine which numbers are needed
                          ]z{~{}{;}?}%  e# remove extra numbers

— Zach गेट्स
स्रोत

1

स्काला, 66 बाइट्स

(d:Int,n:Int)=>(1 to n).map(""+).filter(_.count((""+d)(0)==)%2==0)

— याकूब
स्रोत

1

आर, 145 बाइट्स (मुझे यकीन है कि आगे इसे छोटा करने के तरीके हैं) :)

g<-sapply(sprintf("%s",seq(1:111)),function(z){if(sapply(regmatches(z,gregexpr("0",z)),length)%%2==0){z}else{NULL}})
names(g[!sapply(g,is.null)])

— जेफ मैं
स्रोत

मुझे कभी ओछे मत कहो

इनपुट

उत्पादन

उदाहरण

धन्यवाद

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

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

05AB1E , 11 10 बाइट्स

हास्केल, 69 63 52 50 बाइट्स

Befunge, 1080 945 बाइट्स

स्पष्टीकरण पर प्रयास करें:

अजगर 2, 50 बाइट्स

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

लूआ, 86 बाइट्स

जावास्क्रिप्ट (ईएस 6) 64

MATL , 12 10 बाइट्स

रूबी, 47 42 बाइट्स

पॉवरशेल, 62 55

रेटिना , 99 105 बाइट्स

पुराने संस्करण की टिप्पणी की व्याख्या

बैश + जीएनयू उपयोगिताओं, 37

पायथन 3.4, 92 85 79 85 बाइट्स

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

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

व्याख्या

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

पर्ल, 28 29 31 बाइट्स

ओरेकल SQL 11.2, 111 82 बाइट्स

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

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

रेटिना, 72 71 55

स्पष्टीकरण:

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

प्रयोग

जूलिया, 44 बाइट्स

गंभीरता से, 17 बाइट्स

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

जाप, 13 12 बाइट्स

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

CJam, 38 बाइट्स

व्याख्या

स्काला, 66 बाइट्स

आर, 145 बाइट्स (मुझे यकीन है कि आगे इसे छोटा करने के तरीके हैं) :)