Défi

Étant donné une chaîne telle que Hello World!, décomposer en ses valeurs de caractères: 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33.

Puis calculer la différence entre chaque paire consécutive de caractères: 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67.

Enfin, résumer les imprimer et le résultat final: -39.

Règles

• Des échappatoires standard s'appliquent
• Aucune utilisation de fonctions prédéfinies qui effectuent cette tâche exacte
• Des solutions créatives encouragées
• S'amuser
• Ceci est marqué comme code-golf , la réponse la plus courte en octets gagne mais ne sera pas sélectionnée.

Python, 29 octets

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

La somme des différences forme une série télescopique, donc la plupart des sommets s'annulent et
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) +… + (s _n-1 - s _n-2 ) + (s _n - s _n-1 ) = s _n - s ₀ .

Si la prise d'une chaîne d'octets en entrée est autorisée

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

fonctionnera également pendant 19 octets .

Testez les deux sur Ideone .

MATL , 2 octets

ds

Essayez-le en ligne!

Explication:

dobtient la différence entre les caractères consécutifs et sadditionne le tableau résultant. Ensuite, la valeur en haut de la pile est implicitement imprimée. Pas grand chose d'autre à dire à ce sujet.

Chose intéressante, même si Dennis a découvert un raccourci génial, son utilisation serait considérablement plus longue en MATL.

Gelée , 3 octets

OIS

Essayez-le en ligne!

Prenez les Ordinals des caractères de la chaîne d'entrée, puis les Increments de cette liste, puis le Sum de cette liste.

MATLAB, 16 octets

@(x)sum(diff(x))

Cela crée une fonction anonyme nommée ansqui peut être appelé comme: ans('Hello world!').

Voici une démo en ligne dans Octave qui nécessite un octet supplémentaire +pour convertir explicitement la chaîne d'entrée en un tableau numérique avant de calculer la différence d'élément à élément

Python, 63 octets

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

Ideone it!

Cubix , 13 octets

Cubix est un langage bidimensionnel enroulé autour d'un cube.

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

Testez-le en ligne! Cela correspond au réseau de cubes suivant:

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

Où l'IP (pointeur d'instruction) commence en haut à gauche de la face la plus à gauche.

Comment ça fonctionne

Tout d'abord, l'IP frappe le miroir /qui le redirige sur la iface supérieure. La face supérieure est une boucle qui entre continuellement des codes de caractères jusqu'à ce que l'EOF soit atteint. Lorsque l'entrée est vide, le résultat de iest -1; l'IP tourne à gauche de la ?, en frappant /à l'extrême droite et en passant par les commandes suivantes:

• ; - Pop l'élément supérieur (-1).
• # - Poussez la longueur de la pile.
• t- Pop l'élément supérieur et obtenir l'élément à cet index dans la pile. Cela tire l'élément inférieur.
• - - Soustraire.
• O - Sortie sous forme d'entier.
• /- Dévie l'adresse IP vers @, ce qui met fin au programme.

C #, 22 octets

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

Code source complet avec scénario de test:

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 # avec LINQ, 17 octets

Une version plus courte, utilisant LINQ, grâce à hstde :

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

Cependant, une importation supplémentaire est nécessaire:

using System.Linq;

Rubis, 23 octets

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

Attribuer à une variable comme f=->s{s[-1].ord-s[0].ord}et appeler commef["Hello World!"]

Utilise l'observation de Dennis sur les séries télescopiques.

réticulaire, 12 octets

idVc~@qVc-o;

Essayez-le en ligne!

En utilisant l'observation de Dennis , nous pouvons raccourcir un processus itératif en un processus plus simple.

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 octets

48 octets de code plus trois octets pour le -adrapeau, ce qui permet l'entrée ASCII (mais la sortie décimale. Comme c'est pratique.: D)

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

Essayez-le en ligne!

Celui-ci est un peu plus difficile que mon autre réponse, haha. Permet de le parcourir.

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

Ç¥O

Essayez-le en ligne!

Utilise l'encodage CP-1252.

Explication

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

Brachylog , 7 octets

@c$)@[-

Essayez-le en ligne!

Explication

@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

Puisque soustraire ne fonctionne que pour une entrée de deux entiers, il réussira une fois le préfixe sélectionné [33, 72].

Haskell, 32 octets

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

R, 69 43 32 octets

Une réponse très non concurrente même si je pensais que ce serait amusant de présenter une solution possible dans R.

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

Le seul aspect intéressant de cette réponse est l'utilisation de sapplyet charToRaw. J'ai d'abord divisé la chaîne en un vecteur de caractères que je souhaite convertir en ses représentations entières ASCII. La charToRawfonction n'est pas vectorisée en R et au lieu de boucler sur chaque valeur dans le vecteur susmentionné que j'utilise sapplyqui vectorise efficacement la fonction. Prenez ensuite la 1ère différence puis additionnez.

Edit: s'avère charToRawtransformer une chaîne en un vecteur où chaque élément est la représentation brute de chaque caractère, donc pas besoin d'utiliser strsplitetsapply

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

Edit2: Il s'avère qu'il existe un moyen encore meilleur, la fonction utf8ToInt(x)fait exactement ce strtoi(charToRaw(x),16)qui signifie que nous pouvons économiser quelques octets de plus (idée tirée de la réponse de @ rturnbull à une autre question):

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

Perl, 19 octets

Comprend +1 pour -p

Donnez votre avis sur STDIN sans nouvelle ligne finale

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

slope.pl:

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

Si vous êtes sûr que la chaîne d'entrée comporte au moins 2 caractères, cette version de 17 octets fonctionne également:

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

NodeJS, 82 octets

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

Explication:

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 octets

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}

Même idée que ci-dessus avec une entrée de fonction au lieu d'un argument.

JavaScript ES6, 42 39 octets

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

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

Utilisation de l'observation @Dennis sur les sommes du télescope.

Je pense que dans ce cas, la solution triviale est la plus courte.

Enregistré 3 octets en se débarrassant de la charCodeAtrépétition comme suggéré par @Neil.

Forth, 28 octets

: f depth 1- roll swap - . ;

Prend une liste de caractères sur la pile (méthode standard de Forth de prise de paramètres.) Les caractères sont pris de telle sorte que le haut de la pile est le premier caractère de la chaîne. Je déplace le bas de la pile vers le haut, permute, puis soustrais et imprime. Les déchets sont laissés sur la pile et la sortie est imprimée sur stdout.

Si chaque caractère était poussé dans la pile dans l'ordre au lieu de l'ordre inverse, le programme serait plus court de 2 octets. Je ne sais pas si c'est autorisé, car normalement, vous poussez les arguments dans l'ordre inverse.

Essayez-le en ligne

Appelé comme ceci:

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

Non golfé:

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

Explication:

Celui-ci utilise le même principe que le télescopage:

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

Généralisée pour n'importe quelle séquence de caractères de longueur n, la réponse est c[n-1] - c[0]parce que tout ce qui se trouve au milieu s'annule.

PHP 7.1, 33 31 octets

Utilise des décalages de chaîne négatifs implémentés en PHP 7.1.

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

Courez comme ceci:

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

Tweaks

• Enregistré 2 octets en utilisant $argn

RProgN , 142 octets, non concurrent

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 compétitif, car la commande 'tostack' a été ajoutée après la découverte de ce défi (même si le nombre d'octets est terrible)

Cas de test

Hello, World!
-39

Cool, huh?
-4

Explication

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 est un langage ésotérique sur lequel j'ai travaillé avec la notation polonaise inversée à l'esprit. Il est actuellement assez verbeux, avec une affectation variable de 4 caractères, et je prévois toutefois à l'avenir d'ajouter un peu de sucre syntaxique.

En outre, RProgN accède implicitement aux arguments de la pile et les renvoie de la même manière. Toutes les données de chaîne laissées dans la pile après la fin du programme sont imprimées implicitement.

PHP, 36 octets

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

• Chaque caractère sauf le premier et le dernier est ajouté et soustrait une fois chacun.
  → somme des différences == différence entre le premier et le dernier caractère
• ord()en PHP fonctionne sur le premier caractère d'une chaîne
  → pas besoin de le réduire explicitement à un seul caractère

Brain-Flak , 34 32 + 3 = 35 octets

+3 en raison du -adrapeau requis pour le mode ascii.

Essayez-le en ligne

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

Étrangement, il est plus efficace d'utiliser réellement la définition utilisée dans les spécifications plutôt que le "truc" de soustraire du premier au dernier.

Cela fonctionne en faisant exactement cela.

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

CJam , 8 5 octets

Un grand merci à Dennis pour deux suggestions qui ont supprimé 3 octets

l)\c-

Essayez-le en ligne!

Explication

Calcule la dernière valeur moins la première valeur.

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 octets

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

usage:

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

Haskell (Lambdabot), 31 octets

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

Zsh , 22 octets

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

Essayez-le en ligne!

En mode arithmétique, #nameobtient le code de caractère du premier caractère name. Nous définissons cle dernier caractère et prenons la différence entre le premier et le dernier code.

Haskell , 30 octets

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

Essayez-le en ligne!

Soustrait la valeur ordinale du dernier caractère du premier.

Haskell, 61 octets

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

Java 7, 100 96 octets

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

Code non testé et testé:

Essayez-le ici.

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

Production: -39

Clojure, 31 octets

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

Quelqu'un a déjà réduit la tâche à une seule opération.