Terminologie

Un nombre croissant est celui où chaque chiffre est supérieur ou égal à tous les chiffres à sa gauche (ex. 12239)

Un nombre décroissant est celui où chaque chiffre est inférieur ou égal à tous les chiffres à sa gauche (ex. 95531)

Un nombre rebondissant est un nombre qui n'augmente ni ne diminue. Comme cela nécessite au moins 3 chiffres, le premier numéro rebondissant est 101

La tâche

Étant donné un entier n supérieur ou égal à 1, trouver la somme des n premiers nombres rebondissants

Règles

• C'est le golf de code, donc la réponse avec le plus petit nombre d'octets gagne
• Si votre langue a des limites sur la taille entière (ex. 2 ^ 32-1) n sera suffisamment petit pour que la somme tienne dans l'entier
• L'entrée peut être de n'importe quelle forme raisonnable (stdin, fichier, paramètre de ligne de commande, entier, chaîne, etc.)
• La sortie peut être de n'importe quelle forme raisonnable (stdout, fichier, élément utilisateur graphique qui affiche le nombre, etc.)

Cas de test

1 > 101
10 > 1065
44701 > 1096472981

Gelée , 10 8 octets

ṢeṚƬ¬µ#S

Essayez-le en ligne!

Comment ça fonctionne

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

s.f!SI#_B`

Essayez-le ici!

Comment ça fonctionne?

sf! SI # _B` - Programme complet. Prend un entier Q de STDIN et sort vers STDOUT.
 .f - Trouvez les premiers Q entiers positifs qui satisfont à une certaine condition.
   ! SI # _B - La condition. Renvoie vrai pour les nombres rebondissants uniquement.
       _B` - Cast le nombre dans une chaîne et bifurque (paire) avec son inverse.
      # - Filtrez-les ...
     I - Qui sont invariables sous ...
    S - Tri.
           - Pour clarifier, I (invariant) est un opérateur Pyth qui prend deux entrées, un 
             fonction et une valeur et vérifie si la fonction (valeur) == valeur, donc
             ce n'est pas techniquement intégré.
   ! - Logique non. La liste vide est mappée sur true, les autres valeurs sur false.
s - Somme.

K (ngn / k) , 37 octets

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

Essayez-le en ligne!

{ } est une fonction avec argument x

x{ }\0applique le {}sur les 0 xtemps, en préservant les résultats intermédiaires

(1+) est la fonction successeur

{ }(1+)/x+1applique la fonction successeur à partir de x+1jusqu'à ce que le {}retourne vrai

10\x sont les chiffres décimaux de x

a: affecter à a

|\ est le max-scan (maxima partiels) de a

&\ de façon analogue, est le min-scan

a~|\ane acorrespondre à son max-scan?

| ou

a~&\a son min-scan?

+/ somme

JavaScript (ES6), 77 octets

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)

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne

Cette fonction détermine si un nombre est rebondissant:

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

Python 2 , 84 octets

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

Essayez-le en ligne! Ou consultez une suite de tests .

Rétine , 93 octets

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

Essayez-le en ligne! Explication:

K`:

Initialiser s=i=0. ( sest le nombre de #s avant le :, ile nombre de #s après.)

"$+"{
...
)`

Répétez nfois.

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

Répétez tout in'est pas gonflable.

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

Incrémentez iet faites une copie en décimal.

\d
*_;

Convertissez les chiffres de la copie en unaire. Le test de rebond utilise la copie unaire, donc il ne fonctionne qu'une fois ia été incrémenté au moins une fois.

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

Ajouter ià set supprimer la copie des chiffres unaire, de sorte que pour le passage suivant de la boucle interne du test bounciness échoue et is'incrémenté au moins une fois.

\G#

Convertissez sen décimal.

La version 121 octets calcule en décimal, donc pourrait fonctionner pour des valeurs plus grandes de n:

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

Essayez-le en ligne! Explication:

K`0:0

Initialiser s=i=0.

"$+"{
...
)`

Répétez nfois.

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

Répétez tout in'est pas gonflable.

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

Incrémentez iet faites une copie.

+`;\d
;$&*_;

Convertissez les chiffres de la copie en unaire. Le test de rebond utilise la copie unaire, donc il ne fonctionne qu'une fois ia été incrémenté au moins une fois.

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

Ajouter ià set supprimer la copie des chiffres unaire, de sorte que pour le passage suivant de la boucle interne du test bounciness échoue et is'incrémenté au moins une fois.

:.*

Supprimer i.

05AB1E , 12 octets

µN{‚Nå_iNO¼

Essayez-le en ligne!

Explication

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

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

Utilise une expression régulière pour vérifier si le nombre augmente ou diminue. Essayez-le en ligne ici .

Non golfé:

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 octets

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 octets

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

Exécuter et déboguer

Rouge , 108 octets

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]

Essayez-le en ligne!

Plus lisible:

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
]

Une bonne opportunité à utiliser form- form iest 5 octets plus court queto-string i

MATL , 31 30 octets

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

Essayez-le en ligne!

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 octets

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}

Essayez-le en ligne!

Explication:

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

Rubis (123 octets)

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

Ça me semble assez moche. Le rebond est défini dans ce blocx.sort!=x&&x.sort!=x.reverse

Rubis , 76 octets

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

Essayez-le en ligne!

C (gcc), 104 octets

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

Essayez-le en ligne ici .

Non golfé:

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
}