도전

과 같은 문자열 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 로 표시되며 , 바이트 단위의 최단 답변이이기는하지만 선택되지는 않습니다.

파이썬, 29 바이트

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

다음은 텔레스코픽 시리즈, 그래서 대부분의 피가수가 상쇄 차이점 형태의 합
을 ( ₁ - 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에서 모두 테스트 하십시오 .

MATL , 2 바이트

ds

온라인으로 사용해보십시오!

설명:

d연속 문자의 차이를 가져오고 s결과 배열을 합합니다. 그런 다음 스택 상단의 값이 암시 적으로 인쇄됩니다. 그것에 대해 말할 것도 많지 않습니다.

흥미롭게도 Dennis는 멋진 지름길을 발견했지만 MATL에서는 지름길이 훨씬 길었습니다.

젤리 , 3 바이트

OIS

온라인으로 사용해보십시오!

테이크 O입력 문자열의 문자 rdinals, 그 I다음, 그 목록의 ncrements을 S음의 그 목록입니다.

MATLAB, 16 바이트

@(x)sum(diff(x))

이렇게하면 ans다음과 같이 호출 될 수 있는 익명 함수가 생성 ans('Hello world!')됩니다.

Octave 의 온라인 데모 는 +요소 간 차이를 계산하기 전에 입력 문자열을 숫자 배열로 명시 적으로 변환 하는 데 추가 바이트 가 필요합니다.

파이썬, 63 바이트

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

무시 했어!

Cubix , 13 바이트

Cubix는 큐브를 감싸는 2 차원 언어입니다.

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;

루비, 23 바이트

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

같은 변수에 할당하고 같은 f=->s{s[-1].ord-s[0].ord}호출f["Hello World!"]

텔레스코픽 시리즈에 대한 Dennis의 관찰을 사용합니다.

망상, 12 바이트

idVc~@qVc-o;

온라인으로 사용해보십시오!

Dennis의 관찰을 사용 하면 반복 프로세스를 더 간단한 프로세스로 단축 할 수 있습니다.

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 바이트의 코드와 3 바이트의 -a플래그를 사용하여 ASCII 입력 (그러나 10 진수 출력. 편리함 : 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].

하스켈, 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)))

이 답변의 유일한 흥미로운 측면은 sapply및 의 사용입니다 charToRaw. 먼저 문자열을 ASCII 정수 표현으로 변환하려는 문자 벡터로 나눕니다. charToRaw함수 R에 대신 상기 벡터 I 이용 각 값 위에 루핑 벡터화되지 않고 sapply효과적으로 기능 벡터화. 결과적으로 1 차 차이를 취한 다음 합산하십시오.

편집 : 턴 아웃 charToRaw각 요소는 각 문자의 원시 표현이고, 벡터로 사용하기에 따라서 필요를 문자열을 변환하지 strsplit및sapply

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

Edit2 : 더 나은 방법이 있다는 것이 밝혀졌습니다.이 함수 utf8ToInt(x)는 정확히 strtoi(charToRaw(x),16)몇 바이트를 절약 할 수있는 것을 의미합니다 ( 다른 질문에 대한 @rturnbull의 답변 에서 가져온 아이디어 ).

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

펄, 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

자바 스크립트, 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}

인수 대신 함수 입력을 사용하는 위와 동일한 아이디어입니다.

자바 스크립트 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 - . ;

스택에서 문자 목록을 가져옵니다 (매개 변수를 취하는 표준 방법). 스택의 맨 위가 문자열의 첫 번째 문자가되도록 문자를 가져옵니다. 스택의 맨 아래를 맨 위로 이동하고 교체 한 다음 빼고 인쇄합니다. 쓰레기는 스택에 남아 있고 출력은 표준 출력으로 인쇄됩니다.

각 문자가 역순이 아닌 순서대로 스택에 푸시되면 프로그램은 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]

length의 문자 시퀀스에 대해 일반화 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자인 현재는 매우 장황하지만 앞으로는 약간의 syntatic sugar를 추가 할 계획입니다.

또한 RProgN은 스택에서 인수에 암시 적으로 액세스하여 동일한 방식으로 반환합니다. 프로그램이 완료된 후 스택에 남아있는 문자열 데이터는 내재적으로 인쇄됩니다.

PHP, 36 바이트

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

• 첫 번째 문자와 마지막 문자를 제외한 모든 문자가 각각 한 번씩 추가 및 제거됩니다.
  → 차이의 합 == 첫 문자와 마지막 문자의 차이
• ord()PHP에서 문자열의 첫 번째 문자에서 작동
  → 명시 적으로 단일 문자로 줄일 필요가 없음

Brain-Flak , 34 32 + 3 = 35 바이트

-aASCII 모드에 필요한 플래그로 인해 +3

온라인으로 사용해보십시오

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

이상하게도 처음부터 빼는 "속임수"보다는 스펙에 사용 된 정의를 실제로 사용하는 것이 더 효율적입니다.

이것은 정확히 그렇게함으로써 작동합니다.

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

CJam , 8 5 바이트

3 바이트를 제거 한 두 가지 제안에 대해 Dennis에게 크게 감사드립니다.

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

하스켈, 36 바이트

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

용법:

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

하스켈 (Lambdabot), 31 바이트

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

Zsh , 22 바이트

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

온라인으로 사용해보십시오!

산술 모드에서 #name의 첫 번째 문자의 문자 코드를 가져옵니다 name. 우리 c는 마지막 문자로 설정 하고 첫 번째 코드와 마지막 코드의 차이를 취합니다.

하스켈 , 30 바이트

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

온라인으로 사용해보십시오!

첫 번째 문자에서 마지막 문자의 서수 값을 뺍니다.

하스켈, 61 바이트

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

자바 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

클로저, 31 바이트

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

누군가 이미 작업을 단일 작업으로 줄였습니다.