Учитывая положительное целое число 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+ цифрами меняются местами так же, как числа с 2 цифрами. Например, 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}

Попробуй это

Expanded:

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

Haskell, 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 link выводит все результаты с 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}}

Ruby, 34 байта (если лямбда-параметр является строкой)

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

Спасибо @Unihedron за второе решение.

Mathematica, 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это необработанное число. Магнесон обрабатывает стандартные числа, требуя, чтобы компонент Red был точно равен 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 байта благодаря официальнымaimm!

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

РЕДАКТИРОВАТЬ

Согласно комментарию Kevin Cruijssen , я хотел бы улучшить свой ответ.

Java 8, 103 байта

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

Джапт , 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 байта

ṁ↔ḣ

Попробуйте онлайн!

Ungolfed / Пояснение

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

Попробуйте онлайн!

Пиф , 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;}

Попробуйте онлайн!