Herausforderung

Bei einer Zeichenkette wie Hello World!, brechen sie in ihre Charakterwerte: 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33.

Dann berechnet die Differenz zwischen jedem aufeinander folgenden Paar von Zeichen: 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67.

Schließlich sie summieren und das Endergebnis drucken: -39.

Regeln

• Es gelten Standardlücken
• Verwenden Sie keine vorgefertigten Funktionen, die genau diese Aufgabe ausführen
• Kreative Lösungen werden gefördert
• Habe Spaß
• Dies ist als Code-Golf markiert , die kürzeste Antwort in Bytes gewinnt, wird aber nicht ausgewählt.

Python, 29 Bytes

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

Die Summe der Differenzen bildet eine Teleskopreihe, daher heben sich die meisten Summanden auf und
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) +… + (s _n-1 - s _n-2 ) + (s _n - s _n-1 ) = s _n - s ₀ .

Wenn die Eingabe einer Byte-Zeichenfolge zulässig ist

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

funktioniert auch für 19 Bytes .

Testen Sie beide auf Ideone .

MATL , 2 Bytes

ds

Probieren Sie es online!

Erläuterung:

dErmittelt den Unterschied zwischen aufeinanderfolgenden Zeichen und ssummiert das resultierende Array. Dann wird implizit der Wert oben auf dem Stapel gedruckt. Darüber gibt es sonst nicht viel zu sagen.

Interessanterweise wäre die Verwendung in MATL bedeutend länger, obwohl Dennis eine großartige Verknüpfung entdeckt hat.

Gelee , 3 Bytes

OIS

Probieren Sie es online!

Nehmen Sie das Ordinals der Zeichen der Eingabezeichenfolge, dann die Increments dieser Liste, dann ist die Sum von dieser Liste.

MATLAB, 16 Bytes

@(x)sum(diff(x))

Dies schafft eine anonyme Funktion mit dem Namen , ansdie wie genannt werden können: ans('Hello world!').

Hier ist eine Online-Demo in Octave, die ein zusätzliches Byte erfordert +, um die Eingabezeichenfolge explizit in ein numerisches Array umzuwandeln, bevor die Element-zu-Element-Differenz berechnet wird

Python, 63 Bytes

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

Ideone es!

Cubix , 13 Bytes

Cubix ist eine zweidimensionale Sprache, die um einen Würfel gewickelt ist.

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

Online testen! Dies wird dem folgenden Würfelnetz zugeordnet:

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

Wo der IP (Anweisungszeiger) oben links auf der linken Seite beginnt.

Wie es funktioniert

Zuerst trifft die IP auf den Spiegel, /der sie auf idie Oberseite umleitet . Die Oberseite ist eine Schleife, die kontinuierlich Zeichencodes eingibt, bis EOF erreicht ist. Wenn die Eingabe leer ist, ist das Ergebnis von i-1; Die IP biegt nach links ab ?, trifft /ganz rechts auf und führt die folgenden Befehle aus:

• ; - Pop das oberste Element (-1).
• # - Schieben Sie die Länge des Stapels.
• t- Pop das oberste Element und erhalten Sie das Element an diesem Index im Stapel. Dies zieht den unteren Gegenstand hoch.
• - - Subtrahieren.
• O - Ausgabe als Ganzzahl.
• /- Leitet die IP an die weiter @, die das Programm beendet.

C #, 22 Bytes

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

Vollständiger Quellcode mit Testfall:

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 # mit LINQ, 17 Bytes

Eine kürzere Version mit LINQ, dank hstde :

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

Ein zusätzlicher Import ist jedoch erforderlich:

using System.Linq;

Ruby, 23 Bytes

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

Zuweisung zu einer Variablen wie f=->s{s[-1].ord-s[0].ord}und Aufruf wief["Hello World!"]

Verwendet Dennis 'Beobachtung über Teleskopserien.

netzförmig, 12 Bytes

idVc~@qVc-o;

Probieren Sie es online!

Mit Dennis 'Beobachtung können wir einen iterativen Prozess in einen einfacheren verkürzen.

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 Bytes

48 Byte Code plus drei Byte für das -aFlag, das die ASCII-Eingabe (aber die Dezimalausgabe) ermöglicht. Wie praktisch.: D)

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

Probieren Sie es online!

Diese diejenigen ein wenig etwas härter als meine andere Antwort, haha. Lass uns durchgehen.

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

Ç¥O

Probieren Sie es online!

Verwendet die CP-1252-Codierung.

Erläuterung

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

Brachylog , 7 Bytes

@c$)@[-

Probieren Sie es online!

Erläuterung

@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

Da subtrahieren nur für eine Eingabe von zwei ganzen Zahlen funktioniert, ist dies erfolgreich, sobald das ausgewählte Präfix lautet [33, 72].

Haskell, 32 Bytes

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

R, 69 43 32 Bytes

Eine sehr konkurrenzlose Antwort, obwohl ich dachte, es würde Spaß machen, eine mögliche Lösung in R zu präsentieren.

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

Der einzig interessante Aspekt dieser Antwort ist die Verwendung von sapplyund charToRaw. Zuerst teile ich den String in einen Vektor von Zeichen auf, den ich in seine ASCII-Integer-Darstellungen konvertieren möchte. Die charToRawFunktion wird in R nicht vektorisiert und stattdessen über jeden Wert in dem zuvor erwähnten von mir verwendeten Vektor geschleiftsapply wodurch die Funktion effektiv vektorisiert wird. Anschließend 1. Differenz nehmen und dann summieren.

Bearbeiten: Es stellt sich heraus charToRaw, dass eine Zeichenfolge in einen Vektor transformiert wird, bei dem jedes Element die Rohdarstellung jedes Zeichens ist und daher nicht strsplitund verwendet werden musssapply

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

Edit2: Es stellt sich heraus, dass es einen noch besseren Weg gibt, die Funktion utf8ToInt(x)macht genau das, strtoi(charToRaw(x),16)was bedeutet, dass wir ein paar weitere Bytes sparen können (Idee aus der Antwort von @ rturnbull auf eine andere Frage):

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

Perl, 19 Bytes

Beinhaltet +1 für -p

Geben Sie eine Eingabe für STDIN ohne letzte Zeile ein

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

slope.pl:

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

Wenn Sie sicher sind, dass die Eingabezeichenfolge mindestens 2 Zeichen enthält, funktioniert auch diese 17-Byte-Version:

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

NodeJS, 82 Bytes

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

Erläuterung:

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 Bytes

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}

Dieselbe Idee wie oben mit einer Funktionseingabe anstelle eines Arguments.

JavaScript ES6, 42 39 Bytes

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

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

Mit @Dennis Beobachtung über Teleskopsummen.

Ich denke in diesem Fall ist die triviale Lösung die kürzeste.

3 Bytes gespart, indem die charCodeAtvon @Neil vorgeschlagene Wiederholung beseitigt wurde.

Viertens 28 Bytes

: f depth 1- roll swap - . ;

Nimmt eine Liste von Zeichen auf dem Stapel auf (Forths Standardmethode zum Aufnehmen von Parametern). Die Zeichen werden so aufgenommen, dass der Anfang des Stapels das erste Zeichen der Zeichenfolge ist. Ich bewege die Unterseite des Stapels nach oben, tausche, subtrahiere und drucke. Der Müll bleibt auf dem Stapel, und die Ausgabe wird auf stdout gedruckt.

Wenn jedes Zeichen in umgekehrter Reihenfolge in den Stapel geschoben würde, wäre das Programm 2 Byte kürzer. Ich bin mir jedoch nicht sicher, ob dies zulässig ist, da Sie Argumente normalerweise in umgekehrter Reihenfolge übergeben.

Probieren Sie es online aus

So genannt:

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

Ungolfed:

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

Erläuterung:

Dabei wird dasselbe Prinzip wie beim Teleskopieren angewendet:

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

Verallgemeinert auf eine beliebige Folge von Zeichen mit einer Länge nlautet die Antwort, c[n-1] - c[0]weil das gesamte Zeug in der Mitte gelöscht wird.

PHP 7.1, 33 31 Bytes

Verwendet negative String-Offsets, die in PHP 7.1 implementiert sind.

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

Laufen Sie wie folgt:

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

Optimierungen

• 2 Bytes mit gespeichert $argn

RProgN , 142 Bytes, nicht konkurrierend

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

Nicht konkurrierend, da der Befehl "tostack" nach der Entdeckung dieser Herausforderung hinzugefügt wurde (obwohl er eine schreckliche Anzahl von Bytes aufweist)

Testfälle

Hello, World!
-39

Cool, huh?
-4

Erläuterung

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 ist eine esoterische Sprache, an der ich mit Blick auf die umgekehrte polnische Notation gearbeitet habe. Es ist derzeit ziemlich ausführlich, mit einer variablen Zuweisung von 4 Zeichen, und ich plane jedoch, in Zukunft ein bisschen syntatischen Zucker hinzuzufügen.

Außerdem greift RProgN implizit auf Argumente aus dem Stapel zu und gibt sie auf dieselbe Weise zurück. Alle Zeichenfolgendaten, die nach Beendigung des Programms im Stapel verbleiben, werden implizit gedruckt.

PHP, 36 Bytes

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

• Jedes Zeichen außer dem ersten und dem letzten wird jeweils einmal addiert und subtrahiert.
  → Summe der Unterschiede == Unterschied zwischen erstem und letztem Zeichen
• ord()in PHP wird das erste Zeichen eines Strings bearbeitet
  → es muss nicht explizit auf ein einzelnes Zeichen reduziert werden

Brain-Flak , 34 32 + 3 = 35 Bytes

+3 wegen des -afür den ASCII-Modus erforderlichen Flags.

Probieren Sie es online aus

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

Seltsamerweise ist es effizienter, die in den Spezifikationen verwendete Definition zu verwenden, als den "Trick", zuerst vom letzten zu subtrahieren.

Das funktioniert genau so.

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

CJam , 8 5 Bytes

Vielen Dank an Dennis für zwei Vorschläge, die 3 Bytes entfernt haben

l)\c-

Probieren Sie es online!

Erläuterung

Berechnet den letzten Wert minus dem ersten Wert.

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 Bytes

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

Verwendung:

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

Haskell (Lambdabot), 31 Bytes

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

Zsh , 22 Bytes

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

Probieren Sie es online!

Ruft im arithmetischen Modus #nameden Zeichencode des ersten Zeichens in ab name. Wir setzen cauf das letzte Zeichen und nehmen den Unterschied zwischen dem ersten und dem letzten Code.

Haskell , 30 Bytes

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

Probieren Sie es online!

Subtrahiert den Ordnungswert des letzten Zeichens vom ersten.

Haskell, 61 Bytes

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

Java 7, 100 96 Bytes

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 & Testcode:

Probieren Sie es hier aus.

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

Ausgabe: -39

Clojure, 31 Bytes

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

Jemand hat die Aufgabe bereits auf eine einzige Operation reduziert.