L'invio deve contenere un elenco di numeri (in qualsiasi formato di elenco supportato dalla propria lingua, oppure utilizzando più parametri funzione / riga di comando) o una stringa di numeri separati da qualsiasi carattere che non lo sia 0123456789. In una lingua, deve aggiungerle tutte e generare la somma. In un'altra lingua, deve emetterli sottratti l'uno dall'altro in ordine. Esempio:

12
5
7
2

In una lingua, deve produrre 26, e in un'altra deve produrre -2. Si noti che tutti i numeri immessi saranno numeri interi positivi inferiori a 100. Non ci saranno mai più dei 20numeri forniti, quindi non otterrai mai un valore maggiore 2000o minore di -1899. Qualsiasi domanda? Commenta sotto!

Jelly / 05AB1E , 3 byte

00000000: c6 71 53                                         .qS

Questo è un hexdump (xxd) del programma inviato.

Provalo online!

Gelatina: Somma

Jelly utilizza la tabella codici Jelly , quindi vede i seguenti caratteri.

İqS

Provalo online!

Come funziona

İ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: differenza

05AB1E utilizza Windows-1252 , quindi vede i seguenti caratteri.

ÆqS

Provalo online!

Come funziona

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

Python 2/3, 52 byte

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

int(1-(1/2)*4)ritorna 1in Python 2 perché 1/2valuta prima 0e poi 0 * 4 = 0.

int(1-(1/2)*4)ritorna -1in Python 3 perché 1/2valuta prima 0.5e poi int(0.5 * 4) = int(2.0) = 2.

C e C ++ (entrambi da GCC), 81 75 73 byte

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

Porta un puntatore all'array e alla lunghezza.

Spiegazione: _{usando ancora la spiegazione di @Steadybox: p} In C, auto d=.5dichiara una variabile intera con la classe di memorizzazione automatica (che è l'impostazione predefinita), che viene quindi inizializzata su 0, mentre in C ++ 11 dichiara un doppio, che viene inizializzato a 0,5.

C - plus language: provalo online!

C ++ - meno linguaggio: provalo online!

05AB1E / Gelatina , 5 byte

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

Provalo online! (05AB1E)
Provalo online! (Gelatina)

05AB1E vede :

OQ? _ /

Oq? _ / 1 argomento implicito.
O Prendi la somma del primo elemento di input.
 q Esci.
  ? _ / Non funzionale.

Jelly vede :

OQ
_ /

_ / Link principale. Argomenti: z
_ / Sottrai gli elementi di z in ordine.

Oq Helper link. Non funzionale.

In realtà / Jelly , 4 byte

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

Questo è un hexdump (xxd) del programma inviato. Non può essere testato in forma grezza online; TIO non supporta la codifica CP437.

In realtà: somma

Attualmente utilizza CP 437 , quindi vede i seguenti caratteri.

Σü_/

Provalo online!

Come funziona

Σ     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.

Gelatina: differenza

Jelly utilizza la tabella codici Jelly , quindi vede i seguenti caratteri.

ỵ¹_/

Provalo online!

Come funziona

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

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

Python 2 e 3, 44 41 byte

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

Accetta numeri separati da spazi.

-3 byte grazie a @JonathanAllan

Provalo online: Python 2 (meno) Python 3 (plus)

CJam / Jelly , 6 byte

q~:-
S

CJam

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

Provalo online!

Gelatina

(usando UTF-8, non la tabella codici Jelly)

q~:-è il collegamento di aiuto. Dal momento che non viene chiamato, non importa davvero cosa fa. Scalcola la somma di un array.

Provalo online!

JavaScript / Cubix, 36 byte

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

Provalo!

La funzione JavaScript può essere testata utilizzando lo snippet di seguito, il programma Cubix può essere testato qui .

Come funziona?

JavaScript

La prima riga è un commento di riga a JavaScript, poiché inizia con due barre, quindi JavaScript vede solo la riga inferiore ( a=>eval(a.join`-`)), che accetta un array come input, lo unisce tra loro con i segni meno, quindi lo esegue come codice, risultando in la sottrazione di tutti gli elementi dell'array.

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 vede il seguente cubo (notare che Cubix ignora tutti gli spazi bianchi):

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

L'inizio

L'IP inizia sulla terza riga, puntando verso est. Colpisce il 'I'comando, che prende un numero dall'input e lo spinge nello stack. Quindi, viene reindirizzato '^'nel ciclo di somma.

Sum-loop

Ho rimosso tutti i caratteri che non fanno parte del ciclo di somma e li ho sostituiti con no-ops ( '.'). L'IP arriva inizialmente sulla seconda riga, puntando verso est.

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

Innanzitutto, il '!'comando controlla l'elemento superiore. Se questo è 0(cioè abbiamo raggiunto la fine dell'ingresso), 'v'viene eseguita l'istruzione successiva ( ), che riflette l'IP fuori dal ciclo. Se non abbiamo ancora raggiunto la fine dell'input, sommiamo i primi due elementi insieme ( '+'il secondo elemento è la somma fino a quel punto, l'elemento in alto il nuovo input). Quindi, l'IP si sposta su un'altra faccia del cubo, nel 'u'carattere, il che fa sì che l'IP faccia un'inversione di marcia ed esegua un 'I'comando (leggi un altro numero intero di input), mentre punta verso nord. L'IP torna alla faccia superiore, salta ( '$') l'istruzione delete ( ';') e fa un'altra inversione, tornando al punto in cui siamo partiti.

La fine

Se l'IP viene riflesso fuori dal ciclo, vengono eseguiti i seguenti caratteri:

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

Queste istruzioni eliminano l'elemento superiore (che è zero) e quindi producono l'elemento superiore (la somma) come numero intero. Quindi '@'viene raggiunto il comando, quindi il programma termina.

Python 2 e 3, 33 byte

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

Accetta input come parametri separati.

Python 2.
Python 3.

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

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

JS esegue la sottrazione e CGL esegue l'aggiunta.

JS:

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

Una funzione anonima che sottrae ogni elemento dell'array utilizzando Array#reduce.

//-⨥

Un commento.

CGL

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

Quello che sembra uno spazio sulla prima riga è in realtà uno spazio non-break, un commento in CGL. La prima riga viene ignorata.

//-⨥

I /s non fanno nulla. Il -decrementa il puntatore stack corrente così esso sta puntando ingresso. ⨥aggiunge lo stack corrente (input) insieme, lo spinge allo stack successivo e incrementa lo stack corrente. È implicitamente emesso.

JavaScript (ES6) / QBasic, 84 83 byte

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

Un'altra soluzione con l'hack del commento!

JavaScript calcola la somma. Accetta un array contenente numeri come input. Uscite come funzione return. È possibile chiamare la funzione come alert(f([10,20,30])).

QBasic calcola la differenza. Chiede ripetutamente input. Non appena si immette un valore, viene emessa la differenza di tutti i numeri immessi fino al momento del colpo Entere viene nuovamente richiesto l'inserimento. Continua a fare lo stesso fino alla fine di tutto.

Come funziona?

In QBasic (un linguaggio della famiglia BASIC strutturata; non richiede numeri di riga), 'segna l'inizio di un commento che arriva fino alla fine della riga. Considerando che in JavaScript, segna l'inizio di una stringa. Quindi, l'intera prima riga è contrassegnata come un commento in QBasic ma in JavaScript, la riga viene eseguita (e questa riga contiene la parte JavaScript che aggiunge i numeri e un /*alla fine che inizia un commento per nascondere il resto del codice QBasic dall'interprete JavaScript.)

Il codice dalla seconda all'ultima riga contiene il codice QBasic per calcolare la differenza di tutti i numeri di input (il codice è molto autoesplicativo).

L'ultima riga contiene '*/. 'fa sì che l'interprete QBasic interpreti il ​​seguente codice come commento, mentre in JavaScript non ha alcun effetto poiché fa parte di un commento (che è stato avviato alla fine della prima riga). Il codice seguente ( */) fa sì che JavaScript termini il commento che è stato avviato nella prima riga, ma non viene eseguito in QBasic perché QBasic pensa che sia parte di un commento.

Casi test

JavaScript (aggiunge):

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

Vai a questo sito Web . Copia incolla il seguente codice nel loro editor di testo:

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

Il motivo per cui sono richiesti i numeri di riga è che il sito Web che ho citato supporta solo lingue BASIC non strutturate. E quel sito web è l'unico interprete BASIC online decente che ho trovato. Tuttavia, eseguire il codice presente nella parte superiore del post (il codice senza numeri di riga) dovrebbe funzionare bene in qualsiasi buon interprete QBasic che supporti BASIC strutturato e 'come commentatore (pochi però, la maggior parte lo fanno, però).

Appunti

• Questo è il mio primo post poliglotta ! Spero sia buono!
• La parte QBasic del codice non richiede ENDperché l'interprete non lo raggiungerà mai! (Rimarrà per sempre bloccato nel ciclo infinito; chiedendo sempre più input.)

Brain-Flak / Brain-Flueue , 20 byte

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

Provalo online! (Brain-Flak) (più)

Provalo online! (Brain-Flueue) (meno)

Spiegazione

L'unica differenza tra Brain-Flak e Brain-Flueue è che Brain-Flueue sostituisce le due pile (last in first out) utilizzate in Brain-Flak con due code (first in first out). Naturalmente questo programma usa questa differenza.

Codice annotato

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