প্রথম এন বাউন্সি নাম্বারের যোগফলটি সন্ধান করুন

19

পরিভাষা

বর্ধমান সংখ্যা এমন এক যেখানে প্রতিটি অঙ্ক তার বাম দিকে সমস্ত সংখ্যার চেয়ে বড় বা সমান হয় (উদা। 12239)

একটি ক্রমহ্রাসমান একটি হ'ল যেখানে প্রতিটি অঙ্ক তার বাম দিকে সমস্ত সংখ্যার চেয়ে কম বা সমান (উদা। 95531)

বাউন্সি নম্বর এমন কোনও সংখ্যা যা বৃদ্ধি বা হ্রাস পাচ্ছে না। যেহেতু এটির জন্য কমপক্ষে 3 টি সংখ্যা প্রয়োজন, প্রথম বাউন্সি সংখ্যাটি 101 101

কাজটি

1 এর চেয়ে বড় বা সমান একটি পূর্ণসংখ্যা n দিয়ে দেওয়া, প্রথম এন বাউন্সি সংখ্যাগুলির যোগফলটি সন্ধান করুন

বিধি

  • এটি কোড গল্ফ, তাই বাইটের সংক্ষিপ্ত পরিমাণে জয়ের উত্তর
  • যদি আপনার ভাষার পূর্ণসংখ্যার আকারের সীমা থাকে (উদাহরণস্বরূপ 2 ^ 32-1) এন যথেষ্ট পরিমাণে হবে তবে যোগফলটি পূর্ণসংখ্যায় ফিট হবে
  • ইনপুট যে কোনও যুক্তিসঙ্গত ফর্ম (স্টিডিন, ফাইল, কমান্ড লাইন প্যারামিটার, পূর্ণসংখ্যা, স্ট্রিং ইত্যাদি) হতে পারে
  • আউটপুট যে কোনও যুক্তিসঙ্গত ফর্ম হতে পারে (স্টডআউট, ফাইল, গ্রাফিকাল ব্যবহারকারী উপাদান যা নম্বর প্রদর্শন করে ইত্যাদি)

পরীক্ষার মামলা

1 > 101
10 > 1065
44701 > 1096472981
code-golf  number 
— avern
সূত্র
3
আমি নিশ্চিত না যে আমি আপনার বিধিনিষেধগুলি বুঝতে পেরেছি। আমি sortকি নম্বরগুলি দেখতে পারি এবং সেগুলি কি মূল সংখ্যার সমান কিনা তা পরীক্ষা করতে পারি ? এটি একটি অন্তর্নির্মিত ( sort) ব্যবহার করছে, তবে এটি বাড়ছে কিনা তা পরীক্ষা করার জন্য কঠোরভাবে অন্তর্নির্মিত নয়। পরীক্ষা করে দেখুন অ পর্যবেক্ষণযোগ্য প্রোগ্রাম প্রয়োজনীয়তা এবং কি এক্স ওয়াই ছাড়া আমাদের "থিংস এড়াতে" মেটা পোস্টে।
— অ্যাডমবর্কবার্ক
5
হাই, পিপিসিজিতে আপনাকে স্বাগতম! যদিও এটি একটি দুর্দান্ত প্রথম পোস্ট (+1), আমার কয়েকটি ছোট পরামর্শ রয়েছে: কোনও সংখ্যা বাড়ছে কিনা তা যাচাই করে এমন কোনও বিল্টইন ব্যবহার করা যেতে পারে না , কোনও স্ট্রিং লেসিকোগ্রাফিকভাবে বাড়ছে কিনা তা যাচাই করে এমন কোনও বিল্টইন ব্যবহার করা যেতে পারে (বিল্ট-ইনগুলি বর্জন না করে) চ্যালেঞ্জ লেখার সময় এড়ানো একটি জিনিস ; আমাদের প্রস্তাবিত চ্যালেঞ্জগুলির জন্য একটি স্যান্ডবক্স রয়েছে , যেখানে প্রতিক্রিয়া এবং নির্দেশিকা গ্রহণের জন্য আপনি জমা দেওয়ার আগে আপনার পোস্ট ধারণাটি ভাগ করতে পারেন :)
— মিঃ এক্সকডার
আমি ভাল আপনি যে লিংক পোস্ট করা "ব্যতিক্রমসমূহ" বিভাগে মেলে বিধিনিষেধ আপডেট
— avern
4
আমি এখনও প্রথম স্থানে এই জাতীয় সীমাবদ্ধতা থাকার বিষয়টি দেখতে পাচ্ছি না। অবশ্যই এটি রাখা বা না করা আপনার পক্ষে, তবে বিল্ট-ইনগুলি নিষিদ্ধ করা সাধারণত খারাপ অভ্যাস। যদি আপনি মনে করেন যে চ্যালেঞ্জটি বিল্ট-ইনগুলি দ্বারা তুচ্ছ করা হয়েছে, আপনার মনে রাখা উচিত যে কেবল তাদের সীমাবদ্ধ করা টাস্কটি সমাধান করা আরও আকর্ষণীয় করে তোলে না, বরং বয়লারপ্লেট যুক্ত করে। আপনি কি এই সীমাবদ্ধতা অপসারণ বিবেচনা করতে পারেন? ( যাইহোক , এটি এখনও Y ছাড়াই ড এক্স এর অধীনে আসে ) অন্যথায়, আমি ধারণাটি বেশ পছন্দ করি এবং আমি আসল কাজ থেকে বিরত হওয়ার জন্য কিছুটা বিষয়গত বাধাও চাই না।
— মিঃ এক্সকোডার
10
তবে আমি এই বিধিনিষেধটি সরিয়েছি, কারণ এটি স্পষ্ট যে এটি সম্প্রদায়ের
— পক্ষে সেভাবে আরও উপভোগযোগ্য

উত্তর:

8

জেলি , 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.
— ডেনিস
সূত্র
4
+1 ṚƬঅত্যন্ত ঝরঝরে ...
— মিঃ এক্সকোডার
6

পাইথ , 10 বাইট

s.f!SI#_B`

এখানে চেষ্টা করুন!

কিভাবে এটা কাজ করে?

sf! এসআই # _বি` - সম্পূর্ণ প্রোগ্রাম। STDIN এবং আউটপুটগুলি STDOUT এ পূর্ণসংখ্যা Q নেয় Q
 .f - প্রথম কিউ ইতিবাচক পূর্ণসংখ্যার সন্ধান করুন যা একটি নির্দিষ্ট শর্ত পূরণ করে।
   এসআই # _ বি - অবস্থা। শুধুমাত্র বাউন্সি সংখ্যাগুলির জন্য সত্য ফেরায়।
       _বি` - একটি স্ট্রিংয়ের জন্য নম্বরটি কাস্ট করুন এবং বিপরীতে এটি দ্বিখণ্ডিত (জোড়া) করুন।
      # - এগুলি ফিল্টার রাখুন ...
     আমি - এগুলি হ'ল ...
    এস - বাছাই করা।
           - পরিষ্কার করার জন্য, আমি (আক্রমণকারী) একটি পাইথ অপারেটর যা দুটি ইনপুট নেয়, a 
             ফাংশন এবং একটি মান এবং ফাংশন (মান) == মান, তাই কিনা তা পরীক্ষা করে
             এটি প্রযুক্তিগতভাবে অন্তর্নির্মিত নয়।
   ! - যৌক্তিক না। খালি তালিকার মান সত্যায়িত হয়, অন্য মানগুলি মিথ্যা হয়।
s - যোগফল।
— মিঃ এক্সকোডার
সূত্র
4

কে (এনএনজি / কে) , 37 বাইট

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

এটি অনলাইন চেষ্টা করুন!

{ } যুক্তি সহ একটি ফাংশন x

x{ }\0মধ্যবর্তী ফলাফল সংরক্ষণ {}করে 0 xসময়ে প্রয়োগ করে app

(1+) উত্তরসূরি ফাংশন

{ }(1+)/x+1রিটার্নগুলি সত্য x+1হওয়া অবধি শুরু হওয়া উত্তরসূরি ফাংশন প্রয়োগ করে{}

10\x দশমিক সংখ্যা x

a: ধার্য a

|\ এর সর্বোচ্চ-স্ক্যান (আংশিক ম্যাক্সিমা) a

&\ অ্যানালগালি, মিনি স্ক্যান হয়

a~|\aনেই aতার সর্বোচ্চ-স্ক্যান মেলে?

| অথবা

a~&\a এর মিনি স্ক্যান?

+/ সমষ্টি

— ngn
সূত্র
4

জাভাস্ক্রিপ্ট (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
— Arnauld
সূত্র
3

পাইথন 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:]))
— mbomb007
সূত্র
আপনি অক্ষর সরাসরি তুলনা করতে পারেন। আসলে, আপনার সেট বোধগম্য হয়ে উঠতে পারে set(map(cmp,`x`[:-1],`x`[1:]))।
— Jakob
@ জাকব ধন্যবাদ আমি সর্বদা ভুলে যাই আপনি mapএইভাবে ব্যবহার করতে পারেন ।
— mbomb007
1
x=s=0\nwhile n:b={-1,1}<=set(map(cmp,`x`[:-1],`x`[1:]));s+=x*b;n-=b;x+=13 বাইট সাশ্রয় করেছেন
— মিঃ এক্সকোডার 21
3

রেটিনা , 93 বাইট

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

এটি অনলাইন চেষ্টা করুন! ব্যাখ্যা:

K`:

আরম্ভ করা s=i=0। ( sসংখ্যা #সামনে গুলি :, iসংখ্যা #পর গুলি।)

"$+"{
...
)`

একই পদ্ধতি পুনরাবৃত্তি করুন nবার।

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

iউদ্বিগ্ন না হয়ে পুনরাবৃত্তি করুন ।

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

iদশমিক দশমিক এক কপি বৃদ্ধি করুন make

\d
*_;

অনুলিপিটির অনুলিপিগুলি অকেরে রূপান্তর করুন। বাউন্সনেস টেস্টে অ্যানারি কপি ব্যবহার করা হয়, সুতরাং এটি কেবল একবারে কাজ করে iযা কমপক্ষে একবার বাড়ানো হয়েছে।

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

অ্যানারি ডিজিটগুলির অনুলিপি যোগ iকরুন sএবং মুছুন, যাতে অভ্যন্তরীণ লুপের পরবর্তী পাসের জন্য বাঁচানো পরীক্ষা ব্যর্থ হয় এবং iকমপক্ষে একবার বর্ধিত হয়।

\G#

sদশমিক রূপান্তর ।

121 বাইট সংস্করণ দশমিক গণনা করে, তাই এর বৃহত্তর মানগুলির জন্য কাজ করতে পারে n:

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

এটি অনলাইন চেষ্টা করুন! ব্যাখ্যা:

K`0:0

আরম্ভ করা s=i=0।

"$+"{
...
)`

একই পদ্ধতি পুনরাবৃত্তি করুন nবার।

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

iউদ্বিগ্ন না হয়ে পুনরাবৃত্তি করুন ।

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

বৃদ্ধি iএবং একটি অনুলিপি।

+`;\d
;$&*_;

অনুলিপিটির অনুলিপিগুলি অকেরে রূপান্তর করুন। বাউন্সনেস টেস্টে অ্যানারি কপি ব্যবহার করা হয়, সুতরাং এটি কেবল একবারে কাজ করে iযা কমপক্ষে একবার বাড়ানো হয়েছে।

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

অ্যানারি ডিজিটগুলির অনুলিপি যোগ iকরুন sএবং মুছুন, যাতে অভ্যন্তরীণ লুপের পরবর্তী পাসের জন্য বাঁচানো পরীক্ষা ব্যর্থ হয় এবং iকমপক্ষে একবার বর্ধিত হয়।

:.*

মুছুন i।

— নিল
সূত্র
3

জাভা 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
}
— OOBalance
সূত্র
2

পাইথন 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
— Hashbrowns
সূত্র
স্বাগত! আপনি পাইথনে
— গল্ফিংয়ের টিপসগুলির
1
আমি ;যতটা সম্ভব একটি একক লাইনে অনেকগুলি স্টেটমেন্ট ব্যবহার করে হোয়াইটস্পেস সরিয়ে, এবং 2 টি লম্বা লাইনের জন্য একটি ফাংশন সংজ্ঞায়িত করার অনুরোধ জানাই যাতে আপনি কিছু কোড পুনরায় ব্যবহার করতে পারেন। এছাড়াও, আপনি a=b=s=0এবং করতে পারেন len(g)!=h-1!=len(d)।
— mbomb007
টিপস জন্য ধন্যবাদ। আমি এখন যেতে হবে। তবে আমি এটি পরে কাজ করব।
— হ্যাশব্রাউন 21
0

লাল , 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 বাইট কম orterto-string i

— গ্যালেন ইভানভ
সূত্র
0

এমএটিএল , 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
— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র
0

আর , 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
— digEmAll
সূত্র
0

রুবি (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

আমার কাছে বেশ কুরুচিপূর্ণ লাগছে। বাউঙ্কনেস এই ব্লকে সংজ্ঞায়িত করা হয়েছেx.sort!=x&&x.sort!=x.reverse

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআএনএ বলেছে মনিকে ফিরিয়ে দিন
সূত্র
0

সি (জিসিসি), 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
}
— OOBalance
সূত্র
সুপারিশ u+=!y?--b,o:0,++oপরিবর্তে u+=y?0:o+0*--b,++o, ;y&=(c-=n%10)<0?:c?2:y)c=n%10,n/=10;পরিবর্তে;)c=n%10,n/=10,y&=(c-=n%10)<0?:c?2:y;
— ceilingcat
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.