Terminologie

Eine aufsteigende Zahl ist eine Zahl, bei der jede Ziffer größer oder gleich allen Ziffern links davon ist (z. B. 12239).

Eine absteigende Zahl ist eine Zahl, bei der jede Ziffer kleiner oder gleich allen Ziffern links davon ist (z. B. 95531).

Eine Sprungzahl ist eine Zahl, die nicht zunimmt oder abnimmt. Da dies mindestens 3 Stellen erfordert, ist die erste Hüpfnummer 101

Die Aufgabe

Wenn eine ganze Zahl n größer oder gleich 1 ist, ermitteln Sie die Summe der ersten n Sprungzahlen

Regeln

• Dies ist Codegolf, daher gewinnt die Antwort mit der kürzesten Anzahl von Bytes
• Wenn in Ihrer Sprache die Ganzzahlgröße begrenzt ist (z. B. 2 ^ 32-1), ist n so klein, dass die Summe in die Ganzzahl passt
• Die Eingabe kann in jeder vernünftigen Form erfolgen (stdin, Datei, Befehlszeilenparameter, Ganzzahl, Zeichenfolge usw.)
• Die Ausgabe kann in jeder vernünftigen Form erfolgen (Standardausgabe, Datei, grafisches Benutzerelement, das die Nummer anzeigt usw.).

Testfälle

1 > 101
10 > 1065
44701 > 1096472981

Jelly , 10 8 Bytes

ṢeṚƬ¬µ#S

Probieren Sie es online!

Wie es funktioniert

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

s.f!SI#_B`

Probieren Sie es hier aus!

Wie es funktioniert?

sf! SI # _B` - Volles Programm. Nimmt eine Ganzzahl Q von STDIN und gibt sie an STDOUT aus.
 .f - Finde die ersten Q positiven ganzen Zahlen, die eine bestimmte Bedingung erfüllen.
   ! SI # _B - Die Bedingung. Gibt true nur für Bouncy-Nummern zurück.
       _B` - Wirf die Zahl in eine Zeichenfolge und teile sie mit der Rückseite in zwei Teile.
      # - Filter-behalte diese ...
     I - Das ist unveränderlich unter ...
    S - Sortieren.
           - Zur Verdeutlichung ist I (invariant) ein Pyth-Operator, der zwei Eingaben annimmt: a 
             Funktion und ein Wert und prüft, ob Funktion (Wert) == Wert, also
             dies ist technisch kein eingebautes.
   ! - Logisch nicht. Die leere Liste wird auf true abgebildet, andere Werte auf false.
s - Summe.

K (ngn / k) , 37 Bytes

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

Probieren Sie es online!

{ } ist eine Funktion mit Argument x

x{ }\0gilt das {}für 0 xZeiten, die Zwischenergebnisse zu bewahren

(1+) ist die Nachfolgerfunktion

{ }(1+)/x+1Wendet die Nachfolgerfunktion ab an, x+1bis die {}Rückgabe wahr ist

10\x sind die Dezimalstellen von x

a: zuweisen a

|\ ist der Max-Scan (Teilmaxima) von a

&\ analog ist der min-scan

a~|\apasst azu seinem Max-Scan?

| oder

a~&\a sein min-scan?

+/ Summe

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)

Probieren Sie es online!

Kommentiert

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 Bytes

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

Probieren Sie es online aus

Diese Funktion bestimmt, ob eine Zahl federnd ist:

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

Python 2 , 84 Bytes

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

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Netzhaut , 93 Bytes

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

Probieren Sie es online! Erläuterung:

K`:

Initialisieren s=i=0. ( sIst die Anzahl der #Sekunden vor :, idie Anzahl der #Sekunden nach.)

"$+"{
...
)`

Wiederhole das nmal.

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

Wiederholen, während inicht federnd ist.

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

Zuwachs i und kopieren Sie dezimal.

\d
*_;

Konvertieren Sie die Ziffern der Kopie in Unary. Der Bounciness-Test verwendet die unäre Kopie, daher funktioniert er nur einmali sie mindestens einmal inkrementiert wurde.

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

In izu sund löschen Sie die Kopie der einstelligen Ziffern, so dass für den nächsten Durchlauf der inneren Schleife des bounciness Test nicht bestanden undi wird mindestens einmal erhöht.

\G#

In sDezimalzahl konvertieren .

Die 121-Byte-Version wird in Dezimalzahlen berechnet und kann daher für folgende Werte verwendet werden n:

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

Probieren Sie es online! Erläuterung:

K`0:0

Initialisieren s=i=0.

"$+"{
...
)`

Wiederhole das nmal.

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

Wiederholen, während inicht federnd ist.

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

Inkrementieren iund kopieren.

+`;\d
;$&*_;

Konvertieren Sie die Ziffern der Kopie in Unary. Der Bounciness-Test verwendet die unäre Kopie, funktioniert also nur, wenni sie mindestens einmal inkrementiert wurde.

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

In ian sund die Kopie der einstelligen Ziffern löschen, so dass für den nächsten Durchlauf der inneren Schleife des bounciness Test nicht bestanden undi wird mindestens einmal erhöht.

:.*

Löschen i.

05AB1E , 12 Bytes

µN{‚Nå_iNO¼

Probieren Sie es online!

Erläuterung

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

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

Verwendet einen regulären Ausdruck, um zu überprüfen, ob die Anzahl zunimmt oder abnimmt. Probieren Sie es online aus hier aus .

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 Bytes

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 Bytes

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

Führen Sie es aus und debuggen Sie es

Rot , 108 Bytes

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]

Probieren Sie es online!

Besser lesbar:

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
]

Eine gute Gelegenheit zu nutzen form- form iist 5 Bytes kürzer alsto-string i

MATL , 31 30 Bytes

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

Probieren Sie es online!

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 Bytes

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}

Probieren Sie es online!

Erklärung:

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

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

Sieht für mich ziemlich hässlich aus. In diesem Block wird die Bounciness definiertx.sort!=x&&x.sort!=x.reverse

Ruby , 76 Bytes

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

Probieren Sie es online!

C (gcc), 104 Bytes

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

Probieren Sie es hier online aus .

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
}