Thuật ngữ

Số tăng là một trong đó mỗi chữ số lớn hơn hoặc bằng tất cả các chữ số ở bên trái của nó (ví dụ 12239)

Một số giảm là một trong đó mỗi chữ số nhỏ hơn hoặc bằng tất cả các chữ số ở bên trái của nó (ví dụ: 95531)

Một số bouncy là bất kỳ số nào không tăng hoặc giảm. Vì điều này đòi hỏi ít nhất 3 chữ số, số nảy đầu tiên là 101

Nhiệm vụ

Cho số nguyên n lớn hơn hoặc bằng 1, tìm tổng của n số nảy đầu tiên

Quy tắc

• Đây là mã golf, vì vậy câu trả lời có số byte ngắn nhất sẽ thắng
• Nếu ngôn ngữ của bạn có giới hạn về kích thước số nguyên (ví dụ: 2 ^ 32-1) n sẽ đủ nhỏ để tổng sẽ khớp với số nguyên
• Đầu vào có thể là bất kỳ dạng hợp lý nào (stdin, tệp, tham số dòng lệnh, số nguyên, chuỗi, v.v.)
• Đầu ra có thể là bất kỳ hình thức hợp lý nào (thiết bị xuất chuẩn, tệp, phần tử người dùng đồ họa hiển thị số, v.v.)

Các trường hợp thử nghiệm

1 > 101
10 > 1065
44701 > 1096472981

Thạch , 10 8 byte

ṢeṚƬ¬µ#S

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṣ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.

Bình thường , 10 byte

s.f!SI#_B`

Hãy thử nó ở đây!

Làm thế nào nó hoạt động?

sf! SI # _B` - Chương trình đầy đủ. Lấy một số nguyên Q từ STDIN và xuất ra STDOUT.
 .f - Tìm số nguyên Q dương đầu tiên thỏa mãn một điều kiện nhất định.
   ! SI # _B - Điều kiện. Trả về đúng cho chỉ số bouncy.
       _B` - Truyền số vào một chuỗi và chia đôi (cặp) với số đảo ngược của nó.
      # - Lọc-giữ những ...
     Tôi - Đó là bất biến dưới ...
    S - Sắp xếp.
           - Để làm rõ, tôi (bất biến) là toán tử Pyth có hai đầu vào, một 
             hàm và một giá trị và kiểm tra xem hàm (value) == value, vì vậy
             về mặt kỹ thuật không phải là tích hợp.
   ! - Hợp lý không. Danh sách trống được ánh xạ thành true, các giá trị khác thành false.
s - Tổng.

K (ngn / k) , 37 byte

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

Hãy thử trực tuyến!

{ } là một hàm với đối số x

x{ }\0áp dụng {}đúng 0 xthời gian, bảo toàn kết quả trung gian

(1+) là chức năng kế nhiệm

{ }(1+)/x+1áp dụng hàm kế tiếp bắt đầu từ x+1khi {}trả về giá trị true

10\x là các chữ số thập phân của x

a: giao cho a

|\ là quét tối đa (cực đại một phần) của a

&\ tương tự, là quét tối thiểu

a~|\akhông aphù hợp với quét tối đa của nó?

| hoặc là

a~&\a quét tối thiểu của nó?

+/ tổng

JavaScript (ES6), 77 byte

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)

Hãy thử trực tuyến!

Đã bình luận

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 byte

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

Dùng thử trực tuyến

Hàm này xác định nếu một số bị dội lại:

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

Python 2 , 84 byte

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

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Võng mạc , 93 byte

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

Hãy thử trực tuyến! Giải trình:

K`:

Khởi tạo s=i=0. ( slà số #s trước :, isố #s sau.)

"$+"{
...
)`

Lặp lại nnhiều lần.

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

Lặp lại trong khi ikhông bouncy.

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

Tăng ivà tạo một bản sao ở dạng thập phân.

\d
*_;

Chuyển đổi các chữ số của bản sao để unary. Kiểm tra độ nảy sử dụng bản sao đơn nhất, vì vậy nó chỉ hoạt động một lần iđã được tăng ít nhất một lần.

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

Thêm ivào svà xóa bản sao của các chữ số đơn, để cho lần vượt qua tiếp theo của vòng lặp bên trong, bài kiểm tra độ nảy không thành công và iđược tăng ít nhất một lần.

\G#

Chuyển đổi sthành số thập phân.

Phiên bản 121 byte tính theo số thập phân, do đó có thể hoạt động với các giá trị lớn hơn của n:

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

Hãy thử trực tuyến! Giải trình:

K`0:0

Khởi tạo s=i=0.

"$+"{
...
)`

Lặp lại nnhiều lần.

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

Lặp lại trong khi ikhông bouncy.

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

Tăng ivà tạo một bản sao.

+`;\d
;$&*_;

Chuyển đổi các chữ số của bản sao để unary. Kiểm tra độ nảy sử dụng bản sao đơn nhất, vì vậy nó chỉ hoạt động một lần iđã được tăng ít nhất một lần.

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

Thêm ivào svà xóa bản sao của các chữ số đơn, để cho lần vượt qua tiếp theo của vòng lặp bên trong, bài kiểm tra độ nảy không thành công và iđược tăng ít nhất một lần.

:.*

Xóa i.

05AB1E , 12 byte

µN{‚Nå_iNO¼

Hãy thử trực tuyến!

Giải trình

µ              # 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 byte

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;}

Sử dụng một biểu thức chính quy để kiểm tra xem số lượng đang tăng hay giảm. Hãy thử trực tuyến tại đây .

Ung dung:

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 byte

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 byte

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

Chạy và gỡ lỗi nó

Màu đỏ , 108 byte

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]

Hãy thử trực tuyến!

Dễ đọc hơn:

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
]

Một cơ hội tốt để sử dụng form- form ingắn hơn 5 byte so vớito-string i

MATL , 31 30 byte

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

Hãy thử trực tuyến!

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 byte

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}

Hãy thử trực tuyến!

Giải trình :

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

Ruby (123 byte)

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

Trông tôi khá xấu xí. Bounciness được định nghĩa trong khối nàyx.sort!=x&&x.sort!=x.reverse

Ruby , 76 byte

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

Hãy thử trực tuyến!

C (gcc), 104 byte

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;}

Hãy thử trực tuyến tại đây .

Ung dung:

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
}