Dado um número inteiro positivo n como entrada, produza a soma da faixa reversa de n.

Uma soma de intervalo invertida é criada criando um intervalo inclusivo de até n, começando com 1 e incluindo n, revertendo cada um dos números internos e somando-o.

Exemplo:

Aqui está o que aconteceria com uma entrada de 10:

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

Inverter: [1,2,3,4,5,6,7,8,9,01](os números de 1 caractere invertidos são eles mesmos, 10 invertidos são 01 ou 1)

Soma: 46

Os números com mais de 3 dígitos são revertidos da mesma forma que os números com 2 dígitos. Por exemplo, 1234 se tornaria 4321.

Casos de teste:

Input -> Output

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

Casos completos de texto para a entrada de 999 podem ser encontrados aqui , muito obrigado a @ fireflame241.

05AB1E , 3 bytes

Código

LíO

Usa a codificação 05AB1E . Experimente online!

Explicação

L       # Range
 í      # Reverse
  O     # Sum

Utilitários Bash + GNU, 24

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

Experimente online .

Explicação

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

JavaScript (ES6), 42 bytes

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

Minha solução duplamente recursiva favorita é, infelizmente, três bytes a mais:

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

Perl 6 , 20 bytes

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

Teste-o

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

Experimente online! O link inclui casos de teste. Editar: salvou 5 bytes graças a @FryAmTheEggman. Guardou 1 byte graças a @ PunPun1000. Explicação:

.+
$*

Converta para unário.

1
1$`¶

Crie um intervalo de 1até n.

1+
$.&

Converta de volta para decimal.

%O^$`.

Inverta cada número.

.+
$*

Converta de volta para unário.

1

Soma e converta de volta para decimal.

Gelatina , 4 bytes

Ṛ€ḌS

Experimente online!

Quão?

Ṛ€Ḍ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]

Simples e direto.

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

Experimente online!

cQuents , 4 bytes

;\r$

Experimente online!

Explicação

       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

Não é possível calcular termos mais altos que o limite de recursão:

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

Experimente online!

Braquilog , 4 bytes

⟦↔ᵐ+

Experimente online!

Explicação

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

Röda , 56 41 36 bytes

15 bytes salvos graças a @fergusq

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

Experimente online!

Essa é uma função anônima que pega um número inteiro do fluxo de entrada e gera um número inteiro para o fluxo de saída.

Explicação

{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()

Experimente online!

O link TIO gera todos os resultados de 1 a 999, portanto, fique à vontade para conferir meu trabalho.

Eu esperava que isso fosse um pouco mais curto, mas acontece que Reverse()retorna uma IEnumerable<char>string em vez de outra, então eu tive que adicionar alguns extras para transformá-la novamente em uma string para que eu pudesse analisá-la em um int. Talvez haja uma maneira mais curta de passar IEnumerable<char>para int corretamente.

Nota importante, isso também usa as funções Range() Reverse() e Sum()tudo em ordem.

-6 bytes graças a TheLethalCoder

Rubi, 56, 52, 41, 39 bytes

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

Ruby, 34 bytes (se lambda param for uma string)

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

Obrigado a @Unihedron pela segunda solução.

Mathematica, 47 bytes

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

Experimente online! (para trabalhar em matemática, precisamos substituir "Tr" por "Total")

Carvão , 14 13 bytes

-1 byte graças a Carlos Alejo

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

Experimente online! Link é a versão detalhada.

Explicação

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

Magneson , 102 bytes

Isso não é muito visível, então aqui está uma versão ampliada (Observação: na verdade, não será executado e ainda não é muito bonito)

Magneson opera analisando uma imagem e avaliando comandos a partir das cores dos pixels que lê. Então, percorrendo a imagem para esse desafio, temos:

• R: 0, G: 1, B: 1é um comando de atribuição de número inteiro, que usa uma sequência para o nome da variável e o valor a ser atribuído. Usaremos isso para armazenar a soma total.
• R: 0, G: 1, B: 0é uma string pré-construída com o valor VAR_1(Observação: isso é apenas enquanto solicitamos uma string; o código de cores tem uma função separada quando usado em outro lugar).
• R: 3, G: 0, B: 0é um número bruto. Magneson lida com números padrão exigindo que o componente Vermelho seja exatamente 3 e, em seguida, forma um número usando o valor azul diretamente mais o valor verde multiplicado por 256. Nesse caso, estamos apenas obtendo o número 0.
• R: 0, G: 1, B: 1é outro comando de atribuição de número inteiro. Desta vez, estamos armazenando uma variável de iteração, para acompanhar o número em que estamos
• R: 0, G: 1, B: 1é uma string pré-construída com o valor VAR_2(Mais uma vez, somente quando precisamos de uma string)
• R: 3, G: 0, B: 0é o número 0, mais uma vez. Para os bits interessantes agora.
• R: 1, G: 0, B: 0indica o início de um loop. Isso pega um número e faz um loop do seguinte trecho de código várias vezes.
• R: 2, G: 0, B: 0é a função STDIN, ou pelo menos é quando precisamos de um número. Isso lê uma linha de entrada do console e a transforma em um número, pois solicitamos um número.
• R: 0, G: 8, B: 0inicia nosso código de loop e é um comando aditivo. Isso adiciona um número a uma variável inteira e, portanto, leva uma sequência para o nome da variável e o número a ser adicionado.
• R: 0, G: 1, B: 1 é a string pré-construída para VAR_2 , que é a nossa variável de iteração.
• R: 3, G: 0, B: 1 é um número bruto, mas desta vez é o número 1.
• R: 0, G: 8, B: 0 é outro comando de adição.
• R: 0, G: 1, B: 0 é a string para VAR_1 , que é a nossa soma total.
• R: 0, G: 3, B: 0é uma função que reverte uma string. No contexto de solicitar um número, ele converte a sequência invertida em um número.
• R: 0, G: 2, B: 1é um comando de recuperação de número inteiro e recuperará o número armazenado em uma variável fornecida. No contexto de solicitar uma string (como no comando reverso), ele converte o número em uma string.
• R: 0, G: 1, B: 1 É o nome VAR_2 ; nossa variável de iteração.
• R: 1, G: 0, B: 1é o marcador para finalizar o loop e voltar ao início do loop se os critérios não forem atendidos (por isso, se precisarmos continuar fazendo loop). Caso contrário, prossiga.
• R: 0, G: 0, B: 1 é um comando println muito simples e usa uma string.
• R: 0, G: 2, B: 1 recupera um número inteiro de uma variável

• R: 0, G: 1, B: 0 é o nome da nossa variável total de soma, VAR_1

  Em suma, o programa:

• Atribui o valor 0 a VAR_1eVAR_2
• Loops de 0 a um número fornecido no STDIN
  • Adiciona um a VAR_2
  • Adiciona o valor inteiro da reversão VAR_2paraVAR_1
• Imprime o conteúdo de VAR_1

Python 2 , 50 47 bytes

-3 bytes graças a officialaimm!

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

Experimente online!

CJam , 12 bytes

ri){sW%i}%:+

Experimente online!

-1 graças a Business Cat .

Explicação:

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 golfe graças a @ Adám convertendo para um tradfn de um trem

+/⍎⌽⍕⍳⎕

Experimente online!

⎕          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

De acordo com o comentário de Kevin Cruijssen , eu gostaria de melhorar minha resposta.

Java 8, 103 bytes

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

Japonês , 7 5 bytes

-2 bytes graças a @Shaggy.

õs xw

Experimente online!

Explicação

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

Solução antiga, 7 bytes

Mantendo isso, pois é um uso muito legal de z2.

õs z2 x

Experimente online!

Explicação

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

Casca , 7 6 3 bytes

ṁ↔ḣ

Experimente online!

Ungolfed / Explicação

  ḣ  -- 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..$_}{

Experimente online!

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.

Experimente online!

Pitão , 8 6 bytes

^{-2 bytes graças a FryAmTheEggman!}

sms_`h

Experimente online!

Tcl , 66 bytes

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

Experimente online!

Neim , 4 bytes

Δ𝐫)𝐬

Experimente online!

Explicação

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

Experimente online!