समांतर चतुर्भुज एक संख्या

18

अब जब हम जानते हैं कि किसी संख्या को सही ढंग से वर्ग और त्रिभुज कैसे बनाया जाता है , तो हम सीखना चाहते हैं कि समांतर चतुर्भुज कैसे करें। किसी संख्या को समांतर करने के लिए, हम सबसे पहले इसे अपने आप को एक संख्या के रूप में समांतर चतुर्भुज के रूप में व्यवस्थित करते हैं, जो इसके अंकों की संख्या के बराबर कई बार होता है, और इसे समांतर चतुर्भुज बनाने के लिए रिक्त स्थान जोड़ते हैं। तो 123फार्म होगा:

   123
  123
 123

अब हम प्रत्येक क्षैतिज और ऊर्ध्वाधर संख्या लेते हैं और उन्हें जोड़ते हैं 123+123+123+1+12+123+23+3, जो बराबर होता है 531, जो कि समांतर चतुर्भुज है 123।

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें, जिसे इनपुट के रूप में एक संख्या दी जाती है, संख्या के समांतरभुज को लौटाता है।

इनपुट:

एक गैर-नकारात्मक पूर्णांक, या एक स्ट्रिंग द्वारा प्रस्तुत गैर-नकारात्मक पूर्णांक।

आउटपुट:

पूर्णांक का समांतर चतुर्भुज।

परीक्षण के मामलों:

1234567 -> 10288049
123     -> 531
101     -> 417
12      -> 39

स्कोरिंग:

यह कोड-गोल्फ है , बाइट्स जीत में सबसे कम स्कोर!

code-golf  number 
— ग्रीफॉन - मोनिका को बहाल करना
स्रोत
— ग्रीफॉन -
क्यों होता है पतन?
— ग्रिफ़ॉन -

जवाबों:

9

MATL , 12 बाइट्स

tnEXyPY+c!Us

इनपुट एक स्ट्रिंग है। इसे ऑनलाइन आज़माएं!

व्याख्या

'123'उदाहरण के रूप में इनपुट पर विचार करें ।

कोड इनपुट को दोहराता है ( t) और एक पहचान मैट्रिक्स ( Xy) का आकार इनपुट लंबाई ( nE) से दोगुना बनाता है :

1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1

फिर इसे उल्टा कर देता है ( P):

0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0 0 0 0
1 0 0 0 0 0

इनपुट स्ट्रिंग, अंकों के एएससीआईआई कोड के रूप में व्याख्या की गई है, जो संख्यात्मक पंक्ति वेक्टर के बराबर है

49 50 51

Y+उपरोक्त वेक्टर और मैट्रिक्स के पूर्ण आकार के दो आयामी दृढ़ संकल्प ( )

 0  0  0  0  0 49 50 51
 0  0  0  0 49 50 51  0
 0  0  0 49 50 51  0  0
 0  0 49 50 51  0  0  0
 0 49 50 51  0  0  0  0
49 50 51  0  0  0  0  0

ASCII कोड के रूप में उन नंबरों की व्याख्या करना ( c) निम्नलिखित चार मैट्रिक्स देता है, जिसमें char 0 को स्पेस के रूप में दर्शाया गया है:

     123
    123 
   123  
  123   
 123    
123

ट्रांसपोज़िशन ( !) इसे में बदल देता है

     1
    12
   123
  123 
 123  
123   
23    
3

प्रत्येक पंक्ति को एक संख्या ( U) के रूप में व्याख्या करना संख्यात्मक स्तंभ वेक्टर देता है

  1
 12
123
123
123
123
 23
  3

और यह संक्षेप ( s), अंतिम परिणाम देता है 531।

— लुइस मेंडो
स्रोत
1
मुझे बदबू आ रही है ... सजा
— अदनान
1
@ अदनान और क्या? :-D
— लुइस मेंडो
6

रेटिना , 22 बाइट्स

.
$`;$&$';$_;
\d+
$*
1

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

— नील
स्रोत
6

05AB1E ,  12 11  8 बाइट्स

मुझे यकीन है यह पता था कि कर सकते हैं आगे golfed जा सकता है - सुझावों का स्वागत है!

-1 बाइट की बदौलत एरिक आउटगोलर (लपेटने से बचें, लेकिन कंफर्ट का इस्तेमाल करते हुए)
और फिर ...
अदनान के लिए -3 और बाइट्स धन्यवाद को गुणा करके लंबाई -१ से बचें और अंत में इनपुट को घटाएं)

.s¹η++Oα

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

कैसे?

.s¹η++Oα - implicit input, say i      e.g.  123
.s       - suffixes                         [3,23,123]
  ¹      - push i                           123
   η     - prefixes                         [1,12,123]
    +    - addition of top two              [4,35,246]
     +   - addition (vectorises)            [127,158,369]
      O  - sum                              654
       α - absolute difference abs(123-654) 531
         - implicit print
— जोनाथन एलन
स्रोत
आप «प्रत्ययों और उपसर्गों g<*¹.s¹η«O+
— को समाप्‍त
1
.s¹η++Oα8 बाइट्स के लिए काम करना चाहिए
— अदनान
धन्यवाद @ ErictheOutgolfer दो रैप मुझे अजीब लगे!
— जोनाथन एलन
@ अदनान - यह बहुत प्यारा है!
— जोनाथन एलन
@JonathanAllan "सुझावों का स्वागत है!" यकीन नहीं होता है कि आप किसी भी समय मिल जाएगा ...
— एरिक आउटगॉल्फ
5

हास्केल , 90 78 76 71 64 63 59 57 बाइट्स

g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]

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

— पोस्ट रॉक गार्फ हंटर
स्रोत
g x=sum[x+div x a+mod x a|(a,_)<-zip((10^)<$>[1..])$show x]।
— निमि
g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]अभी भी एक बाल छोटा है
— लिन
g x=sum[x+x`div`10^a+x`mod`10^a|(a,_)<-zip[1..]$show x]।
— लकोनी
4

भूसी , 13 12 बाइट्स

ṁit§+SRL§+ḣṫ

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

व्याख्या

              -- implicit input, say "123"
   §+         -- concatenate the results of the following two functions
     SR       --  ¹repeat the input n times, where n is the result of the next function
       L      --   length                                                  ["123","123"]
        §+   --  ²concatenate the results of the following two functions
          ḣ  --     prefixes                                              ["","1","12","123"]
           ṫ --     suffixes                                              ["123","23","3",""]
              -- inner concatenation                                      ["","1","13","123","123","23","3",""]
              -- outer concatenation                                      ["123","123","","1","13","123","123","23","3",""]
  t           -- all but the first element                                ["123","","1","13","123","123","23","3",""]
ṁ             -- map then sum
 i            --   convert to integer (where "" converts to 0)
— H.PWiz
स्रोत
4

पायथन 3 , 85 70 बाइट्स

f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)+i(n)or i(n)*2

इनपुट के लिए 12345:

स्ट्रिंग को अनुक्रमणिका (r) = 1,2,3,4 से पूर्णांक में डालने से पहले इनपुट 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, के स्लाइसों को जमा करें। , और 12345 * 2 में जोड़ता है

उन्हें विशेष धन्यवाद:

-14 बाइट्स @ जोनाथन एलन

-1 बाइट @ नोव्स

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

— कॉनर जॉनसन
स्रोत
TIO गलत कोड से लिंक करता है। ( ) के (len(n)+1)लिए गोल्फ हो सकता है , और फिर उपयोग करके एक और बाइट बचा सकता है । फिर आप इसे एक अनाम फ़ंक्शन बना सकते हैं: (74 बाइट्स)-~len(n)~x-1-x-i(n)*~len(n)lambda n,i=int:sum(i(n[:r])+i(n[r:])for r in range(1,len(n)))-i(n)*~len(n)
— जोनाथन एलन
इससे भी बेहतर है कि 71 बाइट्स के लिए फ़ंक्शन को पुनरावर्ती बनाएं:f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)or-i(n)*~len(n)
— जोनाथन एलन
1
— ovs
मैंने आपका tio लिंक ठीक कर दिया।
— श्री एक्सकोडर
3

जाप , 15 11 बाइट्स

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

¬£iYç
cUz)x

तार के रूप में इनपुट लेता है।

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

व्याख्या

£

इनपुट फ़ंक्शन को अंकों ( ¬) और मैप द्वारा ( £) निम्न फ़ंक्शन को विभाजित करें , जहां वाई इंडेक्स है।
["1", "2", "3"]

iYç

शुरुआत में Yरिक्त स्थान ( ç) डाला ( i) के साथ इनपुट मूल्य (निहित) । इसे सौंपा गया है U।
["123", " 123", " 123"]

cUz1)x

अपने आप को 90 ° दाएं ( 1समय) घुमाया गया । फिर योग ( x)।
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531।

— जस्टिन मेरिनर
स्रोत
वास्तव में मैं इसे कैसे करने की कोशिश कर रहा था, लेकिन मैं किसी कारण से, वहाँ नहीं जा सका - अच्छी तरह से किया गया :) यहाँ एक 13 बाइट संस्करण है।
— झबरा
— झबरा
@ बहुत अजीब, मुझे पता था कि प्रत्येक पंक्ति के लिए रिक्त स्थान को तैयार करने का एक छोटा तरीका था। धन्यवाद!
— जस्टिन मेरिनर
3

जाप , 31 18 बाइट्स

-13 बाइट्स @ETHproductions की बदौलत

यह दृष्टिकोण Japt का उपयोग करके अच्छी तरह से काम नहीं करता है। जस्टिन का समाधान ज्यादा बेहतर है।

[U*Ål U¬£tYÃUå+]xx

स्पष्टीकरण:

[U*Ål U¬£tYÃUå+]xx
[              ]    // Create a new array
 U*Ål               // Push: Input * Input.slice(1).length()
                    // Push:
      U¬            //   Input, split into chars
        £tY         //   Map; At each char: .substr(Index)
            Uå+     // Push: Cumulative reduce Input; with addition
                xx  // Sum all the items, twice

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

— ओलिवर
स्रोत
3
यही है, मैं इसके लिए एक शॉर्टकट जोड़ रहा हूं Ul : P
— ETHproductions
हम्म ... आपको Uफ़ंक्शंस में दोनों में से किसी की ज़रूरत नहीं है , और सरणी में मध्य आइटम के लिए संघनित किया जा सकता है Uå+ x, जो मुझे लगता है कि आपको 23 बाइट्स तक ले जाता है।
— ETHproductions
@ETHproductions धन्यवाद! मैंने इसे एरी आइटम्स को रीक्रिएट करके एक और बाइट को नीचे लाया।
— ओलिवर
आप बदल सकते हैं mx xकरने के लिए xx? :-)
— ETHproductions
@ETHproductions मुझे यकीन है कि, धन्यवाद फिर से :)
— ओलिवर
2

रूबी , 61 55 + 1 = 56 बाइट्स

-nझंडे का उपयोग करता है । एसटीडीआईएन से इनपुट

p (1..~/$/).sum{|i|[$_[i,~/$/],$_[0,i],$_].sum &:to_i}

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

— मूल्य स्याही
स्रोत
इनपुट के लिए 102033आपका प्रोग्राम प्रिंट करता है 728714जबकि सही मान है 729702।
नहीं! आप उत्तर समीक्षा को पूरा करें! (brb फिक्सिंग, 02033मुद्दा था)
— वैल्यू इंक
मुझे लगता है कि अष्टक संख्या समस्या है, लेकिन मुझे यकीन नहीं था (मुझे पता नहीं है कि रूबी)। स्पष्ट करने के लिए धन्यवाद :)
@ ThePirateBay कोई समस्या नहीं; मैं पहले से ही एक छोटे, वैकल्पिक समाधान पर काम कर रहा था जो स्ट्रिंग इनपुट ले गया था, और यहां तक ​​कि फिक्स के साथ भी मुझे वास्तव में किसी भी तरह से बाइट्स बचाने की जरूरत थी :)
— मान स्याही इंक
2

जावास्क्रिप्ट, 77 74 बाइट्स

मूल्य स्याही के लिए 3 बाइट्स सहेजे गए

f=a=>[...a+a].map((_,b)=>a-=-z.substr((b-=n)>0?b:0,b+n),a*=n=(z=a).length)|a

console.log(f('123'));
console.log(f('101'));
console.log(f('12'));
console.log(f('1234567'));
console.log(f('102033'));
स्निपेट का विस्तार करें

1

पायथ , 20 19 बाइट्स

मेरा वर्तमान उपसर्ग दृष्टिकोण (उम्मीद है कि आगे गोल्फ होगा)।

+*tlQsQssM+_M.__Q._

परीक्षण सूट या एक ही बाइट गिनती के साथ एक वैकल्पिक दृष्टिकोण का प्रयास करें ।

व्याख्या

+*tlQsQssM+_M.__Q._  - Full program that reads a String from STDIN, with implicit input.

  tlQ                - Length of the input - 1.
     sQ              - The input converted to an integer.
 *                   - Product of the above two elements. We will call this P.
                 ._  - Prefixes of the input.
          +          - Concatenated with:
           _M.__Q    - The prefixes of the reversed input, reversed.
        sM           - Convert each to an integer.
       s             - Sum.
+                    - Addition of the product P and the sum above.

अवधारणा को बेहतर ढंग से समझने के लिए, हम एक उदाहरण लेंगे, कहते हैं "123" ।

  • हमें सबसे पहले इनपुट के उपसर्ग मिलते हैं। वो है['1', '12', '123'] ।

  • फिर, हमें उल्टे इनपुट के उपसर्ग मिलते हैं, अर्थात: ['3', '32', '321'] और प्रत्येक को उल्टा करते हैं, इसलिए हम प्राप्त करते हैं ['3', '23', '123']।

  • हम दो सूचियों को मिलाते हैं और प्रत्येक तत्व को पूर्णांक में परिवर्तित करते हैं, इसलिए हम प्राप्त करते हैं [3, 23, 123, 1, 12, 123] ।

  • सूची संक्षेप में, परिणाम है 285 ।

  • उत्पाद Pइनपुट की लंबाई है - 1 (यानी2 ) इसके पूर्णांक प्रतिनिधित्व से गुणा ( 2 * 123 = 246)।

  • अंत में, हम दो परिणामों को 285 + 246जोड़ते हैं : इसलिए हम प्राप्त करते हैं 531, जो कि सही परिणाम है।

अजगर , 20 बाइट्स

+*hlQsQsm+s>Qds<QdtU

परीक्षण सूट।

व्याख्या

आगे गोल्फिंग के बाद आने के लिए स्पष्टीकरण। मैं इसके लिए आगे गोल्फ में सफल नहीं हुआ (मेरे पास हालांकि विचार हैं)।

+*hlQsQsm+s>Qds<QdtUQ  - Full program. Reads from STDIN. Q means input, and is implicit at the end.

  hlQ                  - Length of the input + 1.
     sQ                - The input converted to an integer.
 *                     - Multiply the above. We'll call the result P.
        m         tUQ  - Map over [1...length of the input)
          s>Qd         - input[currentItem:] casted to an integer.
              s<Qd     - input[:currentItem] casted to an integer.
         +             - Sum the above.
       s               - Sum the list.
+                      - Add the sum of the list and P.
— मिस्टर एक्सकोडर
स्रोत
1

क्यू / केडीबी +, ३४ बाइट्स

समाधान:

{sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}

उदाहरण:

q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"1234567"
10288049
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"123"    
531
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"101"    
417
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"12"     
39

स्पष्टीकरण:

{sum"J"$((c#c),c-til 2*c:count x)#\:x} / ungolfed
{                                    } / lambda function
                                    x  / implicit input
                                 #\:   / apply take (#) to each-left element with the right element
        (                       )      / the left element
                       c:count x       / count length and save in variable c
                     2*                / multiply by 2 (e.g. 6)
                 til                   / range, so 0 1 2 3 4 5
               c-                      / vector subtraction, so 3 2 1 0 -1 -2
         (   )                         / do this together
          c#c                          / 3 take 3, so 3 3 3
              ,                        / join, so 3 3 3 3 2 1 0 - 1 -2          
    "J"$                               / cast this "123", "123", "123" .. "23" to longs
 sum                                   / sum them up and return result
— streetster
स्रोत
1

स्विफ्ट 3 , 213 बाइट्स

func f(n:String){print((n.characters.count-1)*Int(n)!+(0..<n.characters.count).map{r in Int(n[n.index(n.startIndex,offsetBy:r)..<n.endIndex])!+Int(n[n.startIndex..<n.index(n.endIndex,offsetBy:-r)])!}.reduce(0,+))}

इसे ऑनलाइन परीक्षण नहीं किया जा सकता है, क्योंकि यह धीमा और समय से बाहर है। यदि आप इसका परीक्षण करना चाहते हैं, तो आप इसे स्विफ्ट प्लेग्राउंड में आज़मा सकते हैं।

नमूना चला

इनपुट:

च (एन: "123")
च (एन: "101")
च (एन: "1234567")

आउटपुट:

531
417
10288049
— मिस्टर एक्सकोडर
स्रोत
1

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

LḶṚ⁶ẋ;€µ;ZVS

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

एक स्ट्रिंग के रूप में इनपुट लेता है। वर्णों के एक मैट्रिक्स के रूप में "समांतर चतुर्भुज" बनाता है, फिर संख्याओं को प्राप्त करने के लिए प्रत्येक पंक्ति और स्तंभ का मूल्यांकन करता है।

व्याख्या

LḶṚ⁶ẋ;€µ;ZVS  Input: string S
L             Length
 Ḷ            Lowered range - [0, 1, ..., len(S)-1]
  Ṛ           Reverse
   ⁶          The char ' ' (space)
    ẋ         Create that many characters of each in the range
     ;€       Prepend each to S
       µ      Begin a new monadic chain
        ;     Concatenate with
         Z    Transpose
          V   Eval each string
           S  Sum
— मील की दूरी पर
स्रोत
1

सी (जीसीसी) ,95 8481 बाइट्स (78 + -lmसंकलक ध्वज)

नमस्ते! यह मेरा पहला सबमिशन है, मुझे उम्मीद है कि मैंने कोई नियम नहीं तोड़ा।

g,o,l;f(char*s){l=atoi(s);while(s[o++])g+=l/pow(10,o)+atoi(s+o);return g+l*o;}

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

बिना किसी चेतावनी के अधूरा,

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g,o,l;

int f(char *s){
  l = atoi(s);

  while(s[o++]) {
    g+=l/pow(10,o)+atoi(s+o);
  }

  return g+l*o;
}

int main(void){
  printf("%d\n",f("1234567"));
  return 0;
}
— scottinet
स्रोत
मुझे मान्य लगता है :)
— Okx
हम्म, -lmगणित कार्यों के लिए केवल कुछ सी रनटाइम जैसे उदाहरण के लिए आवश्यक है glibc। MinGW के साथ उदाहरण संकलित करना (Microsoft का उपयोग करके msvcrt.dll), इसकी आवश्यकता नहीं होगी। तो यकीन है कि यह यहाँ जोड़ने के लिए आवश्यक नहीं है? वैसे भी, अगर आप इसे जोड़ते हैं, तो यह 3 बाइट्स बना देगा;)
— फेलिक्स पालमेन
दुर्भाग्य से, जीसीसी के साथ फ़ंक्शन के -lmलिए आवश्यक है pow()। मैंने इसके बिना काम करने की कोशिश की, लेकिन 6 बाइट्स (पाव + कंपाइलर फ्लैग) से कम का उपयोग करके कोई समाधान नहीं ढूंढ सका। मुझे इस बात का नियम नहीं मिला कि झंडे को बायटेकाउंट में कैसे शामिल किया जाए, और मुझे पता है कि मैंने -चरित्र को न गिनने वाले चरित्र के बारे में गलत धारणा बनाई थी । मैं अभी एक +1 बाइट जोड़ रहा हूं।
— स्कूटनीट
-lmद्वारा आवश्यक नहीं है, gccलेकिन इस तथ्य से कि glibcमुख्य पुस्तकालय में गणित फ़ंक्शन शामिल नहीं हैं। msvcrt.dllकरता है, इसलिए gccबिना काम करता है के साथ खिड़कियों पर संकलन -lm। यह नाइटपैकिंग है और मुझे पूरी तरह से यकीन नहीं है कि इस बारे में नियम वास्तव में क्या कहना है।
— फेलिक्स पाम्स
सिर के लिए धन्यवाद :) मैं आपके प्रस्ताव की कोशिश करने में असमर्थ हूं और
— टियो
1

जावा 8, 147 137 126 116 114 बाइट्स

n->{Integer l=(n+"").length(),r=n*l,i=0;for(;++i<l*2;)r+=l.valueOf((n+"").substring(i>l?i-l:0,i<l?i:l));return r;}

-13 बाइट्स (137 → 126 और 116 → 114) @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                          // Method with integer as parameter and return-type
  Integer l=(n+"").length(),  //  Length of the input integer
      r=n*l,                  //  Result-integer (starting at `n*l`)
      i=0;                    //  Index-integer (starting at 0)
  for(;++i<l*2;               //  Loop from 0 through two times `l` (exclusive)
    r+=                       //   Add to the result-integer sum:
       l.valueOf((n+"").substring(
                              //    Substring of input, converted to integer:
        i>l?                  //     If `i` is larger than `l`:
         i-l                  //      Substring starting at `i-l`
        :                     //     Else:
         0,                   //      Substring starting at 0
        i<l?                  //     If `i` is smaller than `l`:
         i                    //      Substring ending at `i` (exclusive)
        :                     //     Else:
         l)                   //      Substring ending at `l` (exclusive)
  );                          //  End of loop
  return r;                   //  Return resulting sum
}                             // End of method
— केविन क्रूज़सेन
स्रोत
1
114 बाइट्स n->{Integer l=(n+"").length(),s=n*l,i=0;for(;++i<l*2;)s+=l.valueOf((n+"").substring(l<i?i-l:0,i<l?i:l));return s;}:। यह न्यूनतम करने के लिए कॉल की संख्या को कम करने के लिए न्यूनतम-अधिकतम के साथ एक स्लाइडिंग विंडो हैnew Integer(....substring(...))
— ओलिवियर ग्रेजायर
1
@ OlivierGrégoire धन्यवाद, और भी बदलकर और करने के Math.max(0,i-l)लिए कुछ और छोटा कर सकते हैं । इसे अब संशोधित कर रहा है। आह, मैंने देखा कि आपने 126 बाइट्स उत्तर की नकल करने के बाद अपनी टिप्पणी संपादित की है। ;)0>i-l?0:i-lMath.min(i,l)i>l?l:i
— केविन क्रूज़सेन
हाँ, संपादन के लिए खेद है, लेकिन मैंने इसकी जाँच नहीं की थी;)
— ओलिवियर ग्रेजायर 12
1

आर , 168 162 103 बाइट्स

सी () का उपयोग नहीं करके -6 बाइट्स

-59 बाइट्स @Giuseppe की बदौलत

function(n){k=nchar(n)
a=k*strtoi(n)
for(i in 1:k)for(j in i:k)a=a+(i==1|j==k)*strtoi(substr(n,i,j))
a}

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

एक स्ट्रिंग के रूप में इनपुट लेता है।

मैं पूरी तरह से कुछ सुधार कर रहा हूं, मुख्य रूप से आर की किसी भी ताकत का लाभ उठाने में ... लेकिन एक चुनौती है कि मूल रूप से स्ट्रिंग हेरफेर है, मैं यह देखने के लिए संघर्ष कर रहा हूं कि कैसे।

संपादित करें: अब बेहतर है कि मैं एक बुरे विचार पर पुनरावृत्ति नहीं कर रहा हूँ!

— CriminallyVulgar
स्रोत
1
— Giuseppe
@Giuseppe आह धन्यवाद! जब मैं अभी भी एक पूर्णांक इनपुट का उपयोग कर रहा था, तब से बहुत सारी बर्बाद जगह थी। मैं स्ट्रैटो (रूट ()) तरीका पसंद करता हूं, और ((ए। बी) की चाल मेरे मुकाबले अधिक चालाक है। सुधार के लिए धन्यवाद! यह इस बिंदु पर लगभग एक अलग जवाब है ...
— CriminallyVulgar
ऐसा तब होता है जब आप एक और दृष्टिकोण जोड़ते हैं! मैं अपने आप को छोरों का पता नहीं लगा सका, लेकिन मुझे लगता है कि आप substrलूपिंग के बजाय स्पष्ट रूप से सूचकांकों का निर्माण करने में सक्षम हो सकते हैं , जो कुछ बाइट्स को बचाएगा।
— ग्यूसेप
0

गणितज्ञ, 77 बाइट्स

(s=IntegerDigits@#;t=Length@s;Tr[FromDigits/@Table[s~Take~i,{i,-t,t}]]+t#-#)&
— J42161217
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.