Thử thách

Đưa ra một chuỗi như Hello World!, chia nó thành các giá trị ký tự của nó : 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33.

Sau đó tính toán sự khác biệt giữa mỗi cặp ký tự liên tiếp : 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67.

Cuối cùng, tổng hợp chúng và in kết quả cuối cùng : -39.

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Không sử dụng các chức năng được tạo sẵn để thực hiện nhiệm vụ chính xác này
• Giải pháp sáng tạo được khuyến khích
• Chúc vui vẻ
• Điều này được đánh dấu là golf-code , câu trả lời ngắn nhất bằng byte thắng nhưng sẽ không được chọn.

Python, 29 byte

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

Tổng của sự khác biệt tạo thành một loạt kính thiên văn, vì vậy hầu hết các triệu hồi hủy bỏ và
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) + Câu + (s _{n - 1} - s _{n - 2} ) + (s _n - s _{n - 1} ) = s _n - s ₀ .

Nếu lấy một chuỗi byte làm đầu vào được cho phép

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

sẽ hoạt động tốt trong 19 byte .

Kiểm tra cả trên Ideone .

MATL , 2 byte

ds

Hãy thử trực tuyến!

Giải trình:

dnhận được sự khác biệt giữa các ký tự liên tiếp và tính stổng mảng kết quả. Sau đó, giá trị trên cùng của ngăn xếp được in ngầm. Không có nhiều điều khác để nói về điều đó.

Thật thú vị, mặc dù Dennis đã phát hiện ra một phím tắt tuyệt vời, sử dụng nó sẽ dài hơn đáng kể trong MATL.

Thạch , 3 byte

OIS

Hãy thử trực tuyến!

Lấy các Oký tự thứ tự của các ký tự của chuỗi đầu vào, sau đó là các phần Itử của danh sách đó, sau đó là Sô của danh sách đó .

MATLAB, 16 byte

@(x)sum(diff(x))

Điều này tạo ra một hàm ẩn danh có tên anscó thể được gọi là : ans('Hello world!').

Dưới đây là bản demo trực tuyến trong Octave, yêu cầu một byte bổ sung +để chuyển đổi rõ ràng chuỗi đầu vào thành một mảng số trước khi tính toán sự khác biệt giữa các thành phần

Python, 63 byte

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

Nghĩa là nó!

Khối , 13 byte

Cubix là một ngôn ngữ 2 chiều bao quanh một khối lập phương.

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

Kiểm tra nó trực tuyến! Bản đồ này vào mạng khối sau:

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

Trong đó IP (con trỏ lệnh) bắt đầu ở phía trên bên trái của mặt trái.

Làm thế nào nó hoạt động

Đầu tiên, IP chạm vào gương /chuyển hướng nó lên mặt itrên. Mặt trên là một vòng lặp liên tục nhập mã cho đến khi đạt được EOF. Khi đầu vào trống, kết quả ilà -1; IP rẽ trái từ ?, chạm /vào mặt phải và thực hiện các lệnh sau:

• ; - Pop mục trên cùng (-1).
• # - Đẩy chiều dài của ngăn xếp.
• t- Pop mục trên cùng và nhận mục tại chỉ mục đó trong ngăn xếp. Điều này kéo lên các mục dưới cùng.
• - - Trừ đi.
• O - Đầu ra dưới dạng số nguyên.
• /- Làm chệch hướng IP đến @, kết thúc chương trình.

C #, 22 byte

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

Mã nguồn đầy đủ với trường hợp thử nghiệm:

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!"));
        }
    }
}

C # với LINQ, 17 byte

Phiên bản ngắn hơn, sử dụng LINQ, nhờ hstde :

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

Tuy nhiên, cần nhập thêm:

using System.Linq;

Ruby, 23 byte

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

Gán cho một biến như f=->s{s[-1].ord-s[0].ord}và gọi nhưf["Hello World!"]

Sử dụng quan sát của Dennis về loạt kính thiên văn.

mặt lưới, 12 byte

idVc~@qVc-o;

Hãy thử trực tuyến!

Sử dụng sự quan sát của Dennis , chúng ta có thể rút ngắn quá trình lặp lại thành một quy trình đơn giản hơn.

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 byte

48 byte mã cộng với ba byte cho -acờ, cho phép nhập ASCII (nhưng đầu ra thập phân. Thật tiện lợi .: D)

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

Hãy thử trực tuyến!

Những người này một chút cắn khó hơn câu trả lời khác của tôi, haha. Hãy đi qua nó.

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

Ç¥O

Hãy thử trực tuyến!

Sử dụng mã hóa CP-1252.

Giải trình

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

Brachylog , 7 byte

@c$)@[-

Hãy thử trực tuyến!

Giải trình

@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

Vì phép trừ chỉ hoạt động cho đầu vào của hai số nguyên, nên nó sẽ thành công sau khi tiền tố được chọn là [33, 72].

Haskell, 32 byte

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

R, 69 43 32 byte

Một câu trả lời rất không cạnh tranh mặc dù tôi nghĩ sẽ rất vui khi giới thiệu một giải pháp khả thi trong R.

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

Khía cạnh thú vị duy nhất của câu trả lời này là việc sử dụng sapplyvà charToRaw. Đầu tiên tôi chia chuỗi thành một vectơ ký tự mà tôi muốn chuyển đổi thành các biểu diễn số nguyên ASCII của nó. Các charToRawchức năng không vector hóa trong R và thay vì lặp qua mỗi giá trị trong nói trên vector tôi sử dụng sapplymà hiệu quả vectorizes hàm. Sau đó lấy chênh lệch thứ 1 rồi tính tổng.

Chỉnh sửa: Hóa ra charToRawbiến một chuỗi thành một vectơ trong đó mỗi phần tử là biểu diễn thô của mỗi ký tự, do đó không cần sử dụng strsplitvàsapply

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

Edit2: Hóa ra có một cách thậm chí còn tốt hơn, hàm utf8ToInt(x)thực hiện chính xác điều gì strtoi(charToRaw(x),16)có nghĩa là chúng ta có thể lưu thêm một vài byte (Ý tưởng được lấy từ câu trả lời của @ rturnbull cho câu hỏi khác):

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

Perl, 19 byte

Bao gồm +1 cho -p

Cung cấp đầu vào trên STDIN mà không có dòng mới

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

slope.pl:

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

Nếu bạn chắc chắn chuỗi đầu vào có ít nhất 2 ký tự thì phiên bản 17 byte này cũng hoạt động:

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

NodeJS, 82 byte

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

Giải trình:

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 byte

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}

Cùng một ý tưởng như trên với một đầu vào hàm thay vì một đối số.

JavaScript ES6, 42 39 byte

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

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

Sử dụng quan sát @Dennis về tổng số kính viễn vọng.

Tôi nghĩ rằng trong trường hợp này, giải pháp tầm thường là ngắn nhất.

Đã lưu 3 byte bằng cách loại bỏ sự charCodeAtlặp lại theo đề xuất của @Neil.

Forth, 28 byte

: f depth 1- roll swap - . ;

Lấy danh sách các ký tự trên ngăn xếp (Phương pháp lấy tham số tiêu chuẩn của Forth.) Các ký tự được lấy sao cho đỉnh của ngăn xếp là ký tự đầu tiên của chuỗi. Tôi di chuyển dưới cùng của ngăn xếp lên trên cùng, trao đổi, sau đó trừ và in. Rác được để lại trên ngăn xếp và đầu ra được in ra thiết bị xuất chuẩn.

Nếu mỗi ký tự được đẩy vào ngăn xếp theo thứ tự thay vì thứ tự ngược lại, chương trình sẽ ngắn hơn 2 byte. Tuy nhiên, không chắc chắn nếu điều đó được cho phép, bởi vì thông thường, bạn đẩy các đối số theo thứ tự ngược lại.

Dùng thử trực tuyến

Được gọi như thế này:

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

Java, 42

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

Ung dung:

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

Giải trình:

Điều này sử dụng nguyên tắc tương tự như kính thiên văn:

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

Tổng quát cho bất kỳ chuỗi ký tự có độ dài n, câu trả lời là c[n-1] - c[0]bởi vì tất cả những thứ ở giữa hủy bỏ.

PHP 7.1, 33 31 byte

Sử dụng offset chuỗi âm được triển khai trong PHP 7.1.

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

Chạy như thế này:

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

Tinh chỉnh

• Đã lưu 2 byte bằng cách sử dụng $argn

RProgN , 142 byte, không cạnh tranh

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

Không cạnh tranh, vì lệnh 'tostack' đã được thêm vào sau khi phát hiện ra thử thách này (mặc dù nó có số byte khủng khiếp)

Các trường hợp thử nghiệm

Hello, World!
-39

Cool, huh?
-4

Giải trình

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 là một ngôn ngữ bí truyền mà tôi đã làm việc với Ký hiệu đảo ngược tiếng Ba Lan trong tâm trí. Hiện tại nó khá dài dòng, với phép gán biến là 4 ký tự, và như vậy, tuy nhiên tôi dự định trong tương lai sẽ thêm một chút đường tổng hợp.

Ngoài ra, RProgN ngầm truy cập các đối số từ ngăn xếp và trả về chúng theo cùng một cách. Bất kỳ dữ liệu chuỗi nào còn lại trong ngăn xếp sau khi chương trình kết thúc, sẽ được in hoàn toàn.

PHP, 36 byte

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

• Mỗi nhân vật ngoại trừ nhân vật đầu tiên và cuối cùng được thêm vào và trừ đi mỗi lần một.
  → tổng của sự khác biệt == sự khác biệt giữa ký tự đầu tiên và cuối cùng
• ord()trong PHP hoạt động trên ký tự đầu tiên của chuỗi
  → không cần giảm rõ ràng thành một ký tự

Brain-Flak , 34 32 + 3 = 35 byte

+3 vì -acờ cần cho chế độ ascii.

Dùng thử trực tuyến

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

Thật kỳ lạ, nó thực sự hiệu quả hơn khi sử dụng định nghĩa được sử dụng trong thông số kỹ thuật thay vì "mẹo" trừ trước từ cuối.

Điều này hoạt động bằng cách làm chính xác đó.

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

CJam , 8 5 byte

Cảm ơn Dennis vì hai đề xuất đã loại bỏ 3 byte

l)\c-

Hãy thử trực tuyến!

Giải trình

Tính giá trị cuối trừ đi giá trị đầu tiên.

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 byte

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

sử dụng:

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

Haskell (Lambdabot), 31 byte

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

Zsh , 22 byte

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

Hãy thử trực tuyến!

Trong chế độ số học, #namelấy mã ký tự của ký tự đầu tiên name. Chúng tôi đặt cký tự cuối cùng và lấy sự khác biệt giữa mã đầu tiên và mã cuối cùng.

Haskell , 30 byte

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

Hãy thử trực tuyến!

Trừ giá trị thứ tự của ký tự cuối cùng từ ký tự đầu tiên.

Haskell, 61 byte

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

Java 7, 100 96 byte

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

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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!"));
  }
}

Đầu ra: -39

Clojure, 31 byte

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

Ai đó đã giảm nhiệm vụ đã xuống một hoạt động.