Seu envio deve incluir uma lista de números (em qualquer formato de lista que seu idioma suporte, ou usando vários parâmetros de função / linha de comando) ou uma sequência de números separados por qualquer caractere que não seja 0123456789. Em um idioma, ele deve adicionar todos eles e gerar a soma. Em outro idioma, deve produzi-los subtraídos um do outro em ordem. Exemplo:

12
5
7
2

Em um idioma, ele deve produzir 26, e em outro, deve produzir -2. Observe que todos os números introduzidos serão números inteiros positivos menores que 100. Nunca haverá mais do que 20números fornecidos; portanto, você nunca produzirá maior 2000ou menor que -1899. Alguma pergunta? Comente abaixo!

Jelly / 05AB1E , 3 bytes

00000000: c6 71 53                                         .qS

Este é um hexdump (xxd) do programa enviado.

Experimente online!

Jelly: Sum

Jelly usa a página de código Jelly , para ver os seguintes caracteres.

İqS

Experimente online!

Como funciona

İ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: Diferença

05AB1E usa Windows-1252 , para ver os seguintes caracteres.

ÆqS

Experimente online!

Como funciona

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

Python 2/3, 52 bytes

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

int(1-(1/2)*4)retorna 1no Python 2 porque 1/2avalia primeiro 0e depois 0 * 4 = 0.

int(1-(1/2)*4)retorna -1no Python 3 porque 1/2avalia primeiro 0.5e depois int(0.5 * 4) = int(2.0) = 2.

C e C ++ (ambos do GCC), 81 75 73 bytes

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

Leva um ponteiro para matriz e comprimento.

Explicação: _{ainda usando a explicação @Steadybox ': p} Em C, auto d=.5declara uma variável inteira com a classe de armazenamento automático (que é o padrão), que é inicializada como 0, enquanto que no C ++ 11 declara um duplo, que é inicializado a 0,5.

Idioma C - plus: Experimente online!

Menos linguagem: Experimente online!

05AB1E / Jelly , 5 bytes

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

Experimente online! (05AB1E)
Experimente online! (Geléia)

05AB1E vê :

Oq? _ /

Oq? / 1 argumento implícito.
O Pegue a soma do primeiro item de entrada.
 q Saia.
  ?_/ Nao funcional.

Jelly vê :

Oq
_ /

_ / Link principal. Argumentos: z
_ / Subtrai os elementos de z em ordem.

Link Oq Helper. Nao funcional.

Na verdade / geléia , 4 bytes

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

Este é um hexdump (xxd) do programa enviado. Não pode ser testado na forma bruta online; O TIO não suporta a codificação CP437.

Na verdade: soma

Na verdade, usa o CP 437 , para ver os seguintes caracteres.

Σü_/

Experimente online!

Como funciona

Σ     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éia: Diferença

Jelly usa a página de código Jelly , para ver os seguintes caracteres.

ỵ¹_/

Experimente online!

Como funciona

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

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

Python 2 e 3, 44 41 bytes

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

Toma números separados por espaço.

-3 bytes graças a @JonathanAllan

Experimente online: Python 2 (menos) Python 3 (mais)

CJam / Jelly , 6 bytes

q~:-
S

CJam

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

Experimente online!

Geléia

(usando UTF-8, não a página de código Jelly)

q~:-é o link auxiliar. Como não é chamado, realmente não importa o que faz. Scalcula a soma de uma matriz.

Experimente online!

JavaScript / Cubix, 36 bytes

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

Tente!

A função JavaScript pode ser testada usando o trecho de código abaixo, o programa Cubix pode ser testado aqui .

Como é que isso funciona?

Javascript

A primeira linha é um comentário de linha para JavaScript, uma vez que começa com duas barras, portanto, o JavaScript vê apenas a linha inferior ( a=>eval(a.join`-`)), que recebe uma matriz como entrada, junta-a com sinais de menos entre elas e executa como código, resultando em a subtração de todos os elementos na matriz.

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

O Cubix vê o seguinte cubo (observe que o Cubix ignora todos os espaços em branco):

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

O início

O IP começa na terceira linha, apontando para o leste. Ele atinge o 'I'comando, que pega um número da entrada e o empurra para a pilha. Em seguida, ele é redirecionado '^'para o loop de soma.

Loop de soma

Eu removi todos os caracteres que não fazem parte do loop de soma e os substitui por no-ops ( '.'). O IP chega inicialmente na segunda linha, apontando para o leste.

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

Primeiro, o '!'comando verifica o elemento superior. Se isso é 0(ou seja, chegamos ao final da entrada), a próxima instrução ( 'v') é executada, refletindo o IP fora do loop. Se ainda não chegamos ao final da entrada, adicionamos os dois itens principais ( '+'o segundo item é a soma até esse ponto, o item principal é a nova entrada). Em seguida, o IP passa para outra face do cubo, no 'u'caractere, o que faz com que o IP faça uma inversão de marcha e execute um 'I'comando (leia outro número inteiro de entrada), enquanto aponta para o norte. O IP volta para a face superior, pula ( '$') a instrução de exclusão ( ';') e faz outra inversão de marcha, de volta ao ponto em que começamos.

O fim

Se o IP for refletido fora do loop, os seguintes caracteres serão executados:

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

Essas instruções excluem o elemento superior (que é zero) e, em seguida, emitem o elemento superior (a soma) como um número inteiro. Em seguida, o '@'comando é atingido, para que o programa termine.

Python 2 e 3, 33 bytes

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

Recebe a entrada como parâmetros separados.

Python 2.
Python 3.

JS (ES6), CGL (linguagem de golfe CGL) , 32 26 bytes

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

JS faz a subtração e CGL faz a adição.

JS:

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

Uma função anônima que subtrai cada elemento da matriz usando Array#reduce.

//-⨥

Um comentário.

CGL

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

O que parece um espaço na primeira linha é na verdade um espaço sem quebra, um comentário no CGL. A primeira linha é ignorada.

//-⨥

Os /s não fazer nada. O -decrementa o ponteiro atual da pilha, apontando para a entrada. ⨥adiciona a pilha atual (entrada), empurra para a próxima pilha e incrementa a pilha atual. É gerado implicitamente.

JavaScript (ES6) / QBasic, 84 83 bytes

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

Outra solução com o comentário hack!

JavaScript calcula a soma. Ele recebe uma matriz contendo números como entrada. Saídas como função return. Você pode chamar a função como alert(f([10,20,30])).

QBasic calcula a diferença. Solicita repetidamente a entrada. Assim que você insere um valor, ele gera a diferença de todos os números digitados até o momento da batida Entere novamente solicita a entrada. Continua fazendo o mesmo até o fim de tudo.

Como funciona?

No QBasic (um idioma da família BASIC estruturada; não requer números de linha), 'marca o início de um comentário que vai até o final da linha. Enquanto no JavaScript, ele marca o início de uma string. Portanto, a primeira linha inteira é marcada como um comentário no QBasic, mas no JavaScript, a linha é executada (e essa linha contém a parte do JavaScript que adiciona os números e também uma /*no final que inicia um comentário para ocultar o restante do código QBasic do interpretador JavaScript.)

O código da segunda linha para a segunda linha contém o código QBasic para calcular a diferença de todos os números de entrada (o código é muito auto-explicativo).

A última linha contém '*/. 'faz com que o intérprete QBasic interprete o código a seguir como um comentário, enquanto que no JavaScript ele não tem nenhum efeito, pois faz parte de um comentário (iniciado no final da primeira linha). O código a seguir ( */) faz com que o JavaScript termine o comentário iniciado na primeira linha, mas não é executado no QBasic porque o QBasic acha que faz parte de um comentário.

Casos de teste

JavaScript (adiciona):

'';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 (subtrai):

Vá para este site . Copie e cole o seguinte código no editor de texto:

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 '*/

A razão pela qual os números de linha são necessários é que o site que mencionei suporta apenas idiomas BASIC não estruturados. E esse site é o único intérprete online BASIC decente que eu pude encontrar. No entanto, a execução do código presente na parte superior da postagem (o código sem números de linha) deve funcionar bem em qualquer bom intérprete QBasic que ofereça suporte ao BASIC estruturado e 'como iniciador de comentários (poucos, no entanto, a maioria o faz).

Notas

• Este é o meu primeiro post poliglota ! Espero que seja uma boa!
• A parte QBasic do código não requer ENDporque o intérprete nunca o alcançará! (Ele ficará preso para sempre no loop infinito; sempre pedindo mais informações.)

Flak cerebral / Flueue cerebral , 20 bytes

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

Experimente online! (Flak cerebral) (mais)

Experimente online! (Conduto cerebral) (menos)

Explicação

A única diferença entre o Brain-Flak e o Brain-Flueue é que o Brain-Flue substitui as duas pilhas (a última a entrar pela primeira vez) usadas na Brain-Flak por duas filas (a primeira a entrar pela primeira vez). Naturalmente, este programa usa essa diferença.

Código anotado

(                  ) 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)