Giriş

Bir tamsayı n (≥ 1) ve bir rakam d (0 ≤ d  ≤ 9 gibi bir tam sayı  ).

Her iki sırada da; stdin veya parametrelerden veya her neyse; bir program veya fonksiyon için; vb.

Çıktı

Ondalık gösterimleri çift sayıları ds olan 1 - n kapsayıcı tamsayılar (sırasıyla) . (Yani, listedeki tamsayılardır, sırasıyla bir çift sayıda tamsayı d s).

Herhangi bir standart formatta, vs. Özellikle, çıktının ondalık biçimde gösterilmesi gerekmez.

Tek bir dizge olarak çıktı verilirse, tamsayılar bir şekilde ayrılmalıdır (boşluklar, virgüller, yeni satırlar, boş baytlar, ne olursa olsun).

Örnekler

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

Teşekkürler

Başlık için kintopia .

Jöle, 7 bayt

RDċ€Ḃ¬T

Çevrimiçi deneyin!

Nasıl çalışır

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.

05AB1E , 11 10 bayt

Kod:

\>GN¹¢ÈiN,

Açıklama:

\           # 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

Çevrimiçi deneyin

CP-1252 kodlamasını kullanır .

Haskell, 69 63 52 50 bayt

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

Buraya ilk gönderdiğim için basit çözüm. Sayısını showsaymak için kullanılır d. Ben açıkça kullanmıyordu Chariçin girdi olarak dkaydedilmiş olurdu, 12 6 (Damien düzenleme sonrasında) bayt.

EDIT: 11 bayt Damien sayesinde daha az! 2 EDIT: nimi sayesinde 2 bayt daha az!

Befunge, 1080 945 bayt

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^

Puan, yeni satırlar da dahil olmak üzere, karenin tamamını sayarsak, mantıklı geliyor. Kodu kopyalayıp yorumlayıcıya yapıştırabilirsiniz . Önce d ve sonra n olmak üzere iki giriş sağlayın . Bu çözüm n > 999'dan büyük değerler için çalışmaz .

Belli ki bu büyük ödül için yarışmacı olmayacak, ama bir süredir Befunge'de bir kodlayıcı uygulamak istiyordum, bu yüzden sadece yapmaya karar verdim. Bunun, Befunge'de yaptığım ilk gerçek şey olduğu için optimal bir Befunge çözümüne bile yakın olmayacağını düşünüyorum. Bu nedenle, ipuçları açıktır, açıklamaya veya daha fazla bilgiye ihtiyacınız olursa, lütfen yorumlarda bana bildirin.

Açıklama girişimi:

Aşağıya doğru ilk sütunda girdiden bir tamsayı okuduk, buna karşılık gelen ASCII değerine dönüştürmek için 48'i (6 * 8, bunu daha sık göreceksin) ekledik (10, 0).

& - girişi oku

68*+ - 48 ekle

55+0p - değeri (10, 0)

O Not dat (1, 0)sadece yığın numarasını 100 almak için kolay bir yoldur.

Ondan sonra doğuya gidiyoruz ve başka bir tam sayı okuyor ve ASCIIfier dediğim şeye bakıyoruz. Bu, geçerli sayıyı bir dizi ASCII karakterine dönüştürür. ASCIIfier (13, 12)to dan dikdörtgen bir parçadır (26, 17). İlk hunderds sayarak ve onlarca altında ve en üç basamaklı içine koyarak, iki halkadan (6, 0)ve (5, 0). Bundan sonra son rakam girilir (4, 0). Yani sayılar aslında tersidir.

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)

Geçerli tamsayıyı bir dizi ASCII karakterine yerleştirdikten sonra, önceden belirlenmiş sıfırları kaldırmak için biraz daha güneye gideriz. Böylece, daha sonra, başlangıçta en üstte üç sıfır olan, önceden belirlenmiş sıfır olmadan geçerli sayı olacaktır.

Sonra, kuzeye gidene kadar geriye gideceğiz, üç basamağı yığına koyduk. (1, 1)Geçerli hanenin d girişine karşılık gelmesi durumunda bulunan sayacı artırarak her seferinde üst döngüdeki üç basamağın üzerinde yineleniriz.

Bu yapıldığında, gidip bulunan sayacın (1, 1)tek mi, yoksa çift mi olduğunu kontrol ederiz . Eşitse, geçerli sayıyı çıkarıp, mevcut değeri azaltmak ve yeniden başlamak için büyük dış döngüye geçiyoruz.

Python 2,50 bayt

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

Rakamı ddize, üst rakamı sayı olarak alan özyinelemeli bir işlev n.

Basamak arasında sayımı d'ın in nbile verir' s bit tamamlayıcı modulo 2, alarak olmak üzere test edilir 1için bile ve 0tek için. Bu birçok kişi nlisteye ekleniyor ve bu fonksiyon n-1boş listedeki mantıksal kısa devre üzerinden durduğunda tekrarlanıyor n==0.

Çıktı azalan sırada verilebilirse, 49 bayt için bir bayt kaydedilebilir:

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

Eski 51 baytlık çözüm:

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

Rakamı ddize , üstünü sayı olarak alan adsız bir işlev n.

İki numara kullanılır:

• Python's rangesıfır dizinli olduğundan 0...n-1, her potansiyel değere bir tane ekleriz x. Ardından, saymak diçinde s' x+1onun olumsuzlamasıydı kullanmak için bir karakter kazandırır, ~xbunun yerine.
• Eşit değerleri filtrelemek için ~_%2, önce pariteyi değiştirmek için ilk biti çeviren , sonra son biti &1( %2burada olduğu gibi ) alan, sadece orijinal bile olsa bir gerçek değer üreten, yaparız.

Pyth, 10 bayt

f!%/`Tz2SE

Çevrimiçi deneyin. Test odası.

Lua, 86 Bayt

Tutarsız ayırıcı kullanılarak izin verilirse, ben yerini alabilecek io.writetarafından printnumaralar biri veya birden satırbaşıyla ayrılmış olacağını yani.

Bu böyle adlandırılan lazım tam programıdır: lua file.lua d n.

dKarakterin dışındaki tüm karakterleri geçerli sayıdan kaldırır ve çıktısı alınup alınmamasına karar vermek için sonuç dizgesinin boyutunu kullanır.

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

JavaScript (ES6) 64

Konsol çıkışlı anonim bir işlev. splitBasamakları saymak için kullanarak basit bir uygulama .

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

Çıktı alertkullanımı 6 bayt daha az olurdu, ama gerçekten hoşuma gitmedi (ve yine de oyuncak dillerini yenmeyeceğim)

MATL , 12 10 bayt

:!V!=s2\~f

İlk giriş n , ikincisi bir dize olarak d . Örneğin:

12
'1'

Çevrimiçi deneyin!

:       % 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

Ruby, 47 42 bayt

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

İle çalıştırın d ve n komut satırı parametreleri, örneğin olarak

ruby golf.rb 1 12

PowerShell, 62 55

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

düzenleme: Bu durumda bir param blok kullanarak daha kısadır. gereksiz alan kaldırıldı

Golf dili değil ama gerçekten bildiğim tek dil. Bu, senaryo olarak kaydedilen ve buna benzer bir şey olarak işe yarar M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. İlk argüman d rakamı , ikincisi n tamsayısıdır .

1 ile n arasında bir sayı oluşturun . Bunların her biri için onu bir karakter dizisine dönüştürün. 10, 1,0 olur. -matchDizi operatörü olarak kullanıldığında , d rakamıyla eşleşen tüm öğeleri döndürün . Döndürülen öğelerin miktarını say ve sonucu mod 2 olarak değiştir. Sonuç çift için 0, tek sayı için 1 olacaktır. Bir boole olarak 0 yanlıştır, bu yüzden !döngü yanlış sonuçları ve hatta gerçek sonuçları doğru olarak değerlendirmek için döngü için kullanırız .

Çıkış, konsolda sınırlandırılmış yeni bir satırdır.

Retina , 99 105 bayt

Sondaki boşluklara dikkat edin. <empty>boş bir çizgiyi temsil eder.

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

Gibi girdi alır 1 12. Çıktı azalan düzende ayrılmış alandır.

0*1(0|10*1)*Sayıdaki tek sayı ile eşleşecek şekilde değiştirdim \1. Değiştim 0için (?!\1)\dve 1için \1yukarıda gördüğünüz uzun regex hattını oluşturmak için. Bağlantılı regex'in nasıl çalıştığını anlamak çok önemlidir.

Çevrimiçi deneyin

Eski versiyonun yorumlanması

Eğer azalan sipariş tamamsa

\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>

Bash + GNU yardımcı programları, 37

• @Ruud sayesinde 1 bayt kaydedildi.

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

Python 3.4, 92 85 79 85 bayt

Mego sayesinde 7 byte kurtarıldı
kurtarıldı mbomb007 sayesinde 6 byte daha kaydedildi Python 3.x sayesinde bu 6 byte yeniden kazanıldı

Bu benim golf kodundaki ilk şansım, işte hiçbir şey yok!

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]

Perl 6, 38 bayt

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

Brachylog , 32 bayt

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

N'yi girdi, basamağı rakam gibi bekler. brachylog_main(12,1).

açıklama

: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)

Mathematica, 54 bayt

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

Perl, 28 29 31 bayt

İçin +2 içerir -an

Spesifikasyon rakamıyla çalıştırın ve STDIN'deki ardışık satırları sayın:

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

Oracle SQL 11.2, 111 82 bayt

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

Kotlin, 136 bayt

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]))

Tamamen işlevsel bir program olarak, argümanları alır: nd

Çevrimiçi deneyin!

Java 8, 84 bayt

Bu, a için bir lambda ifadesidir BiConsumer< Integer, Integer>:

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

Açıklama:

1 ile n arasındaki her sayı için, sayıyı bir dizgeye dönüştürün ve sınırlayıcı olarak d kullanarak bölün. Tek sayıda bölüme bölünmüşse, sayıyı ve ardından yeni bir satır yazdırın.

Retina, 72 71 55

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

Kazayla atomik eşleşme grupları hatırlattığını söyleyen Martin'e çok teşekkürler!

Çevrimiçi deneyin!

Açıklama:

\d+$
$*

Sayıyı yerine, ancak rakamı yerine, eşdeğer değeriyle değiştirin.

\B
¶$`

\BSözcük sınırı olmayan her konumla (sıfır genişlik) eşleşir. Bunun aşağıdakilerden hiçbiriyle eşleşmeyeceğini unutmayın: dizenin başlangıcı, dizenin sonu veya virgül karakterinin etrafındaki herhangi bir konum. Bu sınır olmayanların her biri daha sonra yeni bir satırla ve daha sonra eşleştirmeden önce gelen dize ( $`) ile değiştirilir. Bu gibi bir liste verir:

d,1
d,11
d,111

dTek bir ondalık basamak nerede .

1+
$.0

Bu, tüm 1s listelerini uzunluklarının ondalık gösterimine dönüştürür. Bu uygun bir şekilde 1virgülün önüne geçebilecek olanı etkilemeyecektir, çünkü her zaman 1olduğu gibi.

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

Burada, Ggrep modunu açar; bu, regex ile eşleşen satırların tutulduğu ve diğer satırların atıldığı anlamına gelir. Bu regex karmaşıktır, ancak esasen baştaki basamağın 2'sinin gruplarıyla eşleşir (yakalama grubu 1'de saklanır, bu nedenle referans verebiliriz \1).

Buradaki anahtar, açgözlü olmayan eşleşmeyi, basamağın en eski iki görünümüne kadar kullanırken başarısız olursa, daha sonra geriye doğru yuvarlanıp tekrar denemeyi .başarmasıdır. Bu, rakamımız 1 olduğunda 111 gibi rakamlar yapacaktır. Bu nedenle, ?>eşleşmeyi atomik yapmak için kullanıyoruz , esasen regex'in bu değer ile eşleşmeden önceki izini geri almasını engelliyoruz. Atomik bir eşleşme , bazı lezzetlerde eşleşecek şekilde sahiplenmeye benzer . Yana *meta karakteri izlemektedir biz saklanan eşleşmesi mümkün olana kadar karakter maç olacak . Sonra bunu iki kez yaptığımızda, normal ifadenin "hafızası" tahrip olur, normalde meydana gelen davranışı engeller, geri gider ve burada?.\1.\1geçersiz bir eşleşme yaratacak olan rakamımız olan ek bir karakterle eşleşin.

Ardından, son konumdan giriş hanesinin iki tanesinin tekrar eden gruplarını eşledikten sonra başka bir giriş hanesiyle eşleşmediğimizi kontrol ederiz.

.,
<empty>

Burada sadece dizelerin her birinden rakam ve virgülleri kaldırıyoruz, bu yüzden sadece iyi cevabımızı alıyoruz.

Python 2, 57 54 bayt

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

kullanım

>>> (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]

Julia, 44 bayt

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

Bu, iki tam sayı kabul eden ve bir dizi döndüren bir işlevdir.

1'den 1'e kadar olan tamsayılarla başlıyoruz n. Her tamsayı için i, ondalık basamaklarından dhangisinin eşittir , hangisinin bir Boolean dizisi oluşturduğunu belirleriz. Biz sumbu olay sayısını almak için dbir basamak olarak ive filtertoplamının parite dayalı orijinal aralık.

Burada dene

Cidden, 17 bayt

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

Girdileri n\n'd'(integer, newline, string) alır.

Çevrimiçi deneyin!

Açıklama:

╩╜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

Mathematica, 45 bayt

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

Yerleşik kullanır DigitCount.

Japt, 13 12 bayt

Uò1 f_s èV v

Giriş n , sonra d tırnak içinde sarılır. Çevrimiçi test edin!

Nasıl çalışır

       // 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

CJam, 38 bayt

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

açıklama

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

Scala, 66 bayt

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

R, 145 bayt (Bunu daha da kısaltmanın yolları olduğuna eminim) :)

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)])