คำศัพท์

ตัวเลขที่เพิ่มขึ้นคือตัวเลขที่แต่ละหลักมากกว่าหรือเท่ากับตัวเลขทั้งหมดทางด้านซ้ายของมัน (เช่น 12239)

ตัวเลขที่ลดลงคือตัวเลขที่แต่ละหลักน้อยกว่าหรือเท่ากับตัวเลขทั้งหมดทางด้านซ้ายของมัน (เช่น 95531)

หมายเลขเด้งคือหมายเลขใด ๆ ที่ไม่เพิ่มขึ้นหรือลดลง เนื่องจากต้องมีตัวเลขอย่างน้อย 3 ตัวหมายเลขเด้งตัวแรกคือ 101

งาน

รับจำนวนเต็ม n มากกว่าหรือเท่ากับ 1 ให้หาผลรวมของตัวเลข bouncy แรก

กฎระเบียบ

• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดคือจำนวนไบต์ที่ชนะ
• หากภาษาของคุณมีข้อ จำกัด เกี่ยวกับขนาดจำนวนเต็ม (เช่น 2 ^ 32-1) n จะมีขนาดเล็กพอที่ผลรวมจะพอดีกับจำนวนเต็ม
• อินพุตอาจเป็นรูปแบบที่สมเหตุสมผล (stdin, ไฟล์, พารามิเตอร์บรรทัดคำสั่ง, จำนวนเต็ม, สตริง, ฯลฯ )
• เอาต์พุตสามารถเป็นรูปแบบที่สมเหตุสมผลใด ๆ (stdout, ไฟล์, องค์ประกอบผู้ใช้แบบกราฟิกที่แสดงหมายเลข ฯลฯ )

กรณีทดสอบ

1 > 101
10 > 1065
44701 > 1096472981

เยลลี่ , 10 8 ไบต์

ṢeṚƬ¬µ#S

ลองออนไลน์!

มันทำงานอย่างไร

ṢeṚƬ¬µ#S  Main link. No arguments.

      #   Read an integer n from STDIN and call the chain to the left with argument
          k = 0, 1, 2, ... until n of them return a truthy result.
          Yield the array of successful values of k.
     µ    Monadic chain. Argument: k (integer)
Ṣ           Sort, after promoting k to its digit array.
  ṚƬ        Reverse 'til the results are no longer unique and yield unique results.
            Calling Ṛ on k promotes it to its digit array. If k = 14235, the 
            result is [14235, [5,3,2,4,1], [1,4,2,3,5]].
 e          Check if the result to the left appears in the result to the right.
    ¬       Negate the resulting Boolean.
       S  Take the sum.

Pyth , 10 ไบต์

s.f!SI#_B`

ลองที่นี่!

มันทำงานอย่างไร?

sf! SI # _B` - โปรแกรมเต็มรูปแบบ ใช้จำนวนเต็ม Q จาก STDIN และส่งออกไปยัง STDOUT
 .f - ค้นหาเลขจำนวนเต็มบวก Q ตัวแรกที่ตรงตามเงื่อนไขที่กำหนด
   ! SI # _B - เงื่อนไข ผลตอบแทนจริงสำหรับตัวเลขเด้งเท่านั้น
       _B` - ส่งตัวเลขไปยังสตริงและแยกไปสองทางด้วยการย้อนกลับ
      # - ตัวกรอง - เก็บสิ่งเหล่านั้น ...
     I - มันคงที่ ...
    S - การเรียงลำดับ
           - เพื่อชี้แจงฉัน (คงที่) เป็นผู้ประกอบการ Pyth ที่ใช้เวลาสองอินพุต 
             function และค่าและตรวจสอบว่า function (value) == value ดังนั้น
             เทคนิคนี้ไม่ใช่ในตัว
   ! - ตรรกะไม่ รายการที่ว่างเปล่าจะถูกแมปเป็นจริงค่าอื่นเป็นเท็จ
s - ผลรวม

K (ngn / k) , 37 ไบต์

{+/x{{(a~&\a)|a~|\a:10\x}(1+)/x+1}\0}

ลองออนไลน์!

{ } เป็นฟังก์ชั่นที่มีข้อโต้แย้ง x

x{ }\0นำไปใช้{}ใน0 xครั้งที่รักษาผลกลาง

(1+) ฟังก์ชั่นเป็นตัวตายตัวแทน

{ }(1+)/x+1ใช้ฟังก์ชันตัวตายตัวแทนเริ่มต้นจากx+1จนกว่า{}ผลตอบแทนที่แท้จริง

10\x เป็นตัวเลขทศนิยมของ x

a: มอบหมายให้ a

|\ คือ max-scan (maxima บางส่วน) ของ a

&\ อะนาล็อกเป็นนาทีสแกน

a~|\aไม่aตรงกับการสแกนสูงสุดของมัน?

| หรือ

a~&\a มันสแกนนาที?

+/ รวม

JavaScript (ES6), 77 ไบต์

f=(i,n=0,k,p)=>i&&([...n+''].map(x=>k|=x<p|2*(p<(p=x)))|k>2&&i--&&n)+f(i,n+1)

ลองออนไลน์!

แสดงความคิดเห็น

f = (                     // f = recursive function taking:
  i,                      //   i = number of bouncy numbers to find
  n = 0,                  //   n = current value
  k,                      //   k = bitmask to flag increasing/decreasing sequences
  p                       //   p = previous value while iterating over the digits
) =>                      //
  i && (                  // if there's still at least one number to find:
    [...n + '']           //   turn n into a string and split it
    .map(x =>             //   for each digit x in n:
      k |=                //     update k:
        x < p |           //       set bit #0 if x is less than the previous digit
        2 * (p < (p = x)) //       set bit #1 if x is greater than the previous digit
                          //       and update p
    )                     //   end of map()
    | k > 2               //   if both bits are set (n is bouncy):
    && i--                //     decrement i
    && n                  //     and add n to the total
  ) + f(i, n + 1)         //   add the result of a recursive call with n + 1

Python 2, 110 92 89 ไบต์

n=input()
x=s=0
while n:b={-1,1}<=set(map(cmp,`x`[:-1],`x`[1:]));s+=x*b;n-=b;x+=1
print s

ลองออนไลน์

ฟังก์ชั่นนี้จะกำหนดว่าหมายเลขใดเป็นเด้งหรือไม่:

lambda x:{-1,1}<=set(map(cmp,`x`[:-1],`x`[1:]))

Python 2 , 84 ไบต์

i=s=0
n=input()
while n:b=`i`>`sorted(`i`)`[2::5]<`i`[::-1];n-=b;s+=b*i;i+=1
print s

ลองออนไลน์! หรือดูการทดสอบในตัว

เรติน่า , 93 ไบต์

K`:
"$+"{/(?=.*;(_*);\1_)(?=.*_(_*);\2;)/^{`:(#*).*
:$1#;$.($1#
)`\d
*_;
)`:(#+).*
$1:$1
\G#

ลองออนไลน์! คำอธิบาย:

K`:

s=i=0initialise ( sคือจำนวน#s ก่อนหน้า:, iจำนวน#s หลัง)

"$+"{
...
)`

ทำซ้ำnครั้ง

/(?=.*;(_*);\1_)(?=.*_(_*);\2;)/^{`
...
)`

ทำซ้ำในขณะที่iไม่เด้ง

:(#*).*
:$1#;$.($1#

เพิ่มiและทำสำเนาเป็นทศนิยม

\d
*_;

แปลงตัวเลขของการคัดลอกเป็นเอก การทดสอบ bounciness ใช้สำเนา unary ดังนั้นมันจะทำงานได้เพียงครั้งเดียวที่iเพิ่มขึ้นอย่างน้อยหนึ่งครั้ง

:(#+).*
$1:$1

เพิ่มiไปsและลบสำเนาของตัวเลขเอกเพื่อให้สำหรับการส่งผ่านต่อไปของวงชั้นในการทดสอบ bounciness ล้มเหลวและiได้รับการเพิ่มขึ้นอย่างน้อยหนึ่งครั้ง

\G#

แปลงsเป็นทศนิยม

รุ่น 121 ไบต์คำนวณเป็นทศนิยมดังนั้นอาจใช้กับค่าที่มากขึ้นของn:

K`0:0
"$+"{/(?=.*;(_*);\1_)(?=.*_(_*);\2;)/^{`:(\d+).*
:$.($1*__);$.($1*__)
)+`;\d
;$&*_;
)`\d+:(\d+).*
$.(*_$1*):$1
:.*

ลองออนไลน์! คำอธิบาย:

K`0:0

s=i=0initialise

"$+"{
...
)`

ทำซ้ำnครั้ง

/(?=.*;(_*);\1_)(?=.*_(_*);\2;)/^{`
...
)

ทำซ้ำในขณะที่iไม่เด้ง

:(\d+).*
:$.($1*__);$.($1*__)

เพิ่มiและทำสำเนา

+`;\d
;$&*_;

แปลงตัวเลขของการคัดลอกเป็นเอก การทดสอบ bounciness ใช้สำเนา unary ดังนั้นมันจะทำงานได้เพียงครั้งเดียวที่iเพิ่มขึ้นอย่างน้อยหนึ่งครั้ง

\d+:(\d+).*
$.(*_$1*):$1

เพิ่มiไปsและลบสำเนาของตัวเลขเอกเพื่อให้สำหรับการส่งผ่านต่อไปของวงชั้นในการทดสอบ bounciness ล้มเหลวและiได้รับการเพิ่มขึ้นอย่างน้อยหนึ่งครั้ง

:.*

iลบ

05AB1E , 12 ไบต์

µN{‚Nå_iNO¼

ลองออนไลน์!

คำอธิบาย

µ              # loop over increasing N until counter equals input
     Nå_i      # if N is not in
 N{‚          # the pair of N sorted and N sorted and reversed
         NO    # sum N with the rest of the stack
           ¼   # and increment the counter

Java 8, 114 112 ไบต์

n->{int i=0,s=0;for(;n>0;++i)s+=(""+i).matches("0*1*2*3*4*5*6*7*8*9*|9*8*7*6*5*4*3*2*1*0*")?0:--n*0+i;return s;}

ใช้นิพจน์ทั่วไปเพื่อตรวจสอบว่าจำนวนนั้นเพิ่มขึ้นหรือลดลง ลองออนไลน์ได้ที่นี่

Ungolfed:

n -> { // lambda
    int i = 0, // the next number to check for bounciness
        s = 0; // the sum of all bouncy numbers so far
    for(; n > 0; ++i) // iterate until we have summed n bouncy numbers, check a new number each iteration
        s += ("" + i) // convert to a String
             .matches("0*1*2*3*4*5*6*7*8*9*" // if it's not an increasing  number ...
             + "|9*8*7*6*5*4*3*2*1*0*") ? 0 // ... and it's not a decreasing number ...
             : --n*0 // ... we have found another bouncy number ...
               + i; // ... add it to the total.
    return s; // return the sum
}

Python 2, 250 ไบต์

n=input()
a=0
b=0
s=0
while a<n:
    v=str(b)
    h=len(v)
    g=[int(v[f])-int(v[0]) for f in range(1,h) if v[f]>=v[f-1]]
    d=[int(v[f])-int(v[0]) for f in range(1,h) if v[f]<=v[f-1]]
    if len(g)!=h-1 and len(d)!=h-1:
       a+=1
       s+=b
    b+=1
print s

Stax , 14 ไบต์

Ö²àDæ▲☼Ty≡°lû↕

เรียกใช้และแก้ไขข้อบกพร่อง

สีแดง 108 ไบต์

func[n][i: s: 0 until[t: form i
if(t > u: sort copy t)and(t < reverse u)[s: s + i n: n - 1]i: i + 1
0 = n]s]

ลองออนไลน์!

อ่านเพิ่มเติมได้:

f: func [ n ] [
    i: s: 0
    until [
       t: form i  
       if ( t > u: sort copy t ) and ( t < reverse u ) [
            s: s + i
            n: n - 1
       ]
       i: i + 1
       0 = n
    ]
    s
]

โอกาสที่ดีในการใช้form- form iสั้นกว่า 5 ไบต์to-string i

MATL , 31 30 ไบต์

l9`tVdZS&*0<a?wQtG>?.]y]QT]xvs

ลองออนไลน์!

l       % Initialize counter to 1
9       % First value to check for being bouncy
`       % Start do-while loop
  tV    % duplicate the current number and convert to string
        % (let's use the iteration where the number is 1411)
        % stack: [1, 1411, '1411']
  d     % compute differences between the characters
        %  For non-bouncy numbers, this would be either all 
        %  positive values and 0, or all negative values and 0
        % stack: [1, 1411, [3 -3 0]]
  ZS    % keep only the signs of those differences
        % stack: [1, 1411, [1 -1 0]]
  &*    % multiply that array by its own transpose, so that
        %  each value is multiplied by every other value
        %  for non-bouncy numbers, all products will be >=0
        %  since it would have had only all -1s or all 1 (other than 0s)
        % stack: [1, 1411, [1 -1  0
                            -1  1 0
                            0  0  0]]
  0<a?  % if any value in the matrix is less than 0
    wQ    % switch the counter to top, increment it
          % stack: [1411, 2]
    tG>?  % duplicate it, check if it's gotten greater than the input limit
      .]    % if so, break out of loop
  y]    % else, duplicate bouncy number from inside stack,
        %  keeping a copy to be used for summing later
        % stack: [1411, 2, 1411]
  QT    % increment number, push True to continue loop
]     % loop end marker
x     % if we've broken out of loop, remove counter from stack
v     % concatenate the bouncy numbers we've collected in stack and 
s     % sum them

R , 96 ไบต์

function(n){while(n){y=diff(T%/%10^(0:log10(T))%%10);g=any(y<0)&any(y>0);F=F+T*g;n=n-g;T=T+1};F}

ลองออนไลน์!

คำอธิบาย:

while(n){                         # while n > 0

        T%/%10^(0:log10(T))%%10   # split T into digits(T==TRUE==1 at the 1st loop)
y=diff(                         ) # compute the diff of digits i.e. digits[i] - digits[i+1]

g=any(y<0)&any(y>0)               # if at least one of the diff is < 0 and 
                                  # at least one is > 0 then T is "bouncy"

F=F+T*g                           # if bouncy increment F (F==FALSE==0 at the 1st loop)

n=n-g                             # decrement n by 1 if bouncy

T=T+1}                            # increment T by 1 and loop

F}                                # return F

ทับทิม (123 ไบต์)

o=0
x=["0"]
while n>0 do x=(x.join.to_i+1).to_s.split('')
(x.sort!=x&&x.sort!=x.reverse ? (n-=1;o+=x.join.to_i):'')
end
p o

ดูน่าเกลียดสำหรับฉัน Bounciness ถูกกำหนดในบล็อกนี้x.sort!=x&&x.sort!=x.reverse

Ruby , 76 ไบต์

->n,s=i=0{[d=(i+=1).digits,d.reverse].index(d.sort)||(s+=i;n-=1);n<1?s:redo}

ลองออนไลน์!

C (gcc), 104 ไบต์

f(b,o,u,n,c,y){for(o=u=0;b;u+=y?0:o+0*--b,++o)for(n=o,y=3;n/10;)c=n%10,n/=10,y&=(c-=n%10)<0?:c?2:y;b=u;}

ลองออนไลน์ได้ที่นี่

Ungolfed:

f(n, // function: return type and type of arguments defaults to int;
     // abusing extra arguments to declare variables
  i,   // number currently being checked for bounciness
  s,   // sum of the bouncy numbers
  j,   // copy of i to be used for checking bounciness in a loop
  p,   // used for investigating the last digit of j
  b) { // whether i is not bouncy; uses the two least significant bits to indicate increasing/decreasing
    for(i = s = 0; // check numbers from zero up; initial sum is zero
        n; // continue until we have n bouncy numbers
        s += b ? 0 // not bouncy, no change to the sum
        : i + 0* --n, // bouncy, add it to the sum and one less bouncy number to go
        ++i) // either way, move to the next number
        for(j = i, b = 3; j/10; ) // make a copy of the current number, and truncate it from the right until there is just one digit left
        // bounciness starts as 0b11, meaning both increasing and decreasing; a value of 0 means bouncy
            p = j % 10, // get the last digit
            j /= 10, // truncate one digit from the right
            b &= // adjust bounciness:
                 (p -= j % 10) // compare current digit to the next
                 < 0 ? // not an increasing number, clear second to least significant bit
                 : p ? 2 // not a decreasing number, clear least significant bit
                 : b; // keep it the same
    n = s; // gcc shortcut for return s
}