Votre soumission doit prendre une liste de nombres (dans le format de liste pris en charge par votre langue, ou en utilisant plusieurs paramètres de fonction / ligne de commande) ou une chaîne de nombres séparés par un caractère qui ne l'est pas 0123456789. Dans une langue, il doit les ajouter tous et produire la somme. Dans une autre langue, il doit les sortir soustraits les uns des autres dans l'ordre. Exemple:

12
5
7
2

Dans une langue, il doit sortir 26et dans une autre, il doit sortir -2. Notez que tous les nombres entrés seront des entiers positifs inférieurs à 100. Il n'y aura jamais plus que de 20nombres fournis, donc vous ne sortirez jamais plus 2000ou moins que -1899. Des questions? Commentaires ci-dessous!

Gelée / 05AB1E , 3 octets

00000000: c6 71 53                                         .qS

Il s'agit d'un vidage hexadécimal (xxd) du programme soumis.

Essayez-le en ligne!

Gelée: somme

Jelly utilise la page de codes Jelly , donc il voit les caractères suivants.

İqS

Essayez-le en ligne!

Comment ça fonctionne

İqS  Main link. Argument: A (array)

İ    (ignored)
 q   Unrecognized token. This breaks the link; nothing to the left is executed.
  S  Take the sum of A.

05AB1E: Différence

05AB1E utilise Windows-1252 , il voit donc les caractères suivants.

ÆqS

Essayez-le en ligne!

Comment ça fonctionne

Æ     Take the difference of the input.
 q    Quit.
  S   (ignored)

Python 2/3, 52 octets

lambda l:sum(l[:1]+[x*int(1-(1/2)*4)for x in l[1:]])

int(1-(1/2)*4)renvoie 1en Python 2 car 1/2évalue d'abord à 0, puis 0 * 4 = 0.

int(1-(1/2)*4)renvoie -1en Python 3 car 1/2évalue d'abord à 0.5, puis int(0.5 * 4) = int(2.0) = 2.

C et C ++ (tous deux de GCC), 81 75 73 octets

int c;int f(int*a,int l){auto d=.5;c=*a++;for(;--l;a++)c+=*a-4*d**a;c=c;}

Prend un pointeur sur le tableau et la longueur.

Explication: _{toujours en utilisant l'explication de @Steadybox: p} En C, auto d=.5déclare une variable entière avec la classe de stockage automatique (qui est la valeur par défaut), qui est ensuite initialisée à 0, tandis qu'en C ++ 11, elle déclare un double, qui est initialisé à 0,5.

Langue C - plus: essayez-la en ligne!

C ++ - langage moins: essayez-le en ligne!

05AB1E / Gelée , 5 octets

00000000: 4f71 7f5f 2f                             Oq._/

Essayez-le en ligne! (05AB1E)
Essayez-le en ligne! (Gelée)

05AB1E voit :

Oq? _ /

Argument implicite Oq? _ / 1.
O Prenez la somme du premier élément saisi.
 q Quittez.
  ?_/ Non fonctionnel.

Jelly voit :

Oq
_ /

_ / Lien principal. Arguments: z
_ / Soustrayez les éléments de z dans l'ordre.

Lien Oq Helper. Non fonctionnel.

En fait / Jelly , 4 octets

00000000: e4 81 5f 2f                                      .._/

Il s'agit d'un vidage hexadécimal (xxd) du programme soumis. Il ne peut pas être testé sous forme brute en ligne; TIO ne prend pas en charge le codage CP437.

En fait: Sum

Utilise en fait le CP 437 , il voit donc les caractères suivants.

Σü_/

Essayez-le en ligne!

Comment ça fonctionne

Σ     Take the sum on the input.
 ü    Print and empty the stack.
  _   Natural logarithm. Ignored since the stack is empty.
   /  Float division. Ignored since the stack is empty.

Gelée: différence

Jelly utilise la page de codes Jelly , donc il voit les caractères suivants.

ỵ¹_/

Essayez-le en ligne!

Comment ça fonctionne

ỵ¹_/  Main link. Argument: A (array)

ỵ     Unrecognized token. Splits the link.
 ¹    Identity; yield A.
  _/  Reduce (/) A by subtraction (_).

Python 2 et 3, 44 41 octets

lambda l:eval(l.replace(' ','-+'[1/2>0]))

Prend des nombres séparés par des espaces.

-3 octets grâce à @JonathanAllan

Essayez-le en ligne: Python 2 (moins) Python 3 (plus)

CJam / Jelly , 6 octets

q~:-
S

CJam

q~    e# Read a list from input
:-    e# Reduce by subtraction
S     e# Push a space
      e# Implicit output

Essayez-le en ligne!

Gelée

(en utilisant UTF-8, pas la page de codes Jelly)

q~:-est le lien d'aide. Puisqu'il n'est pas appelé, peu importe ce qu'il fait.Scalcule la somme d'un tableau.

Essayez-le en ligne!

JavaScript / Cubix, 36 octets

//.!v+u;$I^@O<.Iu
a=>eval(a.join`-`)

Essayez!

La fonction JavaScript peut être testée à l'aide de l'extrait ci-dessous, le programme Cubix peut être testé ici .

Comment cela marche-t-il?

Javascript

La première ligne est un commentaire de ligne vers JavaScript, car elle commence par deux barres obliques, donc JavaScript ne voit que la ligne du bas ( a=>eval(a.join`-`)), qui prend un tableau en entrée, le joint avec des signes moins entre les deux, puis l'exécute en tant que code, ce qui entraîne la soustraction de tous les éléments du tableau.

let f=
//.!v+u;$I^@O<.Iu
a=>eval(a.join`-`)

console.log(f([1,2,3,4,5]))
console.log(f([3,1,4,1,5]))

Cubix

Cubix voit le cube suivant (notez que Cubix ignore tous les espaces blancs):

      / / .
      ! v +
      u ; $
I ^ @ O < . I u a = > e
v a l ( a . j o i n ` -
` ) . . . . . . . . . .
      . . .
      . . .
      . . .

Le début

L'IP commence sur la troisième ligne, pointant vers l'est. Il frappe la 'I'commande, qui prend un nombre de l'entrée et le pousse vers la pile. Ensuite, il est redirigé par '^'dans la boucle de somme.

Boucle de somme

J'ai supprimé tous les caractères ne faisant pas partie de la boucle de somme et les ai remplacés par no-ops ( '.'). L'IP arrive initialement sur la deuxième ligne, pointant vers l'est.

      . . .
      ! v +
      u ; $
. . . . . . I u . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Tout d'abord, la '!'commande vérifie l'élément supérieur. Si c'est le cas 0(c'est-à-dire que nous avons atteint la fin de l'entrée), l'instruction suivante ( 'v') est exécutée, reflétant l'IP hors de la boucle. Si nous n'avons pas encore atteint la fin de l'entrée, nous ajoutons les deux premiers éléments ensemble ( '+', le deuxième élément est la somme jusqu'à ce point, l'élément supérieur la nouvelle entrée). Ensuite, l'IP passe à une autre face du cube, dans le 'u'caractère, ce qui fait que l'IP fait demi-tour et exécute une 'I'commande (lire un autre entier d'entrée), tout en pointant vers le nord. L'IP revient à la face supérieure, ignore ( '$') l'instruction de suppression (';' ) et fait un autre demi-tour, retour au point où nous avons commencé.

La fin

Si l'IP se reflète hors de la boucle, les caractères suivants sont exécutés:

      . . .
      . v .
      . ; .
. . @ O < . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Ces instructions suppriment l'élément supérieur (qui est zéro), puis sortent l'élément supérieur (la somme) sous forme d'entier. Ensuite, la '@'commande est atteinte, donc le programme se termine.

Python 2 et 3, 33 octets

lambda l,*r:l+sum(r)*(1/2>0 or-1)

Prend l'entrée en tant que paramètres séparés.

Python 2.
Python 3.

JS (ES6), CGL (CGL Golfing Language) , 32 26 octets

 x=>eval(x.join`-`)
//-⨥

JS fait la soustraction et CGL fait l'addition.

JS:

x=>eval(x.join`-`)

Une fonction anonyme qui soustrait chaque élément du tableau à l'aide Array#reduce.

//-⨥

Un commentaire.

CGL

 x=>eval(x.join`-`)

Ce qui ressemble à un espace sur la première ligne est en fait un espace insécable, un commentaire en CGL. La première ligne est ignorée.

//-⨥

Les /s ne font rien. Le -décrémente le pointeur de pile actuel de sorte qu'il pointe vers l'entrée. ⨥ajoute la pile actuelle (entrée) ensemble, la pousse dans la pile suivante et incrémente la pile actuelle. Il est implicitement sorti.

JavaScript (ES6) / QBasic, 84 83 octets

'';f=x=>eval(x.join`+`)/*
INPUT a
FOR i=1 TO 2
i=0
INPUT n
a=a-n
PRINT a
NEXT i
'*/

Une autre solution avec le commentaire hack!

JavaScript calcule la somme. Il prend en entrée un tableau contenant des nombres. Sorties comme fonction return. Vous pouvez appeler la fonction commealert(f([10,20,30])) .

QBasic calcule la différence. Demande à plusieurs reprises des commentaires. Dès que vous entrez une valeur, il affiche la différence de tous les nombres que vous avez entrés jusqu'au moment de la frappe Enteret demande à nouveau une entrée. Continue à faire de même jusqu'à la fin de tout.

Comment ça marche?

Dans QBasic (un langage de la famille BASIC structurée; il ne nécessite pas de numéros de ligne), 'marque le début d'un commentaire qui va jusqu'à la fin de la ligne. Alors qu'en JavaScript, il marque le début d'une chaîne. Ainsi, toute la première ligne est marquée comme un commentaire dans QBasic mais en JavaScript, la ligne est exécutée (et cette ligne contient la partie JavaScript qui ajoute les chiffres ainsi qu'un /*à la fin qui commence un commentaire afin de masquer le reste du code QBasic de l'interpréteur JavaScript.)

Le code de la deuxième ligne à l'avant-dernière ligne contient le code QBasic pour calculer la différence de tous les numéros d'entrée (le code est très explicite).

La dernière ligne contient '*/. 'oblige l'interpréteur QBasic à interpréter le code suivant comme un commentaire, alors qu'en JavaScript, il n'a aucun effet car il fait partie d'un commentaire (qui a été démarré à la fin de la première ligne). Le code suivant ( */) oblige JavaScript à terminer le commentaire qui a été démarré dans la première ligne, mais il n'est pas exécuté dans QBasic car QBasic pense qu'il fait partie d'un commentaire.

Cas de test

JavaScript (ajoute):

'';f=x=>eval(x.join`+`);/*
INPUT a
FOR i=1 TO 2
i=0
INPUT n
a=a-n
PRINT a
NEXT i
'*/
console.log(f([12,5,7,2]));

QBasic (soustrait):

Accédez à ce site Web . Copiez collez le code suivant dans leur éditeur de texte:

1 '';f=x=>eval(x.join`+`);/*
2 INPUT a
3 FOR i=1 TO 2
4 i=0
5 INPUT n
6 a=a-n
7 PRINT a
8 NEXT i
9 '*/

La raison pour laquelle les numéros de ligne sont requis est que le site Web que j'ai mentionné ne prend en charge que les langues BASIC non structurées. Et ce site Web est le seul interprète BASIC en ligne décent que j'ai pu trouver. Cependant, l'exécution du code présent en haut de la publication (le code sans numéros de ligne) devrait fonctionner correctement dans tout bon interpréteur QBasic qui prend en charge le BASIC structuré et en 'tant que démarreur de commentaires (peu le font pas, la plupart le font cependant).

Remarques

• Ceci est mon premier article polyglotte ! J'espère que c'est un bon!
• La partie QBasic du code ne nécessite pas, ENDcar l'interpréteur ne l'atteindra jamais! (Il restera à jamais coincé dans la boucle infinie; demandant toujours plus d'entrée.)

Brain-Flak / Brain-Flueue , 20 octets

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

Essayez-le en ligne! (Brain-Flak) (plus)

Essayez-le en ligne! (Cerveau-Flueue) (moins)

Explication

La seule différence entre Brain-Flak et Brain-Flueue est que Brain-Flueue remplace les deux piles (dernier entré premier sorti) utilisées dans Brain-Flak par deux files d'attente (premier entré premier sorti). Naturellement, ce programme utilise cette différence.

Code annoté

(                  ) Push the sum of...
 {}                   the first input,
   <            >     zero,
                 {}   the remaining sum (see below)
    ([      ])       Push the of below line
      ({{}})         Pop all the input sans first, push the sum
              {}     Pop (in Brain-Flak, this discards the negative sum,
                            in Brain-Flueue, the positive)