Sfida

Data una stringa come Hello World!, scomporlo nei suoi valori di carattere: 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33.

Quindi calcolare la differenza tra ciascuna coppia consecutiva di caratteri: 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67.

Infine, li somma e stampare il risultato finale: -39.

Regole

• Si applicano scappatoie standard
• Non utilizzare funzioni predefinite che eseguono questo compito esatto
• Soluzioni creative incoraggiate
• Divertiti
• Questo è contrassegnato come code-golf , la risposta più breve in byte vince ma non verrà selezionata.

Python, 29 byte

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

La somma delle differenze forma una serie telescopica, quindi la maggior parte delle somme si annulla e
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) +… + (s _n-1 - s _n-2 ) + (s _n - s _n-1 ) = s _n - s ₀ .

Se si accetta una stringa di byte come input

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

funzionerà anche per 19 byte .

Prova entrambi su Ideone .

MATL , 2 byte

ds

Provalo online!

Spiegazione:

dottiene la differenza tra caratteri consecutivi e ssomma l'array risultante. Quindi, il valore in cima alla pila viene stampato implicitamente. Non c'è molto altro da dire al riguardo.

Abbastanza interessante, anche se Dennis ha scoperto una scorciatoia fantastica, usarla sarebbe significativamente più lunga in MATL.

Gelatina , 3 byte

OIS

Provalo online!

Prendete le Ordinals dei personaggi della stringa di input, poi le Increments di quella lista, allora il Sum di quella lista.

MATLAB, 16 byte

@(x)sum(diff(x))

Questo crea una funzione anonima di nome ansche può essere chiamata come: ans('Hello world!').

Ecco una demo online in Octave che richiede un byte aggiuntivo +per convertire esplicitamente la stringa di input in un array numerico prima di calcolare la differenza elemento-elemento

Python, 63 byte

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

Ideone esso!

Cubix , 13 byte

Cubix è un linguaggio bidimensionale avvolto attorno a un cubo.

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

Provalo online! Questo è mappato alla seguente rete cubica:

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

Dove l'IP (puntatore alle istruzioni) inizia nella parte superiore sinistra della faccia dell'estrema sinistra.

Come funziona

Innanzitutto, l'IP colpisce lo specchio /che lo reindirizza isulla parte superiore. La faccia superiore è un loop che immette continuamente i codici a caratteri fino a quando non viene raggiunto l'EOF. Quando l'input è vuoto, il risultato di iè -1; l'IP gira a sinistra da ?, colpendo la /faccia all'estrema destra e passando i seguenti comandi:

• ; - Pop l'elemento in alto (-1).
• # - Spingere la lunghezza della pila.
• t- Fai scoppiare l'oggetto in cima e prendi l'oggetto in quell'indice nella pila. Questo tira su l'elemento in basso.
• - - Sottrai.
• O - Output come numero intero.
• /- Devia l'IP su @, che termina il programma.

C #, 22 byte

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

Codice sorgente completo con test case:

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 # con LINQ, 17 byte

Una versione più breve, usando LINQ, grazie a hstde :

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

Tuttavia, è necessaria un'importazione aggiuntiva:

using System.Linq;

Rubino, 23 byte

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

Assegna a una variabile like f=->s{s[-1].ord-s[0].ord}e chiama likef["Hello World!"]

Utilizza l'osservazione di Dennis sulle serie telescopiche.

reticolare, 12 byte

idVc~@qVc-o;

Provalo online!

Usando l'osservazione di Dennis , possiamo abbreviare un processo iterativo in uno più semplice.

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 di codice più tre byte per il -aflag, che abilita l'input ASCII (ma l'output decimale. Quanto è conveniente.: D)

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

Provalo online!

Questo è un po 'più difficile della mia altra risposta, ahah. Camminiamo attraverso di esso.

{           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

Provalo online!

Utilizza la codifica CP-1252.

Spiegazione

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

Brachylog , 7 byte

@c$)@[-

Provalo online!

Spiegazione

@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

Poiché sottrazione funziona solo per un input di due numeri interi, avrà esito positivo una volta che il prefisso selezionato è [33, 72].

Haskell, 32 byte

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

R, 69 43 32 byte

Una risposta molto non competitiva, anche se ho pensato che sarebbe stato divertente mostrare una possibile soluzione in R.

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

L'unico aspetto interessante di questa risposta è l'uso di sapplye charToRaw. Innanzitutto ho diviso la stringa in un vettore di caratteri che voglio convertire nelle sue rappresentazioni di interi ASCII. La charToRawfunzione non è vettorializzata in R e invece di eseguire il loop su ogni valore nel vettore sopra citato che uso in modo sapplyefficace vettorializzare la funzione. Successivamente prendi la 1 ° differenza e poi somma.

Modifica: risulta charToRawtrasformare una stringa in un vettore in cui ogni elemento è la rappresentazione grezza di ogni carattere, quindi non è necessario utilizzare strsplitesapply

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

Edit2: Si scopre che c'è un modo ancora migliore, la funzione utf8ToInt(x)fa esattamente ciò strtoi(charToRaw(x),16)che significa che possiamo salvare qualche altro byte (Idea presa dalla risposta di @ rturnbull a un'altra domanda):

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

Perl, 19 byte

Include +1 per -p

Fornire input su STDIN senza newline finale

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

slope.pl:

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

Se sei sicuro che la stringa di input abbia almeno 2 caratteri, funziona anche questa versione da 17 byte:

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

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

Spiegazione:

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}

Stessa idea di cui sopra con un input di funzione anziché un argomento.

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

Usando l'osservazione di @Dennis sulle somme del telescopio.

Penso che in questo caso la soluzione banale sia la più breve.

charCodeAtHai salvato 3 byte eliminando la ripetizione come suggerito da @Neil.

Avanti, 28 byte

: f depth 1- roll swap - . ;

Prende un elenco di caratteri in pila (metodo standard di Forth per prendere i parametri). I caratteri sono presi in modo tale che la parte superiore della pila sia il primo carattere della stringa. Spingo la parte inferiore della pila in alto, cambio, quindi sottrai e stampo. L'immondizia viene lasciata nella pila e l'output viene stampato su stdout.

Se ogni carattere fosse inserito nello stack in ordine anziché in ordine inverso, il programma sarà più corto di 2 byte. Non sono sicuro che sia consentito, tuttavia, perché normalmente si spingono gli argomenti in ordine inverso.

Provalo online

Chiamato così:

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

Spiegazione:

Questo utilizza lo stesso principio del telescopio:

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

Generalizzata per qualsiasi sequenza di caratteri di lunghezza n, la risposta è c[n-1] - c[0]perché tutte le cose nel mezzo si cancellano.

PHP 7.1, 33 31 byte

Utilizza offset di stringa negativi implementati in PHP 7.1.

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

Esegui in questo modo:

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

Ritocchi

• Salvato 2 byte utilizzando $argn

RProgN , 142 byte, senza competizione

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

Non competitivo, poiché il comando 'tostack' è stato aggiunto dopo la scoperta di questa sfida (anche se ha un numero di byte terribile)

Casi test

Hello, World!
-39

Cool, huh?
-4

Spiegazione

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 è un linguaggio esoterico a cui ho lavorato pensando alla notazione polacca inversa. Al momento è piuttosto prolisso, con un'assegnazione variabile di 4 caratteri e simili, tuttavia in futuro prevedo di aggiungere un po 'di zucchero sintatico.

Inoltre, RProgN accede implicitamente agli argomenti dallo stack e li restituisce allo stesso modo. Tutti i dati di stringa lasciati nello stack al termine del programma vengono stampati implicitamente.

PHP, 36 byte

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

• Ogni personaggio tranne il primo e l'ultimo vengono aggiunti e sottratti una volta ciascuno.
  → somma delle differenze == differenza tra il primo e l'ultimo carattere
• ord()in PHP opera sul primo carattere di una stringa
  → non è necessario ridurlo esplicitamente a un singolo carattere

Brain-Flak , 34 32 + 3 = 35 byte

+3 a causa della -abandiera richiesta per la modalità ASCII.

Provalo online

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

Stranamente è più efficiente usare effettivamente la definizione usata nelle specifiche piuttosto che il "trucco" di sottrarre il primo dall'ultimo.

Questo funziona esattamente.

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

CJam , 8 5 byte

Grazie mille a Dennis per due suggerimenti che hanno rimosso 3 byte

l)\c-

Provalo online!

Spiegazione

Calcola l'ultimo valore meno il primo valore.

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

utilizzo:

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]

Provalo online!

In modalità aritmetica, #nameottiene il codice carattere del primo carattere name. Impostiamo cl'ultimo carattere e prendiamo la differenza tra il primo e l'ultimo codice.

Haskell , 30 byte

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

Provalo online!

Sottrae il valore ordinale dell'ultimo carattere dal primo.

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

Codice non testato e test:

Provalo qui.

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

Produzione: -39

Clojure, 31 byte

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

Qualcuno ha già ridotto l'attività a un'unica operazione.