Dado un entero positivo n como entrada, genera la suma del rango inverso de n.

Una suma de rango invertida se crea haciendo un rango inclusivo hasta n, comenzando con 1 e incluyendo n, invirtiendo cada uno de los números dentro y sumándolo.

Ejemplo:

Esto es lo que sucedería para una entrada de 10:

Distancia: [1,2,3,4,5,6,7,8,9,10]

Reverso: [1,2,3,4,5,6,7,8,9,01](los números 1-char invertidos son ellos mismos, 10 invertidos es 01 o 1)

Suma: 46

Los números con más de 3 dígitos se invierten de la misma manera que los números con 2 dígitos. Por ejemplo, 1234 se convertiría en 4321.

Casos de prueba:

Input -> Output

10 -> 46
5 -> 15
21 -> 519
58 -> 2350
75 -> 3147
999 -> 454545

Aquí se pueden encontrar casos de texto completos para la entrada de 999 , muchas gracias a @ fireflame241.

05AB1E , 3 bytes

Código

LíO

Utiliza la codificación 05AB1E .Pruébalo en línea!

Explicación

L       # Range
 í      # Reverse
  O     # Sum

Bash + GNU utils, 24

seq $1|rev|paste -sd+|bc

Pruébalo en línea .

Explicación

seq $1                    # range
      |rev                # reverse (each line)
          |paste -sd+|bc  # sum

JavaScript (ES6), 42 bytes

f=n=>n&&+[...n+""].reverse().join``+f(n-1)

Lamentablemente, mi solución doblemente recursiva favorita es 3 bytes más larga:

f=n=>n&&+(g=x=>x?x%10+g(x/10|0):"")(n)+f(n-1)

Perl 6 , 20 bytes

{(1..$_)».flip.sum}

Pruébalo

Expandido:

{
   ( 1 .. $_ )\  # Range
   ».flip        # flip each value in the Range (possibly in parallel)
   .sum          # sum up the list
}

Retina , 41 36 35 bytes

.+
$*
1
1$`¶
1+
$.&
%O^$`.

.+
$*
1

Pruébalo en línea! El enlace incluye casos de prueba. Editar: Guardado 5 bytes gracias a @FryAmTheEggman. Guardado 1 byte gracias a @ PunPun1000. Explicación:

.+
$*

Convierte a unario.

1
1$`¶

Crea un rango de 1a n.

1+
$.&

Convertir de nuevo a decimal.

%O^$`.

Invierte cada número.

.+
$*

Convertir de nuevo a unario.

1

Suma y convierte de nuevo a decimal.

Jalea , 4 bytes

Ṛ€ḌS

Pruébalo en línea!

¿Cómo?

Ṛ€ḌS - Link: n
Ṛ€   - reverse for €ach (in implicit range)
  Ḍ  - convert from decimal list (vectorises)
   S - sum

Haskell, 34 bytes

\n->sum$read.reverse.show<$>[1..n]

Simple y directo.

C (gcc) , 63 bytes

f(n){int t=0,c=n;for(;c;c/=10)t=t*10+c%10;return n?t+f(n-1):0;}

Pruébalo en línea!

cQuents , 4 bytes

;\r$

Pruébalo en línea!

Explicación

       Implicit input n.
;      Series mode. Outputs the sum of the sequence from 1 to n.
 \r$   Each item in the sequence equals:
 \r    String reverse of
   $                     current index (1-based)

Python 2 , 38 bytes

No se pueden calcular términos más altos que el límite de recursividad:

f=lambda x:x and int(`x`[::-1])+f(x-1)

Pruébalo en línea!

Brachylog , 4 bytes

⟦↔ᵐ+

Pruébalo en línea!

Explicación

⟦↔ᵐ+
⟦        range from 0 to input
 ↔ᵐ      map reverse
   +     sum

Röda , 56 41 36 bytes

15 bytes guardados gracias a @fergusq

{seq 1,_|parseInteger`$_`[::-1]|sum}

Pruébalo en línea!

Esta es una función anónima que toma un número entero de la secuencia de entrada y genera un número entero en la secuencia de salida.

Explicación

{seq 1,_|parseInteger`$_`[::-1]|sum} Anonymous function
 seq 1,_                             Create a sequence 1 2 3 .. input and push each value to the stream
        |                            For each value in the stream:
                     `$_`             Cast it into a string
                         [::-1]       And reverse it
         parseInteger                 And parse the resulting string as an integer, while pushing the value to the stream
                               |sum  Sum all the values in the stream

C # (.NET Core) , 103 97 bytes

using System.Linq;r=>new int[r+1].Select((_,n)=>int.Parse(string.Concat((n+"").Reverse()))).Sum()

Pruébalo en línea!

El enlace TIO genera todos los resultados del 1 al 999, así que no dude en consultar mi trabajo.

Esperaba que esto fuera un poco más corto, pero resulta que Reverse()devuelve una IEnumerable<char>cadena en lugar de otra, por lo que tuve que agregar un poco más para convertirla nuevamente en una cadena para poder analizarla en un int. Tal vez hay una forma más corta de ir IEnumerable<char>a int correctamente.

De menor importancia, esto también utiliza las funciones Range() Reverse()y Sum()todo en orden.

-6 bytes gracias a TheLethalCoder

Rubí, 56, 52, 41, 39 bytes

->n{(1..n).sum{|i|i.to_s.reverse.to_i}}

Ruby, 34 bytes (si lambda param es una cadena)

->n{(1..n).sum{|i|i.reverse.to_i}}

Gracias a @Unihedron por la segunda solución.

Mathematica, 47 bytes

Tr[FromDigits@*Reverse/@IntegerDigits@Range@#]&

Pruébalo en línea! (para trabajar en matemáticas necesitamos reemplazar "Tr" con "Total")

Carbón , 14 13 bytes

-1 byte gracias a Carlos Alejo

Ｉ∕…·⁰Ｎ«⁺ιＩ⮌Ｉκ

Pruébalo en línea! El enlace es a la versión detallada.

Explicación

Ｉ                  Cast
  ∕     «           Reduce
   …·⁰Ｎ            Inclusive range from 0 to input as number
         ⁺          Plus
          ι         i
           Ｉ⮌Ｉκ   Cast(Reverse(Cast(k)))

Magneson , 102 bytes

Eso no es muy visible, así que aquí hay una versión ampliada (Nota: en realidad no se ejecutará, y aún no es muy bonita)

Magneson opera analizando una imagen y evaluando comandos de los colores de los píxeles que lee. Entonces, al recorrer la imagen para este desafío, tenemos:

• R: 0, G: 1, B: 1es un comando de asignación de enteros, que toma una cadena para el nombre de la variable y el valor a asignar. Usaremos esto para almacenar la suma total.
• R: 0, G: 1, B: 0es una cadena preconstruida con el valor VAR_1(Nota: Esto es solo mientras pedimos una cadena; el código de color tiene una función separada cuando se usa en otro lugar).
• R: 3, G: 0, B: 0Es un número sin procesar. Magneson maneja los números estándar al requerir que el componente Rojo sea exactamente 3, y luego forma un número usando el valor azul directamente más el valor verde multiplicado por 256. En este caso, solo estamos obteniendo el número 0.
• R: 0, G: 1, B: 1es otro comando de asignación de enteros. Esta vez, estamos almacenando una variable de iteración, para realizar un seguimiento de en qué número estamos
• R: 0, G: 1, B: 1 es una cadena preconstruida con el valor VAR_2 (Una vez más, solo cuando necesitamos una cadena)
• R: 3, G: 0, B: 0es el número 0, una vez más. Sobre las partes interesantes ahora.
• R: 1, G: 0, B: 0indica el inicio de un bucle. Esto toma un número y repite el siguiente fragmento de código que muchas veces.
• R: 2, G: 0, B: 0es la función STDIN, o al menos es cuando necesitamos un número. Esto lee una línea de entrada de la consola y la convierte en un número, ya que pedimos un número.
• R: 0, G: 8, B: 0comienza nuestro código de bucle y es un comando aditivo. Esto agrega un número a una variable entera y, por lo tanto, toma una cadena para el nombre de la variable y el número que se agrega.
• R: 0, G: 1, B: 1es la cadena preconstruida para VAR_2, que es nuestra variable de iteración.
• R: 3, G: 0, B: 1 es un número sin procesar, pero esta vez es el número 1.
• R: 0, G: 8, B: 0 Es otro comando adicional.
• R: 0, G: 1, B: 0es la cadena para VAR_1, que es nuestra suma total.
• R: 0, G: 3, B: 0es una función que invierte una cadena. En el contexto de pedir un número, luego convierte la cadena invertida en un número.
• R: 0, G: 2, B: 1es un comando de recuperación de enteros y recuperará el número almacenado en una variable proporcionada. En el contexto de pedir una cadena (como el comando inverso), convierte el número en una cadena.
• R: 0, G: 1, B: 1 es el nombre VAR_2 ; Nuestra variable de iteración.
• R: 1, G: 0, B: 1es el marcador para finalizar el bucle y volver al inicio del bucle si no se cumplen los criterios (por lo tanto, si necesitamos seguir en bucle). De lo contrario, continúe.
• R: 0, G: 0, B: 1 es un comando println muy simple y toma una cadena.
• R: 0, G: 2, B: 1 recupera un entero de una variable

• R: 0, G: 1, B: 0 es el nombre de nuestra variable suma total, VAR_1

  En general, el programa:

• Asigna el valor 0 a VAR_1yVAR_2
• Bucles de 0 a un número proporcionado en STDIN
  • Agrega uno a VAR_2
  • Agrega el valor entero de invertir VAR_2aVAR_1
• Imprime el contenido de VAR_1

Python 2 , 50 47 bytes

-3 bytes gracias a officialaimm!

lambda n:sum(int(`i+1`[::-1])for i in range(n))

Pruébalo en línea!

CJam , 12 bytes

ri){sW%i}%:+

Pruébalo en línea!

-1 gracias a Business Cat .

Explicación:

ri){sW%i}%:+
r            Get token
 i           To integer
  )          Increment
   {sW%i}    Push {sW%i}
    s         To string
     W        Push -1
      %       Step
       i      To integer
         %   Map
          :+ Map/reduce by Add

APL (Dyalog) , 10 7 bytes

3 bytes de golf gracias a @ Adám al convertir a un tren desde un tren

+/⍎⌽⍕⍳⎕

Pruébalo en línea!

⎕          Input (example input: 10)
⍳          Range; 1 2 3 4 5 6 7 8 9 10
⍕          Stringify; '1 2 3 4 5 6 7 8 9 10'
⌽          Reverse; '01 9 8 7 6 5 4 3 2 1'
⍎          Evaluate; 1 9 8 7 6 5 4 3 2 1
+/         Sum; 46

Java 8, 97 bytes

IntStream.range(1,n+1).map(i->Integer.valueOf(new StringBuffer(""+i).reverse().toString())).sum()

EDITAR

Según el comentario de Kevin Cruijssen, me gustaría mejorar mi respuesta.

Java 8, 103 bytes

n->java.util.stream.LongStream.range(1,n+1).map(i->new Long(new StringBuffer(""+i).reverse()+"")).sum()

Japt , 7 5 bytes

-2 bytes gracias a @Shaggy.

õs xw

Pruébalo en línea!

Explicación

õs xw  Implicit input of integer U
õs     Create range [1,U] and map to strings
    w  Reverse each string
   x   Sum the array, implicitly converting to numbers.

Solución anterior, 7 bytes

Mantener esto ya que es un uso realmente genial z2.

õs z2 x

Pruébalo en línea!

Explicación

õs z2 x  Implicit input of integer U
õs       Create range [1,U] and map to strings
   z2    Rotate the array 180°, reversing strings
      x  Sum the array, implicitly converting back to integers

C ++, 146 bytes

#include<string>
using namespace std;int r(int i){int v=0,j=0;for(;j<=i;++j){auto t=to_string(j);reverse(t.begin(),t.end());v+=stoi(t);}return v;}

Casco , 7 6 3 bytes

ṁ↔ḣ

Pruébalo en línea!

Ungolfed / Explicación

  ḣ  -- With the list [1..N] ..
ṁ    -- .. do the following with each element and sum the values:
 ↔   --    reverse it

Perl 5 , 29 27 22 + 1 ( -p) = 23 bytes

map$\+=reverse,1..$_}{

Pruébalo en línea!

RProgN 2 , 8 bytes

{Ø.in}S+

Explicado

{Ø.in}S+
{    }S # Create a stack in range 0 through the implicit input, using the function defined
 Ø.     # Append nothing, stringifying the number
   i    # Reverse the string
    n   # Convert back to a number
       +# Get the sum of the stack, and output implicitly.

Pruébalo en línea!

Pyth , 8 6 bytes

^{-2 bytes gracias a FryAmTheEggman!}

sms_`h

Pruébalo en línea!

Tcl , 66 bytes

time {incr s [regsub ^0+ [string rev $n] ""];incr n -1} $n
puts $s

Pruébalo en línea!

Neim , 4 bytes

Δ𝐫)𝐬

Pruébalo en línea!

Explicación

Δ )              for each element 1 to n (outputs list)
 𝐫               reverse 
   𝐬             sum 

C (gcc) , 71 bytes

q(n,x,p){p=n?q(n/10,x*10+n%10):x;}f(w,a,e){for(a=0;w;)a+=q(w--,0);e=a;}

Pruébalo en línea!