चुनौती

इस तरह के रूप में एक स्ट्रिंग को देखते हुए Hello World!यह टूट अपने चरित्र मूल्यों में,: 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33।

फिर वर्णों की प्रत्येक लगातार जोड़ी के बीच अंतर की गणना करें 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67:।

अंत में, उन्हें योग करें और अंतिम परिणाम प्रिंट करें -39:।

नियम

मानक खामियां लागू होती हैं
पूर्व-निर्मित कार्यों का उपयोग नहीं करना जो इस सटीक कार्य को करते हैं
रचनात्मक समाधानों को प्रोत्साहित किया
मज़े करो
इसे कोड-गोल्फ के रूप में चिह्नित किया गया है, बाइट्स जीत में सबसे छोटा उत्तर है, लेकिन चयनित नहीं होगा।

— dkudriavtsev
स्रोत

16

डेनिस के अवलोकन से पता चलता है कि यह कार्य आवश्यकता से अधिक जटिल तरीके से संचालित है।

— ग्रेग मार्टिन

क्या कोई भाषा किसी वर्ण सरणी के रूप में इनपुट को स्वीकार कर सकती है, भले ही वह स्ट्रिंग प्रकारों का समर्थन करती हो?

— पोक

@Poke सॉरी, एक तार होना है

— dkudriavtsev

@GregMartin मुझे वास्तव में उस समय तक एहसास नहीं हुआ था। चुनौती हालांकि इस तरह से रहना चाहिए।

— dkudriavtsev

@DJMcMayhem पता करने के लिए अच्छा है, आउटपुट के अन्य सभी प्रकार इसके द्वारा अनुमत हैं।

— dkudriavtsev 20

38

पायथन, 29 बाइट्स

lambda s:ord(s[-1])-ord(s[0])

अंतरों का योग एक दूरबीन श्रृंखला बनाता है, इसलिए अधिकांश सारांश रद्द हो जाते हैं और
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) +… + (s _n-1 - s _n-2 ) + (s _n -) s _n-1 ) = s _n - s ₀ ।

यदि इनपुट के रूप में बाइट स्ट्रिंग लिया जाता है

lambda s:s[-1]-s[0]

19 बाइट्स के लिए भी काम करेगा ।

Ideone पर दोनों का परीक्षण करें ।

— डेनिस
स्रोत

क्या यह परिणाम प्रिंट करता है?

— dkudriavtsev

4

एक REPL में, मुझे लगता है कि यह करता है। आउटपुट का इच्छित रूप एक वापसी मूल्य है, हालांकि, जो आउटपुट के हमारे डिफ़ॉल्ट तरीकों में से एक है। यदि इसकी अनुमति नहीं है, तो उत्पादन भाषाओं के अधिकांश उत्तर अमान्य हैं।

— डेनिस

22

MATL , 2 बाइट्स

ds

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

स्पष्टीकरण:

dलगातार वर्णों के बीच अंतर प्राप्त करता है और sपरिणामी सरणी को समेटता है। फिर, स्टैक के शीर्ष पर मान को स्पष्ट रूप से मुद्रित किया जाता है। उस बारे में कहने के लिए और कुछ नहीं।

दिलचस्प रूप से पर्याप्त है, भले ही डेनिस ने एक भयानक शॉर्टकट की खोज की, इसका उपयोग करना MATL में काफी लंबा होगा।

— जेम्स
स्रोत

9

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

OIS

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

लो Oइनपुट स्ट्रिंग के पात्रों में से rdinals, तो Iफिर उस सूची के ncrements, Sकी उम कि सूची।

— लिन
स्रोत

हां, परिणाम को प्रिंट करना (और पहली जगह में इनपुट लेना) जेली में निहित है।

— लिन

6

MATLAB, 16 बाइट्स

@(x)sum(diff(x))

यह एक अनाम फ़ंक्शन बनाता है ansजिसे नाम दिया जा सकता है जैसे ans('Hello world!'):।

यहां ऑक्टेव में एक ऑनलाइन डेमो दिया गया है, जिसमें +तत्व-से-तत्व अंतर की गणना करने से पहले इनपुट स्ट्रिंग को स्पष्ट रूप से एक संख्यात्मक सरणी में बदलने के लिए आवश्यक है

— Suever
स्रोत

4

पायथन, 63 बाइट्स

x=map(ord,input())
print sum(map(lambda(a,b):b-a,zip(x,x[1:])))

Ideone यह!

— तांबा
स्रोत

3

क्यूबिक्स , 13 बाइट्स

क्यूबिक्स एक घन के चारों ओर लिपटी एक 2-आयामी भाषा है।

i?u//O-t#;/.@

इसे ऑनलाइन टेस्ट करें!निम्नलिखित घन नेट के लिए यह मानचित्र:

    i ?
    u /
/ O - t # ; / .
@ . . . . . . .
    . .
    . .

जहाँ IP (इंस्ट्रक्शन पॉइंटर) दूर-बाएं चेहरे के ऊपरी-बाएँ से शुरू होता है।

यह काम किस प्रकार करता है

सबसे पहले, आईपी दर्पण को हिट करता है /जो इसे iशीर्ष चेहरे पर रीडायरेक्ट करता है । शीर्ष चेहरा एक लूप है जो ईओएफ तक पहुंचने तक लगातार इनपुट करता है। जब इनपुट खाली होता है, तो परिणाम i-1 होता है; IP दायें से बाएं मुड़ता है ?, /दायीं ओर के चेहरे पर मारता है और निम्नलिखित कमांड से गुजरता है:

; - शीर्ष आइटम पॉप (-1)।
# - स्टैक की लंबाई पुश करें।
t- शीर्ष आइटम को पॉप करें और स्टैक में उस इंडेक्स पर आइटम प्राप्त करें। यह नीचे की वस्तु को ऊपर खींचता है।
- - घटाना।
O - पूर्णांक के रूप में आउटपुट।
/- आईपी को परिभाषित करता है @, जो कार्यक्रम को समाप्त करता है।

— ETHproductions
स्रोत

3

सी #, 22 बाइट्स

s=>s[s.Length-1]-s[0];

परीक्षण के मामले के साथ पूर्ण स्रोत कोड:

using System;

namespace StringCumulativeSlope
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,int>f= s=>s[s.Length-1]-s[0];
            Console.WriteLine(f("Hello World!"));
        }
    }
}

LINQ, 17 बाइट्स के साथ C #

एक छोटा संस्करण, LINQ का उपयोग करके, hstde के लिए धन्यवाद :

s=>s.Last()-s[0];

हालांकि, एक अतिरिक्त आयात आवश्यक है:

using System.Linq;

— adrianmp
स्रोत

2

s=>s.Last()-s[0];केवल 17 बाइट्स होंगे

— hstde

3

रूबी, 23 बाइट्स

->s{s[-1].ord-s[0].ord}

जैसे वेरिएबल को असाइन करें f=->s{s[-1].ord-s[0].ord}और जैसे कॉल करेंf["Hello World!"]

टेलिस्कोपिक श्रृंखला के बारे में डेनिस के अवलोकन का उपयोग करता है।

— dkudriavtsev
स्रोत

आपको आउटपुट प्रिंट करने की आवश्यकता नहीं है, केवल इसे वापस करें, ताकि आप छुटकारा पा सकें $><<।

— जॉर्डन

1

हां, मैंने सवाल भी पढ़ा। सौभाग्य से, "आउटपुट" की परिभाषा पर व्यापक सहमति है (यह भी देखें: इस पृष्ठ पर कई उत्तर जो मूल्य प्रिंट करने के बजाय लौटते हैं)। लेकिन हे, यह आपका कोड है।

— जॉर्डन

2

जालीदार, 12 बाइट्स

idVc~@qVc-o;

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

डेनिस के अवलोकन का उपयोग करते हुए , हम एक पुनरावृत्त प्रक्रिया को एक सरल में छोटा कर सकते हैं।

idVc~@qVc-o;
i             take input
 d            duplicate
  V           pop input copy, push last character
   c          get its char code
    ~         put it under the input in the stack
     @q       reverse the item at the top of the stack
       V      get the last item of that (first item of input)
        c     convert to char
         -    subtract
          o   output
           ;  and terminate

— कोनोर ओ ब्रायन
स्रोत

2

ब्रेन-फ्लैक , 51 बाइट्स

-aध्वज के लिए कोड प्लस तीन बाइट्स के 48 बाइट्स , जो ASCII इनपुट (लेकिन दशमलव आउटपुट को सक्षम बनाता है। कितना सुविधाजनक है: डी)

{([{}]({})<>)<>}<>{}([]<>){({}[()])<>({}{})<>}<>

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

यह लोगों को एक छोटे से , मेरे दूसरे सवाल का जवाब की तुलना में कठिन सा haha। इससे चलें।

{           While the top of the stack is nonzero:
 (            Push:
  [{}]          The top of the stack times negative one. Pop this off.
  ({})          Plus the value on top of the stack, which is duplicated to save for later.
  <>          On to the other stack
 )
 <>         Move back to the first stack
}
<>          After the loop, move back again.
{}          We have one extra element on the stack, so pop it
([]<>)      Push the height of the alternate stack back onto the first stack
{           While the top of the stack is nonzero:
 ({}[()])     Decrement this stack
 <>           Move back to the alternate stack
 ({}{})       Sum the top two elements
 <>           Move back tothe first stack
}
<>          Switch back to the stack holding the sum

— जेम्स
स्रोत

2

05AB1E , 3 बाइट्स

Ç¥O

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

CP-1252 एन्कोडिंग का उपयोग करता है।

व्याख्या

Ç       Converts input string to ASCII
¥       Compute difference between successive elements
O       Sum the result

— सवर
स्रोत

अच्छा ठीक है। माफ़ करना।

— dkudriavtsev

2

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

@c$)@[-

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

व्याख्या

@c        Convert "Hello World!" to [72,101,108,108,111,32,87,111,114,108,100,33]
  $)      Circular permute right: [33,72,101,108,108,111,32,87,111,114,108,100]
    @[    Take a prefix of the list
      -   Subtract

चूंकि घटाव केवल दो पूर्णांकों के इनपुट के लिए काम करता है, यह एक बार चयनित उपसर्ग होने पर सफल होगा [33, 72]।

— Fatalize
स्रोत

2

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

g=fromEnum
f t=g(last t)-g(t!!0)

— डेमियन
स्रोत

@ निम्मी यह वही है।

— xnor

2

आर, 69 43 32 बाइट्स

एक बहुत ही गैर-प्रतिस्पर्धात्मक उत्तर, हालांकि मुझे लगा कि आर में एक संभावित समाधान प्रदर्शित करना मजेदार होगा।

sum(diff(strtoi(sapply(strsplit(readline(),"")[[1]],charToRaw),16L)))

इस उत्तर का एकमात्र दिलचस्प पहलू का उपयोग sapplyऔर है charToRaw। पहले मैंने स्ट्रिंग को उन वर्णों के वेक्टर में विभाजित किया, जिन्हें मैं अपने ASCII पूर्णांक अभ्यावेदन में बदलना चाहता हूं। charToRawसमारोह आर में और इसके बजाय ऊपर उल्लिखित वेक्टर मैं प्रयोग में प्रत्येक मान से अधिक पाशन की vectorized नहीं है sapplyजो प्रभावी रूप से समारोह vectorizes। बाद में 1 अंतर लें और फिर योग करें।

संपादित करें: charToRawएक स्ट्रिंग को एक वेक्टर में बदल देता है जहां प्रत्येक तत्व प्रत्येक वर्ण का कच्चा प्रतिनिधित्व है, इसलिए उपयोग करने की आवश्यकता नहीं है strsplitऔरsapply

sum(diff(strtoi(charToRaw(readline()),16)))

Edit2: पता चला है कि एक और भी बेहतर तरीका है, फ़ंक्शन utf8ToInt(x)ठीक वही करता है strtoi(charToRaw(x),16)जिसका अर्थ है कि हम कुछ और बाइट्स (आइडिया @ rturnbull के जवाब से दूसरे प्रश्न के लिए लिया गया ) को बचा सकते हैं :

sum(diff(utf8ToInt(readline())))

— Billywob
स्रोत

2

पर्ल, 19 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट को अंतिम नई लाइन के बिना दें

echo -n "Hello World!" | slope.pl; echo

slope.pl:

#!/usr/bin/perl -p
$_=-ord()+ord chop

यदि आप सुनिश्चित हैं कि इनपुट स्ट्रिंग में कम से कम 2 अक्षर हैं तो यह 17 बाइट संस्करण भी काम करता है:

#!/usr/bin/perl -p
$_=ord(chop)-ord

— टन हास्पेल
स्रोत

2

NodeJS, 82 बाइट्स

x=process.argv[2],a=[],t=0;for(y in x)a[y]=x.charCodeAt(y),t+=y!=0?a[y]-a[y-1]:0

स्पष्टीकरण:

x = process.argv[2] // Get the input
a=[], // Initializes an array to store the differences' values.
t=0;  // Initializes a variable to store the total of the differences
for(y in x) // Iterates over the string as an array of characters
    a[y]=x.charCodeAt(y) // Transforms the input into an array of integers
    t+=y!=0?a[y]-a[y-1]:0 // Add the difference of the last two characters, except at the first iteration

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

f=x=>{a=[],t=0;for(y in x)a[y]=x.charCodeAt(y),t+=y!=0?a[y]-a[y-1]:0;return t}

एक तर्क के बजाय एक फ़ंक्शन इनपुट के साथ समान विचार।

— Alexis_A
स्रोत

क्षमा करें, लेकिन आप यह नहीं मान सकते xकि इनपुट है। आपको वास्तव में इनपुट प्राप्त करने की आवश्यकता है।

— R

क्या यह इस तरह से काम करता है?

— एलेक्सिस_ए

हाँ, यह बहुत अच्छा काम करता है!

— R

1

इनपुट प्राप्त करने का एक और स्वीकार्य तरीका एक फ़ंक्शन बनाना है। उदाहरण f=x=>{...;return t}के लिए 2 बाइट्स को बचाने के लिए ;)

— joeytwiddle

2

जावास्क्रिप्ट ईएस 6, 42 39 बाइट्स

f=
     s=>s[x='charCodeAt'](s.length-1)-s[x]();
;

console.log(f.toString().length);      // 39
console.log(f('Hello World!'))         // -39

स्निपेट का विस्तार करें

टेलीस्कोप रकम के बारे में @ डेनिस अवलोकन का उपयोग करना।

~~मुझे लगता है कि इस मामले में तुच्छ समाधान सबसे छोटा है।~~

charCodeAt@Neil द्वारा सुझाए गए दोहराव से छुटकारा पाने के लिए 3 बाइट्स सहेजे गए।

— Lmis
स्रोत

सबसे अच्छा मैं कर सकता था, s=>s.slice(-1).charCodeAt()-s.charCodeAt()जो एक ही लंबाई का निकला।

— नील

वास्तव charCodeAtमें काफी लंबा है, पुनरावृत्ति से बचने के लिए बाइट्स को बचाने का एक तरीका है।

— नील

@Neil सुझाव के लिए धन्यवाद, जिसने मुझे 3 बाइट्स बचाए।

— लमिस

थोड़ा पुनरावर्ती दृष्टिकोण कुछ बाइट्स लंबा है:f=s=>(s[1]?-f(s.slice(-1)):0)-s.charCodeAt()

— ETHproductions

2

फोर्थ, 28 बाइट्स

: f depth 1- roll swap - . ;

स्टैक पर वर्णों की एक सूची लेता है (पैरामीटर लेने के लिए फोर्थ की मानक विधि।) अक्षर ऐसे लिए जाते हैं कि स्टैक के शीर्ष स्ट्रिंग का पहला वर्ण होता है। मैं स्टैक के निचले हिस्से को ऊपर की ओर ले जाता हूं, स्वैप करता हूं, फिर घटाना और प्रिंट करता हूं। कचरे को ढेर पर छोड़ दिया जाता है, और आउटपुट स्टैडआउट पर मुद्रित किया जाता है।

यदि प्रत्येक वर्ण को रिवर्स ऑर्डर के बजाय स्टैक में धकेल दिया गया, तो प्रोग्राम 2 बाइट्स छोटा होगा। निश्चित नहीं है कि इसकी अनुमति है, हालांकि, क्योंकि आम तौर पर आप उल्टे क्रम में तर्क देते हैं।

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

इस तरह कहा जाता है:

33 100 108 114 111 87 32 111 108 108 101 72 f

— mbomb007
स्रोत

2

जावा, ४२

int f(char[]c){return c[c.length-1]-c[0];}

Ungolfed:

  int f(char[] c) {
    return c[c.length - 1] - c[0];
  }

स्पष्टीकरण:

यह टेलीस्कोपिंग के समान सिद्धांत का उपयोग करता है:

sum =
  c[4] - c[3]
+        c[3] - c[2]
+               c[2] - c[1]
+                      c[1] - c[0]
= c[4]                      - c[0]

लंबाई के पात्रों के किसी भी क्रम के लिए सामान्यीकृत n, इसका c[n-1] - c[0]कारण यह है कि बीच के सभी सामान बाहर निकल जाते हैं।

2

PHP 7.1, 33 31 बाइट्स

PHP 7.1 में कार्यान्वित नकारात्मक स्ट्रिंग ऑफसेट का उपयोग करता है ।

echo ord($argn[-1])-ord($argn);

इस तरह से चलाएं:

echo 'Hello World!' | php -nR 'echo ord($argn[-1])-ord($argn);';echo

बदलाव

का उपयोग करके 2 बाइट्स बचाया $argn

— aross
स्रोत

1

RProgN , 142 बाइट्स, गैर-प्रतिस्पर्धात्मक

function tostack 'b' asoc stack 'a' asoc 0 'v' asoc b pop byte 'o' asoc b len while [ v o b pop byte ] 'o' asoc - + 'v' asoc b len end [ v end

गैर-प्रतिस्पर्धी, जैसा कि इस चुनौती की खोज के बाद 'टूस्टैक' कमांड को जोड़ा गया था (भले ही इसकी भयानक बाइट गिनती हो)

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

Hello, World!
-39

Cool, huh?
-4

व्याख्या

function                        # Push the function between this and end to the stack
    tostack 'b' asoc            # Convert the implicit input to a stack, associate it with 'b'
    0 'v' asoc                  # Push 0 to the stack, associate it with 'v'
    b pop byte 'o' asoc         # Pop the top value of b (The end of the input), get the byte value, associate it with 'o'.
    b len                       # Push the size of b to the stack
    while [                     # While the top of the stack is truthy, pop the top of the stack
        v                       # Push v to the stack
            o                   # Push o to the stack
            b pop byte          # Pop the top value of b, push the byte value of that to the stack
            ] 'o' asoc          # Push a copy of the top of the stack, associate it with 'o'
            -                   # Subtract the top of the stack from one underneith that, In this case, the old value of o and the byte.
        +                       # Sum the top of the stack and underneith that, that is, the difference of the old value and new, and the total value
        'v' asoc                # Associate it with 'v'
        b len                   # Push the size of b to the stack (which acts as the conditional for the next itteration)
    end [                       # Pop the top of the stack, which will likely be the left over size of b
    v                           # Push the value of v to the top of the stack
end                             # Implicitely returned / printed

RProgN एक गूढ़ भाषा है जिसे मैं रिवर्स पोलिश नोटेशन को ध्यान में रखकर काम कर रहा हूं। यह वर्तमान में बहुत ही क्रियात्मक है, इसमें चर असाइनमेंट 4 वर्णों का है, और इस तरह, हालांकि मैं भविष्य में थोड़ी सी शक्कर के साथ योजना बनाता हूं।

इसके अलावा, RProgN स्पष्ट रूप से स्टैक से तर्कों को एक्सेस करता है, और उन्हें उसी तरह वापस करता है। कार्यक्रम समाप्त होने के बाद स्टैक में छोड़ा गया कोई भी स्ट्रिंग डेटा, अंतर्निहित रूप से मुद्रित होता है।

— Ataco
स्रोत

"बिट ऑफ़ सुगर" ने वास्तव में कुछ महीनों में रूप बदल लिया। यह पूरी बात अब है ~{bid☼[+और यह थोड़ा आराध्य है।

— अताको

1

PHP, 36 बाइट्स

<?=ord(strrev($s=$argv[1]))-ord($s);

प्रत्येक वर्ण लेकिन पहले और अंतिम को एक-एक करके जोड़ा जाता है और प्रतिस्थापित किया जाता है।
→ अंतर का योग == पहले और अंतिम चरित्र के बीच अंतर
ord()PHP में एक स्ट्रिंग के पहले चरित्र पर काम करता है
→ किसी एकल चरित्र को स्पष्ट रूप से कम करने की आवश्यकता नहीं है

— टाइटस
स्रोत

1

ब्रेन-फ्लैक , 34 32 + 3 = 35 बाइट्स

+3 -aअस्सी मोड के लिए आवश्यक ध्वज के कारण ।

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

(([][()]){[{}{}]({})([][()])}<>)

वास्तव में यह वास्तव में पहले से घटाव की "चाल" के बजाय चश्मे में उपयोग की जाने वाली परिभाषा का उपयोग करने के लिए अधिक कुशल है।

यह ठीक वैसा ही करके काम करता है।

(                           )  Push
 ([][()]){[{}]...([][()])}     While the stack has more than one item
  [{}]({})                     Subtract the top from a copy of the second
                          <>   Switch

— एड हॉक गार्फ हंटर
स्रोत

1

CJam , 8 5 बाइट्स

दो सुझावों के लिए डेनिस का बड़ा धन्यवाद जिसने 3 बाइट्स निकाले

l)\c-

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

व्याख्या

अंतिम मान माइनस प्रथम मान की गणना करता है।

l        e# Read line as a string
 )       e# Push original string except last char, then last char
  \      e# Swap
   c     e# Convert to char: gives the first element of the string
    -    e# Subtract. Implicitly display

— लुइस मेंडो
स्रोत

आप का उपयोग करते हैं )बजाय W=, आप की जरूरत नहीं है _। इसके अलावा, cएक शॉर्टकट के रूप में 0=।

— डेनिस

@ डेनिस बहुत बहुत धन्यवाद!

— लुइस मेंडो सेप

1

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

sum.(tail>>=zipWith(-)).map fromEnum

उपयोग:

Prelude> (sum.(tail>>=zipWith(-)).map fromEnum)"Hello World!"
-39

हास्केल (लैंबडॉट), 31 बाइट्स

sum.(tail>>=zipWith(-)).map ord

— BlackCap
स्रोत

मुझे डर है कि यह एक उचित कार्य नहीं है। यह सिर्फ एक झलकी है। sum.(tail>>=zipWith(-)).map fromEnumउदाहरण के लिए एक फ़ंक्शन है।

— nimi

@nimi प्रश्न ने उचित कार्य के लिए नहीं पूछा

— BlackCap

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

— निम्मी

1

Zsh , 22 बाइट्स

c=${1[-1]}
<<<$[#1-#c]

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

अंकगणितीय मोड में, #name पहले वर्ण का वर्ण कोड प्राप्त करता है name। हम cअंतिम चरित्र पर सेट होते हैं, और पहले और अंतिम कोड के बीच अंतर करते हैं।

— GammaFunction
स्रोत

1

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

(-).x.last<*>x.head
x=fromEnum

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

पहले वाले से अंतिम वर्ण के क्रमिक मान को घटाता है।

— मजाक कर रहा है
स्रोत

0

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

import Data.Char
f s=sum$g$ord<$>s
g(a:b:r)=b-a:g(b:r)
g _=[]

— joeytwiddle
स्रोत

0

जावा 7, 100 96 बाइट्स

int c(String s){char[]a=s.toCharArray();int r=0,i=a.length-1;for(;i>0;r+=a[i]-a[--i]);return r;}

Ungolfed और परीक्षण कोड:

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

class M{
  static int c(String s){
    char[] a = s.toCharArray();
    int r = 0,
        i = a.length-1;
    for(; i > 0; r += a[i] - a[--i]);
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("Hello World!"));
  }
}

आउटपुट: -39

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

0

क्लोजर, 31 बाइट्स

#(-(int(last %))(int(first %)))

किसी ने पहले से ही एक ऑपरेशन में काम कम कर दिया।

— माइकल एम
स्रोत

एक स्ट्रिंग के संचयी ढलान का उत्पादन

चुनौती

नियम

पायथन, 29 बाइट्स

MATL , 2 बाइट्स

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

MATLAB, 16 बाइट्स

पायथन, 63 बाइट्स

क्यूबिक्स , 13 बाइट्स

यह काम किस प्रकार करता है

सी #, 22 बाइट्स

LINQ, 17 बाइट्स के साथ C #

रूबी, 23 बाइट्स

जालीदार, 12 बाइट्स

ब्रेन-फ्लैक , 51 बाइट्स

05AB1E , 3 बाइट्स

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

व्याख्या

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

आर, 69 43 32 बाइट्स

पर्ल, 19 बाइट्स

NodeJS, 82 बाइट्स

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

जावास्क्रिप्ट ईएस 6, 42 39 बाइट्स

फोर्थ, 28 बाइट्स

जावा, ४२

PHP 7.1, 33 31 बाइट्स

बदलाव

RProgN , 142 बाइट्स, गैर-प्रतिस्पर्धात्मक

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

व्याख्या

PHP, 36 बाइट्स

ब्रेन-फ्लैक , 34 32 + 3 = 35 बाइट्स

CJam , 8 5 बाइट्स

व्याख्या

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

हास्केल (लैंबडॉट), 31 बाइट्स

Zsh , 22 बाइट्स

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

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

जावा 7, 100 96 बाइट्स

क्लोजर, 31 बाइट्स