Подавши ціле додатне ціле число n, виведіть зворотну суму діапазону n.

Зворотна сума діапазону створюється шляхом створення включного діапазону до n, починаючи з 1 і включаючи n, перевертаючи кожне з чисел всередині і підсумовуючи його.

Приклад:

Ось, що трапиться для введення 10:

Діапазон: [1,2,3,4,5,6,7,8,9,10]

Зворотний: [1,2,3,4,5,6,7,8,9,01](1-знакові числа перевернуті самі, 10 обернених - це 01 або 1)

Сума: 46

Числа, що мають 3+ цифр, змінюються так само, як і цифри з двома цифрами. Наприклад, 1234 рік стане 4321.

Тестові приклади:

Input -> Output

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

Повні текстові регістри до вводу 999 можна знайти тут , дуже дякую @ fireflame241.

05AB1E , 3 байти

Код

LíO

Використовує кодування 05AB1E . Спробуйте в Інтернеті!

Пояснення

L       # Range
 í      # Reverse
  O     # Sum

Bash + GNU утиліти, 24

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

Спробуйте в Інтернеті .

Пояснення

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

JavaScript (ES6), 42 байти

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

Моє улюблене подвійно-рекурсивне рішення, на жаль, на 3 байти довше:

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

Perl 6 , 20 байт

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

Перевірте це

Розширено:

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

Сітківка , 41 36 35 байт

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

.+
$*
1

Спробуйте в Інтернеті! Посилання включає тестові випадки. Редагувати: Збережено 5 байт завдяки @FryAmTheEggman. Збережено 1 байт завдяки @ PunPun1000. Пояснення:

.+
$*

Перетворити в одинарне.

1
1$`¶

Створіть діапазон від 1до n.

1+
$.&

Перетворити назад у десятковий.

%O^$`.

Переверніть кожне число.

.+
$*

Перетворити назад в одинарний.

1

Підсумовуйте та конвертуйте назад у десяткові.

Желе , 4 байти

Ṛ€ḌS

Спробуйте в Інтернеті!

Як?

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

Хаскелл, 34 байти

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

Простий і прямий.

C (gcc) , 63 байти

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

Спробуйте в Інтернеті!

cQuents , 4 байти

;\r$

Спробуйте в Інтернеті!

Пояснення

       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 байт

Неможливо обчислити більш високі терміни, ніж межа рекурсії:

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

Спробуйте в Інтернеті!

Брахілог , 4 байти

⟦↔ᵐ+

Спробуйте в Інтернеті!

Пояснення

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

Röda , 56 41 36 байт

15 байт збережено завдяки @fergusq

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

Спробуйте в Інтернеті!

Це анонімна функція, яка бере ціле число з вхідного потоку і виводить ціле число до вихідного потоку.

Пояснення

{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 байт

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

Спробуйте в Інтернеті!

Посилання TIO видає всі результати від 1 до 999, тому сміливо перевіряйте мою роботу.

Я очікував, що це трохи коротше, але, виявляється, Reverse()повертається IEnumerable<char>замість іншої рядки, тому мені довелося додати трохи зайвих, щоб перетворити його на рядок, щоб я міг її розібрати до int. Можливо, є коротший шлях, як правильно перейти від IEnumerable<char>до int.

З незначної уваги, це також використовує функції Range() Reverse()і Sum()все в порядку.

-6 байт завдяки TheLethalCoder

Рубі, 56, 52, 41, 39 байт

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

Рубін, 34 байти (якщо параметр лямбда - рядок)

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

Завдяки @Unihedron за друге рішення.

Математика, 47 байт

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

Спробуйте в Інтернеті! (для роботи над математикою нам потрібно замінити "Tr" на "Total")

Вугілля деревне , 14 13 байт

-1 байт завдяки Карлосу Алехо

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

Спробуйте в Інтернеті! Посилання на багатослівну версію.

Пояснення

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

Магнесон , 102 байти

Це не дуже видно, тому ось розширена версія (Примітка: насправді не запуститься, і все ще не дуже симпатично)

Магнесон діє, аналізуючи зображення та оцінюючи команди за кольорами пікселів, які він читає. Отже, переглядаючи зображення для цього завдання, ми маємо:

• R: 0, G: 1, B: 1це ціла команда призначення, яка бере рядок для імені змінної та значення для присвоєння. Ми будемо використовувати це для зберігання загальної суми.
• R: 0, G: 1, B: 0 - це попередньо вбудований рядок зі значенням VAR_1 (Примітка. Це лише тоді, коли ми запитуємо рядок; колірний код має окрему функцію при використанні в іншому місці).
• R: 3, G: 0, B: 0- це необроблене число. Магнесон обробляє стандартні числа, вимагаючи, щоб червоний компонент був рівним 3, а потім формує число, використовуючи безпосередньо синє значення плюс зелене значення, помножене на 256. У цьому випадку ми просто отримуємо число 0.
• R: 0, G: 1, B: 1- ще одна команда призначення цілого числа. Цього разу ми зберігаємо змінну ітерації, щоб відстежувати, яке число ми знаходимо
• R: 0, G: 1, B: 1 - це попередньо вбудований рядок зі значенням VAR_2 (Ще раз, лише тоді, коли нам потрібна рядок)
• R: 3, G: 0, B: 0- це число 0, ще раз. На цікаві біти зараз.
• R: 1, G: 0, B: 0вказує на початок циклу. Це займає число і циклічно виконує наступний фрагмент коду, який багато разів.
• R: 2, G: 0, B: 0є функцією STDIN або, принаймні, це коли нам потрібне число. Це зчитує рядок введення з консолі і перетворює її в число, оскільки ми попросили номер.
• R: 0, G: 8, B: 0починає наш цикл, і це команда добавки. Це додає число до цілочисленної змінної, а значить, береться рядок для імені змінної та число, яке потрібно додати.
• R: 0, G: 1, B: 1- це попередньо вбудований рядок для VAR_2, який є нашою змінною ітерації.
• R: 3, G: 0, B: 1 це необроблене число, але цього разу це число 1.
• R: 0, G: 8, B: 0 - ще одна команда додавання.
• R: 0, G: 1, B: 0це рядок для VAR_1, який є нашою загальною сумою.
• R: 0, G: 3, B: 0- це функція, яка обертає рядок. У контексті запиту на номер він перетворює перевернутий рядок у число.
• R: 0, G: 2, B: 1це ціла команда пошуку та отримає число, збережене у наданій змінній. У контексті запиту рядка (наприклад, з команди зворотного зв'язку) він перетворює число в рядок.
• R: 0, G: 1, B: 1- назва VAR_2; наша ітераційна змінна.
• R: 1, G: 0, B: 1- це маркер для закінчення циклу та повернення до початку циклу, якщо критерії не виконані (тому, якщо нам потрібно продовжувати циклічно). В іншому випадку продовжуйте роботу вперед.
• R: 0, G: 0, B: 1 це дуже проста команда println і займає рядок.
• R: 0, G: 2, B: 1 отримує ціле число зі змінної

• R: 0, G: 1, B: 0 - назва нашої загальної змінної суми, VAR_1

  Загалом, програма:

• Призначає значення 0 до VAR_1 таVAR_2
• Цикли від 0 до числа, передбаченого STDIN
  • Додає до VAR_2
  • Додає ціле значення реверсування VAR_2доVAR_1
• Друкує вміст VAR_1

Python 2 , 50 47 байт

-3 байти завдяки службовій мові!

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

Спробуйте в Інтернеті!

CJam , 12 байт

ri){sW%i}%:+

Спробуйте в Інтернеті!

-1 завдяки Business Cat .

Пояснення:

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 байт

3 байти в гольф завдяки @ Adám, переходячи на tradfn з поїзда

+/⍎⌽⍕⍳⎕

Спробуйте в Інтернеті!

⎕          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 байт

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

EDIT

Відповідно до коментаря Kevin Cruijssen, я хотів би покращити свою відповідь.

Java 8, 103 байти

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

Japt , 7 5 байт

-2 байти завдяки @Shaggy.

õs xw

Спробуйте в Інтернеті!

Пояснення

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

Старий розчин, 7 байт

Зберігаючи це, оскільки це дійсно круте використання z2.

õs z2 x

Спробуйте в Інтернеті!

Пояснення

õ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 байт

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

Лушпиння , 7 6 3 байт

ṁ↔ḣ

Спробуйте в Інтернеті!

Безголів / пояснення

  ḣ  -- 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 байти

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

Спробуйте в Інтернеті!

RProgN 2 , 8 байт

{Ø.in}S+

Пояснив

{Ø.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.

Спробуйте в Інтернеті!

Pyth , 8 6 байт

^{-2 байти завдяки FryAmTheEggman!}

sms_`h

Спробуйте в Інтернеті!

Tcl , 66 байт

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

Спробуйте в Інтернеті!

Нейм , 4 байти

Δ𝐫)𝐬

Спробуйте в Інтернеті!

Пояснення

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

C (gcc) , 71 байт

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

Спробуйте в Інтернеті!