Bei einer positiven ganzen Zahl n als Eingabe wird die umgekehrte Bereichssumme von n ausgegeben.

Eine umgekehrte Bereichssumme wird erstellt, indem ein inklusiver Bereich bis zu n erstellt wird, beginnend mit 1 und einschließlich n, wobei jede der darin enthaltenen Zahlen umgekehrt und summiert wird.

Beispiel:

Folgendes würde bei einer Eingabe von 10 passieren:

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

Reverse: [1,2,3,4,5,6,7,8,9,01](1-Zeichen-Nummern sind umgekehrt, 10 umgekehrt ist 01 oder 1)

Summe: 46

Zahlen mit 3 oder mehr Ziffern werden genauso umgekehrt wie Zahlen mit 2 Ziffern. Zum Beispiel würde 1234 4321 werden.

Testfälle:

Input -> Output

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

Komplette Textfelder zur Eingabe von 999 finden Sie hier , vielen Dank an @ fireflame241.

05AB1E , 3 Bytes

Code

LíO

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

L       # Range
 í      # Reverse
  O     # Sum

Bash + GNU Utils, 24

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

Probieren Sie es online aus .

Erläuterung

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

JavaScript (ES6), 42 Byte

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

Meine bevorzugte doppelt rekursive Lösung ist leider 3 Bytes länger:

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

Perl 6 , 20 Bytes

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

Probier es aus

Erweitert:

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 5 Bytes dank @FryAmTheEggman gespeichert. 1 Byte dank @ PunPun1000 gespeichert. Erläuterung:

.+
$*

In Unary konvertieren.

1
1$`¶

Erstellen Sie einen Bereich von 1bis n.

1+
$.&

Zurück in Dezimalzahl konvertieren.

%O^$`.

Kehren Sie jede Zahl um.

.+
$*

Konvertiere zurück zu Unary.

1

Summieren und zurück in Dezimalzahl konvertieren.

Gelee , 4 Bytes

Ṛ€ḌS

Probieren Sie es online!

Wie?

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

Einfach und unkompliziert.

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

Probieren Sie es online!

cQuents , 4 Bytes

;\r$

Probieren Sie es online!

Erläuterung

       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

Höhere Terme als das Rekursionslimit können nicht berechnet werden:

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

Probieren Sie es online!

Brachylog , 4 Bytes

⟦↔ᵐ+

Probieren Sie es online!

Erläuterung

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

Röda , 56 41 36 Bytes

15 Bytes gespart dank @fergusq

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

Probieren Sie es online!

Dies ist eine anonyme Funktion, die eine Ganzzahl aus dem Eingabestream entnimmt und eine Ganzzahl an den Ausgabestream ausgibt.

Erläuterung

{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 bis 97 Byte

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

Probieren Sie es online!

TIO Link gibt alle Ergebnisse von 1 bis 999 aus. Sie können also gerne meine Arbeit überprüfen.

Ich erwartete dies ein wenig kürzer zu sein, aber es stellt sich heraus , Reverse()kehrt ein , IEnumerable<char>anstatt eine andere Zeichenfolge , damit ich etwas mehr hinzuzufügen , hatte es wieder in einen String zu drehen , damit ich es in ein int analysieren konnte. Vielleicht gibt es einen kürzeren Weg, um IEnumerable<char>korrekt von int zu gelangen.

Von untergeordneter Bedeutung, verwendet dies auch die Funktionen Range() Reverse()und Sum()alles in der richtigen Reihenfolge.

-6 Bytes dank TheLethalCoder

Rubin, 56, 52, 41, 39 Bytes

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

Ruby, 34 Bytes (wenn Lambda-Parameter ein String ist)

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

Vielen Dank an @Unihedron für die zweite Lösung.

Mathematica, 47 Bytes

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

Probieren Sie es online! (Um in der Mathematik arbeiten zu können, müssen wir "Tr" durch "Total" ersetzen.)

Kohle , 14 13 Bytes

-1 Byte danke an Carlos Alejo

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

Probieren Sie es online! Link ist zur ausführlichen Version.

Erläuterung

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

Magneson , 102 Bytes

Das ist nicht sehr sichtbar, daher hier eine vergrößerte Version (Hinweis: Läuft nicht wirklich und ist immer noch nicht sehr hübsch)

Magneson analysiert ein Bild und bewertet Befehle anhand der Farben der gelesenen Pixel. Wenn wir uns also für diese Herausforderung ins Bild setzen, haben wir:

• R: 0, G: 1, B: 1ist ein ganzzahliger Zuweisungsbefehl, der eine Zeichenfolge für den Variablennamen und den zuzuweisenden Wert enthält. Wir werden dies verwenden, um die Gesamtsumme zu speichern.
• R: 0, G: 1, B: 0ist eine vorgefertigte Zeichenfolge mit dem Wert VAR_1(Hinweis: Dies ist nur möglich, wenn eine Zeichenfolge angefordert wird; der Farbcode hat eine separate Funktion, wenn er an anderer Stelle verwendet wird).
• R: 3, G: 0, B: 0ist eine rohe Zahl. Magneson verarbeitet Standardzahlen, indem die Rot-Komponente genau 3 sein muss, und bildet dann eine Zahl, indem der Blau-Wert direkt plus der Grün-Wert multipliziert mit 256 verwendet wird. In diesem Fall erhalten wir nur die Zahl 0.
• R: 0, G: 1, B: 1ist ein weiterer Befehl für die Zuweisung von Ganzzahlen. Dieses Mal speichern wir eine Iterationsvariable, um zu verfolgen, auf welcher Nummer wir gerade sind
• R: 0, G: 1, B: 1ist eine vorgefertigte Zeichenkette mit dem Wert VAR_2(noch einmal, nur wenn wir eine Zeichenkette brauchen)
• R: 3, G: 0, B: 0ist die Zahl 0 noch einmal. Auf die interessanten Teile jetzt.
• R: 1, G: 0, B: 0zeigt den Beginn einer Schleife an. Dies nimmt eine Zahl und wiederholt den folgenden Codeausschnitt so oft.
• R: 2, G: 0, B: 0ist die STDIN-Funktion, oder zumindest, wenn wir eine Nummer benötigen. Dadurch wird eine Eingabezeile von der Konsole gelesen und in eine Zahl umgewandelt, da wir nach einer Zahl gefragt haben.
• R: 0, G: 8, B: 0startet unseren Schleifencode und es ist ein additiver Befehl. Dies fügt einer Ganzzahlvariablen eine Zahl hinzu und benötigt daher eine Zeichenfolge für den Variablennamen und die hinzuzufügende Zahl.
• R: 0, G: 1, B: 1ist die vorgefertigte Zeichenfolge für VAR_2, die unsere Iterationsvariable ist.
• R: 3, G: 0, B: 1 ist eine rohe Zahl, aber diesmal ist es die Nummer 1.
• R: 0, G: 8, B: 0 ist ein weiterer Zusatzbefehl.
• R: 0, G: 1, B: 0ist die Zeichenfolge für VAR_1, die unsere Gesamtsumme ist.
• R: 0, G: 3, B: 0ist eine Funktion, die einen String umkehrt. Im Kontext der Abfrage einer Zahl wird die umgekehrte Zeichenfolge in eine Zahl konvertiert.
• R: 0, G: 2, B: 1ist ein Integer-Abrufbefehl, der die in einer bereitgestellten Variablen gespeicherte Zahl abruft. Im Kontext der Abfrage einer Zeichenfolge (z. B. vom Befehl reverse) wird die Zahl in eine Zeichenfolge konvertiert.
• R: 0, G: 1, B: 1ist der Name VAR_2; unsere Iterationsvariable.
• R: 1, G: 0, B: 1ist die Markierung zum Beenden der Schleife und zum Zurückkehren zum Anfang der Schleife, wenn die Kriterien nicht erfüllt sind (wenn wir also die Schleife fortsetzen müssen). Andernfalls fahren Sie fort.
• R: 0, G: 0, B: 1 ist ein sehr einfacher Befehl println, der eine Zeichenfolge enthält.
• R: 0, G: 2, B: 1 Ruft eine Ganzzahl aus einer Variablen ab

• R: 0, G: 1, B: 0 ist der Name unserer Gesamtsummenvariable, VAR_1

  Alles in allem ist das Programm:

• Weist den Wert 0 zu VAR_1undVAR_2
• Schleifen von 0 bis zu einer in STDIN angegebenen Nummer
  • Fügt einen hinzu VAR_2
  • Fügt den ganzzahligen Wert der Umkehrung VAR_2zu hinzuVAR_1
• Druckt den Inhalt von VAR_1

Python 2 , 50 47 Bytes

-3 Bytes dank officialaimm!

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

Probieren Sie es online!

CJam , 12 Bytes

ri){sW%i}%:+

Probieren Sie es online!

-1 Dank an Business Cat .

Erläuterung:

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 wurden dank @ Adám durch die Umwandlung in ein Tradfn aus einem Zug gespielt

+/⍎⌽⍕⍳⎕

Probieren Sie es 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()

BEARBEITEN

Gemäß dem Kommentar von Kevin Cruijssenmöchte ich meine Antwort verbessern.

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 dank @Shaggy.

õs xw

Probieren Sie es online!

Erläuterung

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

Alte Lösung, 7 Bytes

Halten Sie dies, da es eine wirklich coole Verwendung von ist z2.

õs z2 x

Probieren Sie es online!

Erläuterung

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

Schale , 7 6 3 Bytes

ṁ↔ḣ

Probieren Sie es online!

Ungolfed / Erklärung

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

Probieren Sie es online!

RProgN 2 , 8 Bytes

{Ø.in}S+

Erklärt

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

Probieren Sie es online!

Pyth , 8 6 Bytes

^{-2 Bytes dank FryAmTheEggman!}

sms_`h

Probieren Sie es online!

Tcl , 66 Bytes

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

Probieren Sie es online!

Neim , 4 Bytes

Δ𝐫)𝐬

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!