挑战

给定一个字符串，例如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。

规则

• 适用标准漏洞
• 请勿使用执行此确切任务的预制函数
• 鼓励创意解决方案
• 玩得开心
• 这被标记为code-golf，以字节为单位的最短答案将获胜，但不会被选择。

Python，29个字节

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

的差异的形式的伸缩系列，因此大部分被加数抵消之和
（S ₁ - S ₀）+（S ₂ - S ₁）+ ... +（S _n-1个 - S _N-2）+（S _ñ - s _n-1）= s _n -s ₀。

如果允许使用字节字符串作为输入

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

对于19个字节也可以工作。

在Ideone上进行测试。

MATL，2个字节

ds

在线尝试！

说明：

d获取连续字符之间的差并s求和结果数组。然后，将隐式打印堆栈顶部的值。没什么可说的了。

有趣的是，即使丹尼斯发现了一个很棒的捷径，在MATL中使用它的时间也明显更长。

果冻，3个字节

OIS

在线尝试！

就拿O输入字符串的字符rdinals，那么，I那么该列表的ncrements，SUM的那名单。

MATLAB，16个字节

@(x)sum(diff(x))

这将创建一个名为的匿名函数ans，可以这样调用：ans('Hello world!')。

这是Octave 的在线演示，需要一个额外的字节+才能在计算元素与元素之间的差异之前将输入字符串显式转换为数字数组

Python，63个字节

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

伊迪恩！

Cubix，13个字节

Cubix是包裹在立方体周围的二维语言。

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

在线测试！这映射到以下多维数据集网：

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

IP（指令指针）从最左面的左上角开始的位置。

怎么运行的

首先，IP击中镜像/，将其重定向到i顶部。顶面是一个循环，不断输入字符代码，直到达到EOF。输入为空时，结果i为-1；IP从处向左转?，击中/最右边的，然后执行以下命令：

• ; -弹出顶部项目（-1）。
• # -推动堆栈的长度。
• t-弹出顶部项目，并在堆栈中的该索引处获得该项目。这拉起底部的项目。
• - - 减去。
• O -输出为整数。
• /-将IP偏转到@，以结束程序。

C＃，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的C＃，17个字节

由于hstde，使用LINQ的较短版本：

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

但是，需要额外导入：

using System.Linq;

Ruby，23个字节

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

分配给变量，f=->s{s[-1].ord-s[0].ord}然后调用likef["Hello World!"]

使用丹尼斯对望远镜系列的观察。

网状，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

Brain-Flak，51字节

48个字节的代码加上三个字节的-a标志，用于启用ASCII输入（但十进制输出。多么方便。：D）

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

在线尝试！

这的人一点点有点困难比我其他的答案，哈哈。让我们通过它。

{           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

05AB1E，3个字节

Ç¥O

在线尝试！

使用CP-1252编码。

说明

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

Brachylog，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]。

Haskell，32个字节

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

R，69 43 32字节

尽管我认为在R中展示一个可能的解决方案会很有趣，但是这是一个非竞争性的答案。

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

这个答案唯一有趣的方面是sapplyand 的使用charToRaw。首先，我将字符串拆分为字符向量，然后将其转换为ASCII整数表示形式。该charToRaw函数未在R中进行矢量化，而是使用sapply有效地矢量化该函数的方法，而不是遍历上述矢量中的每个值。随后取一阶差，然后求和。

编辑：原来charToRaw将字符串转换为向量，其中每个元素是每个字符的原始表示，因此无需使用strsplit和sapply

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

Edit2：事实证明，还有一种更好的方法，该函数utf8ToInt(x)完全strtoi(charToRaw(x),16)可以执行此操作，这意味着我们可以节省更多字节（来自@rturnbull的另一个问题的答案中的想法）：

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

Perl，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

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

JavaScript，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}

与上面相同的想法，但使用函数输入而不是参数。

JavaScript ES6，42 个 39字节

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

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

使用@Dennis观测望远镜总和。

我认为这种情况下最简单的解决方案是最短的。

通过消除charCodeAt@Neil建议的重复，节省了3个字节。

第28个字节

: f depth 1- roll swap - . ;

获取堆栈上的字符列表（Forth的标准参数获取方法）。将字符取为堆栈的顶部是字符串的第一个字符。我将堆栈的底部移到顶部，交换，然后减去并打印。垃圾留在堆栈上，输出被输出到stdout。

如果将每个字符按顺序而不是相反的顺序推入堆栈，则程序将缩短2个字节。不过，不确定是否允许这样做，因为通常您会以相反的顺序推送参数。

在线尝试

这样称呼：

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

爪哇，42

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

取消高尔夫：

  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]因为中间的所有内容都被抵消了。

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

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

非竞争性，因为在发现此挑战后添加了“ tostack”命令（即使它的字节数非常糟糕）

测试用例

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隐式地从堆栈访问参数，并以相同的方式返回它们。程序完成后，堆栈中剩余的任何字符串数据都将隐式打印。

PHP，36字节

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

• 除第一个和最后一个字符外，每个字符都被添加和减去一次。
  →差异之和==第一个字符与最后一个字符之间的差异
• ord()在PHP中对字符串的第一个字符进行操作
  →无需显式将其简化为单个字符

脑筋急转弯，34岁 32 + 3 = 35字节

+3，因为-aASCII模式需要标志。

在线尝试

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

奇怪的是，实际上使用规范中使用的定义要比使用“先从后减去”的“技巧”更有效。

正是这样做的。

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

CJam，8 5字节

非常感谢Dennis提出的两个建议，这些建议删除了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

Haskell，36个字节

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

用法：

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

Haskell（Lambdabot），31个字节

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

Zsh，22个字节

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

在线尝试！

在算术模式下，#name获取中第一个字符的字符代码name。我们设置c为最后一个字符，并采用第一个和最后一个代码之间的差异。

Haskell，30个字节

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

在线尝试！

从第一个字符中减去最后一个字符的序数值。

Haskell，61个字节

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

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

取消测试代码：

在这里尝试。

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

Clojure，31个字节

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

有人已经将任务简化为一个操作。