रेंज, रिवर्स, सम!

Question

इनपुट के रूप में एक धनात्मक पूर्णांक 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 के लिए बहुत बहुत धन्यवाद।

Comments

अधिक परीक्षण मामले के परिणाम (गिने नहीं गए, क्षमा करें, लेकिन आप चाहें तो पार्स कर सकते हैं और यदि आप चाहें तो उनकी लाइन नंबर प्राप्त कर सकते हैं): इसे ऑनलाइन आज़माएं!

— स्टीफन

@StepHen>: D चारकोल और तेज़ है

— ASCII-only

प्रासंगिक

— सिल्वियो मेयोलो

OEIS A062918

— लीक

-1 क्योंकि यह निर्बाध है। यह सबसे अधिक लगता है, यदि नहीं, तो सभी प्रस्तुतियाँ एक ही दृष्टिकोण का उपयोग कर रही हैं। यह चुनौती समस्याओं का एक गुच्छा की तरह लगती है जो पहले से ही पूछी गई हैं, बस बिना किसी स्पष्ट शॉर्टकट के साथ एक साथ पाइप किया गया है।

— बजे फल

Answer 1

05AB1E , 3 बाइट्स

कोड

LíO

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

व्याख्या

L       # Range
 í      # Reverse
  O     # Sum

Comments

— डेट

@ETHproductions अच्छी तरह Reverseसे Reverse eachवास्तव में होना चाहिए ...

— आउटगॉल्फ

@EriktheOutgolfer यह सदिश नहीं है?

— केवल

@ ASCII- केवल 05AB1E वेक्टरकरण वास्तव में 1 स्तर गहरा है, only नहीं। इसके अलावा सिर्फ "रिवर्स" है R, जबकि í"रिवर्स प्रत्येक" है।

— आउटगोल्फर

Answer 2

बैश + जीएनयू के बर्तन, 24

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

इसे ऑनलाइन आज़माएं ।

व्याख्या

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

Answer 3

जावास्क्रिप्ट (ईएस 6), 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)

Answer 4

पर्ल 6 , 20 बाइट्स

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

झसे आज़माओ

विस्तारित:

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

Comments

क्या the संभवतः समानांतर में ’की आवश्यकता है? लगता है कि आप एक बाइट या दो को छोड़ कर छुटकारा पा सकते हैं।

— निधि मोनिका का मुकदमा

@QPaysTaxes सं। रेंज में प्रत्येक मान पर विधि को ».flipकॉल करता है .flip। ऐसा करने का अगला सबसे छोटा तरीका है .map(*.flip)जो 5 बाइट्स अधिक है।

— ब्रैड गिल्बर्ट b2gills

ओह, इसलिए मुख्य भाग "प्रत्येक" है, न कि "(संभवतः समानांतर में)"। हो सकता है कि वे उन्हें अलग कर दें।

— निधि मोनिका का मुकदमा

@QPaysTaxes मुझे यकीन नहीं है कि मुझे पता है कि आपका क्या मतलब ».flipहै एक हाइपर विधि कॉल है। मैं अलग हो सकता है »और .flipएक unspace का उपयोग करके \ मैं पहले की तरह ही; यह समझना कठिन होगा, क्योंकि यह एक qqww/ /निर्माण के अंत की तरह दिखेगा ( « a b "c d" »)।

— ब्रैड गिल्बर्ट

Answer 5

रेटिना , 41 36 35 बाइट्स

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

.+
$*
1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संपादित करें: सहेजे गए 5 बाइट्स @FryAmTheEggman के लिए धन्यवाद। सहेजे गए 1 बाइट @ PunPun1000 को धन्यवाद। स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

1
1$`¶

से एक सीमा बनाएं 1करने के लिए n।

1+
$.&

वापस दशमलव में परिवर्तित करें।

%O^$`.

प्रत्येक संख्या को उलट दें।

.+
$*

वापस एकता में परिवर्तित करें।

1

Sum और वापस दशमलव में परिवर्तित करें।

Comments

@FryAmTheEggman बाह, मैं उस के बारे में भूल रहा हूँ।

— नील

आप में की जरूरत नहीं ¶है.+¶ मैच लाइनों के पार से मिलान करेगा

— PunPun1000

@ PunPun1000 मुझे FryAmTheEggman के फिक्स होने से पहले इसकी ज़रूरत थी!

— नील

मुझे लगता O^$s`.है कि पूरे स्ट्रिंग को उलटने के लिए भी काम करता है।

— नील

Answer 6

जेली , 4 बाइट्स

Ṛ€ḌS

इसे ऑनलाइन आज़माएं!

कैसे?

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

Comments

मुझे लगता है कि वहाँ एक तरीका था निहितार्थ रेंज का उपयोग करने के लिए, +1

— nmjcman101

Answer 7

हास्केल, 34 बाइट्स

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

सरल और सीधा।

Answer 8

सी (जीसीसी) , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 9

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)

Answer 10

अजगर २ , 38 बाइट्स

पुनरावर्तन सीमा से अधिक शर्तों की गणना नहीं की जा सकती:

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

इसे ऑनलाइन आज़माएं!

Comments

आप उपयोग कर सकते हैं import sysऔर sys.setrecursionlimit()यदि आप बड़ी संख्याओं को संभालना चाहते हैं, तो टियो हेडर में।

— श्री एक्सकोडर

Answer 11

ब्रेकीलॉग , 4 बाइट्स

⟦↔ᵐ+

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Answer 12

रोड़ा , 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

Comments

आप [::-1]रिवर्स के बजाय का उपयोग करके बहुत सारे बाइट्स बचा सकते हैं । इसके अलावा ` $_` _..""parseInteger के बाद की तुलना में कम है और कोष्ठक की जरूरत नहीं है।

— fergusq

युक्तियों के लिए @fergusq धन्यवाद, मेरा रोड़ा थोड़ा कठोर हो गया है :)

— क्रिति लिथोस

Answer 13

सी # (.NET कोर) , 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>और स्ट्रिंग के बजाय रिटर्न को बदल देता है इसलिए मुझे इसे वापस स्ट्रिंग में बदलने के लिए कुछ अतिरिक्त जोड़ना पड़ा ताकि मैं इसे इंट में पार्स कर सकूं। हो सकता है कि IEnumerable<char>इंट से सही तरीके से जाने का एक छोटा तरीका हो ।

छोटे नोट में, यह फंक्शन्स Range() Reverse()और Sum()सभी को क्रम में उपयोग करता है ।

-6 बाइट्स TheLethalCoder का धन्यवाद

Comments

आपको अनुगामी अर्ध उपनिवेश की आवश्यकता नहीं है। मैं का उपयोग कर लगता है new int[r]और .Select((_,n)=>...)आप बाइट्स बचत होगी।

— TheLethalCoder

@ TheLethalCoder new int[r+1]सूचकांक को 0 से शुरू होने के बाद सही आउटपुट प्राप्त करने में लेता है, लेकिन यह अभी भी कुछ बाइट्स को बचाता है। आरआईपी Range()हालांकि

— कामिल Drakari

Answer 14

माणिक, 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 को धन्यवाद।

Comments

->n{साथ ही काम करता है।

— वैल्यू इंक

मैंने उसी टूल (रूबी) में एक छोटा प्रोग्राम तैयार किया है जो अलग है (यह इनपुट और आउटपुट से संबंधित है) इसका अपना सबमिशन है, आप इसे यहाँ पा सकते हैं: codegolf.stackexchange.com/a/150636/23030

— Unihedron

@ यूनीहेड्रॉन, हाहा, मुझे नहीं पता था कि रूबी स्ट्रिंग रेंज की अनुमति देने के लिए इतनी पागल है। धन्यवाद।

— अकोस्टैडिनोव

हां, रूबी में भी निफ्टी की तरह विशेषताएं हैं ?a..?zऔर ?a1..?h8(हालांकि आप दूसरे प्रारूप के साथ बेहतर हैं: डी)

— अनहाइड्रॉन

सीमाओं को या तो 1. (स्टार्ट वैल्यू के लिए) लागू करना होगा succऔर 2. (यदि या तो स्टार्ट या एंड वैल्यू लागू नहीं होती है succ) तो न्यूमेरिक है, इसलिए int..string"रेंज के लिए बैड वैल्यू" के रूप में रिजेक्ट हो जाएगा। उलटा सच है (लेकिन इसके अलावा कोई डाउन रेंज नहीं है), या (?1..n)इसके बजाय इस्तेमाल किया जा सकता है

— Unihedron

Answer 15

मैथेमेटिका, 47 बाइट्स

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

इसे ऑनलाइन आज़माएं! (गणित पर काम करने के लिए हमें "Tr" को "Total" से बदलना होगा)

Comments

Tr@*IntegerReverse@*Range

— ngenisis

Answer 16

चारकोल , 14 13 बाइट्स

-1 कार्लोस अलेजो को धन्यवाद

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

इसे ऑनलाइन आज़माएं!लिंक वर्बोज वर्जन के लिए है।

व्याख्या

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

Comments

आप एक बाइट को अंतिम ड्रॉप करके बचा सकते हैं »। वैसे, चारकोल विकी में Reduceऑपरेटर को दस्तावेज कहां दिया जाता है?

— चार्ली

कहीं नहीं, यह एक विभाजन का एक अधिभार है: | अगर आप चाहते हैं तो मैं आपको इसका उपयोग संपादित कर सकता हूं (क्षमा करें, मैं इसे स्वयं करने के लिए बहुत आलसी हूं)

— ASCII-only

हाँ, मैं यह भी भूल गया कि अंत में ब्रेसिज़ को छोड़ कर काम करता है

— केवल

मैं वास्तव में चारकोल विकी को थोड़ा और अधिक प्रलेखित करना चाहूंगा, क्योंकि अभी भी कुछ काम कर रहे हैं लेकिन छिपी हुई विशेषताएं हैं। यदि आप मुझे पहुंच प्रदान करते हैं तो मैं उन्हें दस्तावेज देने की पूरी कोशिश करूंगा। उदाहरण: Moduloचारकोल में तारों को प्रारूपित करने के लिए ऑपरेटर का उपयोग कैसे किया जा सकता है?

— चार्ली

@CarlosAlejo मेरे पास खाली समय का थोड़ा सा समय है इसलिए मैंने सामान का दस्तावेजीकरण शुरू कर दिया है, आशा है कि आप इसे पसंद करेंगे!

— नील

Answer 17

मैग्नेसन , 102 बाइट्स

यह बहुत दृश्यमान नहीं है, इसलिए यहां एक छोटा संस्करण है (नोट: वास्तव में नहीं चलेगा, और अभी भी बहुत सुंदर नहीं है)

मैग्नेसन एक छवि को पार्स करके और उसके द्वारा पढ़े जाने वाले पिक्सेल के रंगों से आदेशों का मूल्यांकन करता है। इस चुनौती के लिए छवि के माध्यम से कदम रखते हुए, हमारे पास है:

• R: 0, G: 1, B: 1एक पूर्णांक असाइनमेंट कमांड है, जो चर नाम और असाइन करने के लिए एक स्ट्रिंग लेता है। हम इसका उपयोग कुल योग को संग्रहीत करने के लिए करेंगे।
• R: 0, G: 1, B: 0 मूल्य के साथ एक पूर्वनिर्मित स्ट्रिंग है VAR_1 (ध्यान दें: यह केवल तब है जब हम एक स्ट्रिंग के लिए पूछ रहे हैं; रंग कोड का एक अलग फ़ंक्शन होता है जब अन्यत्र उपयोग किया जाता है)।
• R: 3, G: 0, B: 0एक कच्चा नंबर है। Magneson लाल घटक की आवश्यकता होती है वास्तव में 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: 0STDIN फ़ंक्शन है, या कम से कम यह तब होता है जब हमें एक नंबर की आवश्यकता होती है। यह कंसोल से इनपुट की एक पंक्ति को पढ़ता है और इसे एक नंबर में बदल देता है, क्योंकि हमने एक नंबर मांगा था।
• R: 0, G: 8, B: 0हमारे लूपिंग कोड को शुरू करता है, और यह एक एडिटिव कमांड है। यह एक पूर्णांक चर में एक संख्या जोड़ता है, और इसलिए चर नाम के लिए एक स्ट्रिंग लेता है, और जोड़ने के लिए संख्या।
• R: 0, G: 1, B: 1के लिए prebuilt स्ट्रिंग है 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 एक बहुत ही सरल प्रिंटल कमांड है, और एक स्ट्रिंग लेता है।
• R: 0, G: 2, B: 1 एक चर से पूर्णांक को पुनः प्राप्त करता है

• R: 0, G: 1, B: 0 हमारे कुल योग का नाम है, VAR_1

  सभी में, कार्यक्रम:

• मान 0 से VAR_1और पर असाइन करता हैVAR_2
• STDIN में दिए गए नंबर से 0 से लूप्स
  • एक को जोड़ता है VAR_2
  • को उलटने VAR_2का पूर्णांक मान जोड़ता हैVAR_1
• की सामग्री प्रिंट करता है VAR_1

Answer 18

पायथन 2 , 50 47 बाइट्स

आधिकारिक बाइट के लिए -3 बाइट्स धन्यवाद !

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

इसे ऑनलाइन आज़माएं!

Comments

चूंकि यह अजगर str3 बाइट्स के बजाय अजगर 2, `` है ।

— आधिकारिक '

Answer 19

CJam , 12 बाइट्स

ri){sW%i}%:+

इसे ऑनलाइन आज़माएं!

-1 बिजनेस कैट को धन्यवाद ।

स्पष्टीकरण:

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

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं? मैं सीजेएम (न ही गोल्फस्क्रिप्ट) को नहीं समझता। लेकिन मेरी ने दो (गोल्फ-लंग्स के मामले में प्राचीन) को हराकर गोल्फ की भाषाएं बनाईं!

— Zacharý

@ Zacharý किया ...

— निकले ऑगेल आउटफेलर

आप की जरूरत नहीं है,

— बिजनेस कैट

@BusinessCat ओह्ह जाहिरा तौर पर GolfScript के लिए बहुत ज्यादा इस्तेमाल किया ...

— एरिक आउटगोल्फ

Answer 20

एपीएल (डायलॉग) , 10 7 बाइट्स

3 बाइट्स एक ट्रेन से एक ट्रेडफ़न में परिवर्तित करके @ Adám के लिए धन्यवाद

+/⍎⌽⍕⍳⎕

इसे ऑनलाइन आज़माएं!

⎕          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

Comments

चैट प्रश्न के बारे में @Uriel & Cows ने चुटकी ली: ठीक है, मैंने गणित का भाग किया, इसके अलावा, मुझे चैट से निलंबित कर दिया गया है, इसलिए मेरा वहां कोई जवाब नहीं है।

— ज़ाचारि

7 बाइट्स:+/⍎⌽⍕⍳⎕

— Adám

@ टिप के लिए धन्यवाद। ¨चालाक को हटाना :)

— Kritii Lithos

Answer 21

जावा 8, 97 बाइट्स

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

---

संपादित करें

की टिप्पणी के अनुसार Kevin Cruijssen, मैं अपने उत्तर में सुधार करना चाहूंगा।

जावा 8, 103 बाइट्स

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

Comments

Integer.valueOfकरने के लिए गोल्फ हो सकता है new Integer, और .reverse().toString()करने के लिए गोल्फ हो सकता है .reverse()+""। इसके अलावा, आपको आवश्यक आयात और लंबो मापदंडों को शामिल करना चाहिए, जैसे java.util.stream.IntStreamऔर इसके n->पहले। और तुम भी गोल्फ कर सकते हैं IntStreamऔर Integerकरने के लिए LongStreamऔर Long। अंतिम उत्तर होगा n->java.util.stream.LongStream.range(1,n+1).map(i->new Long(new StringBuffer(""+i).reverse()+"")).sum()( 103 बाइट्स - जोड़ा गया आयात और लैम्ब्डा पैरामीटर के साथ आपका वर्तमान उत्तर 117 बाइट्स होगा ।) फिर भी +1, अच्छा जवाब!

— केविन क्रूज़सेन

@KevinCruijssen अपने बहुमूल्य इनपुट के लिए धन्यवाद। मैं अपना जवाब अपडेट करूंगा। धन्यवाद। :)

— CoderCroc

Answer 22

जाप , 7 5 बाइट्स

-2 बाइट्स @ शुग्गी को धन्यवाद।

õ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

Comments

तुम्हें पता है z2कि एक सपाट ऐरे पर उतने ही हैं w, उतने ही उह ... उह ... जाप में मेरी अपर्याप्तता ... बहाना

— ETHproductions

6 बाइट्स: õ_swÃxके नए जोड़ के लिए धन्यवाद N.s(f)।

— झबरा

या यहां तक ​​कि सिर्फ õs xw5 बाइट्स के लिए।

— झबरा

@ शैग्गी मैं विश्वास नहीं कर सकता कि किसी ने भी उस 5-बाइट सॉल्यूशन का उल्लेख अब तक नहीं किया है ... एक बिट में संपादित करेगा। 6-बाइट एक के रूप में, अगर इस चुनौती को पोस्ट किए जाने के बाद इसे जोड़ा गया था, तो मुझे लगता है कि यह गैर-प्रतिस्पर्धात्मक होगा।

— जस्टिन मैरिनर

@JustinMariner, न तो मैं कर सकता हूँ! : डी हालांकि, यह उस z2चाल को खाई करने के लिए शर्म की बात है ; यह बहुत लानत प्रतिभा थी। ध्यान दें कि गैर-प्रतिस्पर्धा अब कोई बात नहीं है ।

— झबरा

Answer 23

सी ++, 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;}

Comments

बहुत बढ़िया! आप शीर्ष लेख को हटाकर और "नेमस्पेस std का उपयोग करके" कुछ बाइट्स को अलग कर सकते हैं (यहां देखें tio.run/#cpp-gcc )। मुझे भी लगता है कि आप "ऑटो टी" को सिर्फ "टी" (?) से बदल सकते हैं

— koita_pisw_sou

हाँ, koita_pisw_sou पहले भाग के बारे में सही है। लेकिन आपको जरूरत है auto।

— ज़चारि

@koita_pisw_sou क्या आपका मतलब है कि मैं हेडर निर्देश को बाइट की गिनती से बाहर कर सकता हूं? नामस्थान के लिए भी? autoकीवर्ड की जरूरत है

— HatsuPointerKun

हां, मेरे द्वारा भेजे गए लिंक की जाँच करें

— koita_pisw_sou

(वूप्स, मैं हेडर को हटाने के बारे में निश्चित नहीं हूं!) लेकिन मैं using namespace std;बाइट्स बचाने की बात कर रहा था ।

— Zacharý

Answer 24

भूसी , 7 6 3 बाइट्स

ṁ↔ḣ

इसे ऑनलाइन आज़माएं!

Ungolfed / स्पष्टीकरण

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

Answer 25

पर्ल 5 , 29 27 22 + 1 ( -p) = 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

26 बाइट्स: map$r+=reverse,1..<>;say$r।

— डेनिस इबाव

इसे आगे भी प्रयोग करके समझे-p

— Xcali

Answer 26

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.

इसे ऑनलाइन आज़माएं!

Answer 27

पायथ , 8 6 बाइट्स

^{-2 बाइट्स फ्राइअमईएगमैन को धन्यवाद !}

sms_`h

इसे ऑनलाइन आज़माएं!

Comments

1 बाइट लंबा संस्करण, जो अंत में sms_`dSनिहित का दुरुपयोग नहीं करता है U।

— मिस्टर एक्सकोडर

Answer 28

Tcl , 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 29

नीम , 4 बाइट्स

Δ𝐫)𝐬

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

वैकल्पिक समाधान: 𝐈Ψ𝐫𝐬(समावेशी रेंज बनाएं, प्रत्येक तत्व को उल्टा करें, योग)

— ओएक्सएक्स

@ ओकेक्स को नहीं पता था कि Ψटोकन अस्तित्व में है! निश्चित रूप से उस दृष्टि में इस्तेमाल किया जाएगा। असली अच्छा

— अंतरिक्ष जंक

Answer 30

सी (जीसीसी) , 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;}

इसे ऑनलाइन आज़माएं!

Comments

रुको क्या? f()बिना किसी परिणाम के अपना परिणाम कैसे लौटाता हैreturn बयान के ? क्या e=aनिर्देश रजिस्टरों को इस तरह से हेरफेर करता है कि परिणाम उसी रजिस्टर में संग्रहीत किया जाता है जो लौटाए गए मूल्यों द्वारा उपयोग किया जाता है?

— स्कूटनीट