23

Questo è un problema di NCPC 2005 . Roy ha un appartamento con una sola presa elettrica, ma ha un sacco di prese multiple. Calcola il numero massimo di prese che può avere usando le prese multiple che ha. Il numero di prese per ciabatta viene fornito come input.

Si scopre che se il numero di uscite delle strisce sono rispettivamente

p_{1}, p_{2}, \dots, p_{n}

$p_1, p_2, \dots, p_n$

quindi il numero di punti vendita è ,

1 - n + \sum_{i} p_{i}

$1 - n + \sum_i p_i$

o

.

1 + p_{1} - 1 + p_{2} - 1 + \dots + p_{n} - 1

$1 + p_1-1 + p_2-1 + \dots + p_n-1$

L'input per il programma o la funzione è una serie non vuota di numeri interi positivi.

Esempi

2 3 4
> 7
2 4 6
> 10
1 1 1 1 1 1 1 1
> 1
100 1000 10000
> 11098

code-golf number arithmetic

— Pål GD
fonte

17

E pensavo che non avresti dovuto concatenare le prese multiple ...

— Joey,

Per quanto ne so, la mia risposta alla Retina è l'unica risposta che utilizza un input unario. Potresti dare un'occhiata alla discussione dei commenti qui: codegolf.stackexchange.com/questions/71047/electrical-outlet/… ... Se pensi che la soluzione unaria sia troppo di un hack che non è nello spirito di la sfida, sono felice che tu specifichi che l'input dovrebbe essere in decimale (e quindi risolverò la mia risposta di conseguenza).

— Martin Ender,

7

Poiché l'elettricità è così costosa, il codice dovrebbe essere il più breve possibile per evitare di utilizzare più energia

— cat

1

@cat È ora di scavare il vecchio turing machine e i computer meccanici guidati da criceto.

— Pharap

1

@immibis certo, ma l'output verrebbe trattato come l'informazione contenuta nel flusso di byte, non come ciò che accade tramite il rendering del tuo terminale.

— Martin Ender,

24

Gelatina, 3 byte

’S‘

Decrementa (tutto), somma, incremento. Provalo qui.

— Lynn
fonte

29

Retina , 3 byte

L'alimentazione di linea finale è significativa.

L'input è un elenco separato da spazi di numeri unari .

Provalo online!

Spiegazione

Il codice rimuove semplicemente tutti gli spazi così come il 1 loro dopo dalla stringa. Ecco perché funziona:

L'aggiunta in unario è semplice: basta concatenare i numeri che equivale a rimuovere i delimitatori. Il decremento di 1 è anche semplice: basta rimuovere un 1da ciascun numero. Vogliamo 1 in più rispetto alla somma degli input decrementati, quindi rimuoviamo semplicemente le 1s che troviamo dopo gli spazi, diminuendo così tutto tranne il primo input.

— Martin Ender
fonte

1

Mi chiedo se l'ingresso in unario dovrebbe essere permesso.

— John Dvorak,

@JanDvorak è di default, a meno che la sfida non specifichi esplicitamente l'input decimale. (Vedi il link nella risposta.) Non importa però, Jelly sta vincendo comunque.

— Martin Ender,

@ MartinBüttner Ci sono dati di esempio sia in questa domanda che nell'assegnazione originale. Non pensi (se non diversamente specificato) che dovrebbe essere un criterio necessario (anche se non sufficiente) per il passaggio, che il codice funziona con i dati di esempio testuali?

— nitro2k01,

1

@ nitro2k01 No (in tal caso la maggior parte delle risposte sarebbe probabilmente non valida). A meno che la sfida non specifichi esplicitamente un particolare formato di input, normalmente supponiamo che gli elenchi possano essere presi in qualsiasi formato di elenco nativo . Lo stesso vale per i formati numerici (almeno unari e prendendo numeri interi come valori di byte sono consentiti per consenso a meno che la sfida non li proibisca). È praticamente impossibile includere nella sfida dati di esempio in ogni formato di input nativo pensabile.

— Martin Ender,

@ MartinBüttner Imo, non è questo il problema che la raccomandazione sta affrontando. Ciò che parla ancora contro questo è che (a meno che non mi sbagli) questo non funziona perché unario è un formato numerico supportato o nativo in Retina, ma funziona quando si elabora la stringa come dati di stringa. È un trucco. È anche un trucco intelligente, ma non sono ancora convinto che sia secondo le regole. Se i numeri unari separati da spazi fossero un formato nativo in Retina nello stesso modo in cui un elenco di byte è un formato nativo in bf, sarei d'accordo che la raccomandazione si applica e avrei un'opinione diversa.

— nitro2k01,

9

Esagonia , 18 14 byte

.?<_(@'")>{+.!

non piegato:

  . ? <
 _ ( @ '
" ) > { +
 . ! . .
  . . .

Provalo online!

Non credo che la lunghezza laterale 2 sia possibile, ma ci ~~deve essere~~ potrebbe essere una soluzione più efficiente lato di lunghezza 3 che questo.

Questo è il solito approccio "decrementa tutto, somma, incremento", ma in seguito dovrò aggiungere dei diagrammi per mostrare come funziona esattamente in Hexagony.

— Martin Ender
fonte

7

Python, 24 byte

lambda*n:1-len(n)+sum(n)

Provalo online

— Mego
fonte

1

Ciò presuppone che la funzione sia prima assegnata, quindi applicata all'input da un'altra variabile.

— juandesant,

1

@juandesant ... che va benissimo. È una funzione letterale, che è una forma valida di presentazione.

— FlipTack

7

Mathematica, 9 byte

Tr[#-1]+1&

— A Simmons
fonte

7

Haskell, 17 15 byte

foldl1$(+).pred

Esempio di utilizzo: ( foldl1$(+).pred ) [2,4,6]->10 .

Vecchia versione, approccio diverso, 17 byte: succ.sum.map pred.

— Nome del modello
fonte

6

J, 6 byte

+/+1-#

Somma più una lunghezza meno. Parentesi e applicarlo, in questo modo:

   (+/+1-#) 2 3 4
7

— Lynn
fonte

6

Labirinto , 9 byte

"?;)!@
+(

Provalo online!

Il solito primer:

Labyrinth è basato su 2D e stack. Le pile hanno un numero infinito di zeri sul fondo.
Quando il puntatore dell'istruzione raggiunge una giunzione, controlla la parte superiore dello stack per determinare dove girare successivamente. Il negativo è a sinistra, lo zero è in avanti e il positivo è a destra.

Qui partiamo in alto a sinistra ", no-op, andando verso destra. Il prossimo è? , che legge un int da STDIN (buttando via i caratteri che non può analizzare come un numero intero, ad es. Spazi). Ora abbiamo due casi:

Se l'ingresso è positivo, giriamo a destra, eseguendo:

(            decrement top of stack
+            add top two stack elements
             [continue loop]

Se l'ingresso è zero (che si verifica in EOF), andiamo dritto, eseguendo:

;            pop zero from EOF
)            increment top of stack
!            output top of stack as number
@            halt program

— SP3000
fonte

5

Pyth, 5 byte

hstMQ

incremento (somma (mappa (decremento, input)))

— Lynn
fonte

5

ES6, 25 byte

a=>a.map(n=>r+=n-1,r=1)|r

— Neil
fonte

4

Stavo per pubblicare: "Uno dei rari casi in cui la riduzione vince la partita" ... ed è anche 25 l=>l.reduce((a,b)=>a+b-1).

— edc65,

@ edc65 Sì, (,b)è costoso, ma mi piace anche quella versione.

— Neil,

5

MATL, 3 byte

qsQ

Provalo online.

Spiegazione

qsQ
q      thread decrement over the input array
  s    sum
   Q   increment

— uno spaghetto
fonte

4

05AB1E , 4 byte

Codice:

E<O>

Spiegazione:

E     # Evaluates input
 <    # Decrement on list
  O   # Compute the total sum
   >  # Increment on the sum
      # Implicit: output top of the stack

Accetta input come un array (ad es [3, 4, 5].).

— Adnan
fonte

Molto elegante per un lang del golf

— Pharap

4

Stellato , 26 24 byte

, + '`      + ** `, +'*.

Si aspetta numeri interi separati da nuova riga. Provalo online!

Grazie a @ MartinBüttner per -2 byte.

,           Read line as integer
 + '        Dupe and jump to label 1 if nonzero
`           Set label 0
      +     Push 1
 *          Sub
*           Add
 `          Set label 1
,           Read line as integer
 + '        Dupe and jump to label 0 if nonzero
*           Add
.           Output as integer

Il ciclo viene srotolato in modo che il primo numero non venga ridotto, annullando la necessità di incrementare. Spingere i numeri è costoso in Starry ...

— SP3000
fonte

Conto solo 20 byte.

— Addison Crump,

1

@VoteToClose Hai contato gli spazi iniziali? (

— Presumo che

4

Utilità Bash + GNU, 16

Se sono presenti Nprese multiple, dovrebbero esserci dei N-1separatori nell'elenco di input separato da virgole. Tutto ciò che dobbiamo fare è sostituire i separatori con - 1 +e valutare aritmeticamente:

sed s/,/-1+/g|bc

O usando lo stesso trucco:

Pure Bash (senza utility esterne), 19

echo $[${1//,/-1+}]

— Trauma digitale
fonte

3

APL (NARS 2000), 13 10 byte

{1+(+/⍵)-⍴∊⍵}

Modifica: fino a 10 con l'approccio (migliore) di Lynn.

{1++/1-⍨⍵}

— Koneke
fonte

3

gs2, 5 byte

(CP437-codificati.)

W&Φd'

Questo è read-nums dec m1 sum inc.

— Lynn
fonte

3

CJam, 7 byte

q~:(:+)

Provalo qui.

Stesso approccio di Lynn (decrementa tutto, somma, incremento). Funziona anche per 8 byte (ed è forse un po 'più interessante):

q~{(+}*

Questo piega "decrementa, aggiungi" sulla lista. In questo modo, il decremento viene applicato solo a tutti gli elementi tranne il primo, in modo tale che non dobbiamo occuparci dell'incremento separatamente.

— Martin Ender
fonte

3

C, 60 59 55 byte

x;main(s){while(~scanf("%i",&x))s+=x-1;printf("%i",s);}

— stmbgr1
fonte

3

Perl 6, 14 byte

{1+[+] --«@_}

uso

my &f = {1+[+] --«@_}

say f([2,3,4]) # 7
say f([2,4,6]) # 10
say f([1,1,1,1,1,1,1,1]) # 1
say f([100,1000,10000]) # 11098

— Tasti di scelta rapida
fonte

Ho intenzione di modificare completamente la mia risposta alla stessa cosa (vedi il commento html )

— Brad Gilbert b2gills

11 byte:{.sum-$_+1}

— nwellnhof,

3

Scherzi a parte, 7 byte

,;l@Σ-u

Provalo online!

Spiegazione:

,;l@Σ-u
,        push input
 ;       dupe
  l@     push length (n), swap
    Σ-u  push sum, subtract n, add one

— Mego
fonte

2

Perl 6 , 20 byte

put 1+sum --«@*ARGS

(Puoi usare <<invece di «)

Uso:

$ perl6 -e 'put 1+sum --«@*ARGS' 100 1000 10000
11098

— Brad Gilbert b2gills
fonte

«È un operatore Perl?

— user253751

@immibis In realtà fa parte di diversi operatori Perl 6 @arraya »+« @arrayb ++«@array @array».method @array»++ « a 'space separated' list of words »Molti di questi sono quelli che sono noti come operatori Meta, in quanto si combinano con altri operatori. (Perl 5 attualmente non ha quegli operatori.)

— Brad Gilbert b2gills

2

Perl 5 23 + 2 = 25 o 19 + 2 = 21

Richiede -apbandiere:

map{$.+=($_-1)}@F;$_=$.

Salvato in un file ed esegui come

perl -ap file.pl

EDIT: un'altra risposta, più piccola (19 + 2) ma sostanzialmente copiata dalla risposta dev-null:

$.+=$_-1for@F;$_=$.

— ChatterOne
fonte

2

F #, 25 byte

Seq.fold(fun s n->s+n-1)1

Questa è una funzione che accetta un array / elenco / sequenza di numeri interi e restituisce il risultato richiesto.

Come funziona:

Seq.foldti permette di applicare una funzione a ogni elemento di una sequenza mentre porta in giro uno stato mentre lo fa. Il risultato della funzione applicata al primo elemento fornirà lo stato che verrà inserito nella funzione per il secondo elemento e così via. Ad esempio, per riassumere l'elenco [1; 3; 4; 10], lo scriveresti in questo modo:

Seq.fold (fun sum element -> sum + element) 0 [1; 3; 4; 10]
         (       function to apply        ) ^ (sequence to process)
                                     ( initial state )

Quale sarebbe applicato così:

// First, initial state  + first element
0 + 1  = 1
// Then, previous state + next element until the end of the sequence
1 + 3  = 4
4 + 4  = 8
8 + 10 = 18

Con l'ultimo stato è il valore restituito di Seq.fold.

— Roujo
fonte

2

𝔼𝕊𝕄𝕚𝕟, 5 caratteri / 7 byte

ï⒭+‡_

Try it here (Firefox only).

Utilizza una codifica personalizzata con caratteri a 10 bit (grazie a @Dennis!). Esegui encode('ï⒭+‡_')nella console JS per ottenere il modulo codificato edecode(/*ENCODED TEXT HERE*/) per decodificare il modulo codificato.

Spiegazione

Traduce in Javascript ES6 come:

i=>i.reduce(($,_)=>$+--_)

— Mama Fun Roll
fonte

Codifica interessante.

— lirtosiast

Funziona anche abbastanza bene.

— Mama Fun Roll,

2

Mornington Crescent , 1909 1873 1839 byte

Take Northern Line to Stockwell
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Embankment
Take Northern Line to Stockwell
Take Northern Line to Embankment
Take Circle Line to Temple
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Embankment
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Parsons Green
Take District Line to Embankment
Take Circle Line to Blackfriars
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Provalo online!

— pppery
fonte

"Il 90% di tutte le istruzioni riguarda l'assunzione della District Line." È perché il distretto è dove si trovano tutte le stazioni aritmetiche. Tuttavia, su TIO, non sembra funzionare per nessuno degli esempi .

— NieDzejkob,

1873 byte usando nomi di linee più brevi ove possibile

— NieDzejkob

L'interprete di TIO ha un bug e non implementa Turnham Green

— pepery

Bella presa. Ho inviato un PR che lo risolve a monte.

— NieDzejkob,

1

Python 3, 79 byte

import sys
print(sum(map(lambda x: int(x)-1, sys.stdin.readline().split()))+1)

— Pål GD
fonte

Sembra che tu stia contando una nuova riga come due byte. Forse sostituirlo con un punto e virgola per salvare un byte. Anche alcuni spazi possono essere rimossi.

— Daffy,

1

Rubino, 30 byte

$*.inject(1){|s,v|s+=v.to_i-1}

Abbastanza semplice - a partire da 1, sommare i numeri forniti, ogni -1 (gli argomenti della riga di comando sono presenti $*). La vergogna injectè una parola così lunga.

— Chowlett
fonte

1

PowerShell, 19 byte

$args-join'-1+'|iex

Si noti che 1 + p1-1 + p2-1 + ... + pn-1equivale ap1-1 + p2-1 + ... + pn .

Accetta input come argomenti della riga di comando separati con $args. Noi -joinquelli insieme a un -1+delimitatore per creare una stringa, come 2-1+3-1+4. La stringa viene quindi reindirizzata a Invoke-Expression(simile a eval) e genera il risultato.

— AdmBorkBork
fonte

1

Perl, 21 + 2 = 23 byte

$a+=$_-1for@F;say++$a

Richiede -ae -E:

$ perl -aE'$a+=$_-1for@F;say++$a'<<<'2 3 4'
7

— andlrc
fonte

Puoi usare il -aflag per ottenere una @Fvariabile con elementi già divisi e sostituire -n con -p in modo da non averne bisogno say, riducendolo a 21 + 2:$a+=$_-1for@F;$_=++$a

— ChatterOne

Usare al -pposto di sayè lo stesso perché devo usare $_=comunque.

— Andlrc,

@ChatterOne -aè una buona idea!

— Andlrc,

1

Brainfuck, 15 byte

Presupposto: l'operatore restituisce 0 una volta esaurito tutto l'ingresso e non ci sono prolunghe con 0 spine. Inoltre, l'IO deve essere in valori di byte anziché in codici di caratteri ASCII.

+>,[-[-<+>],]<.

Spiegazione: utilizza 2 registri. Un registro dell'accumulatore "Valore", che rappresenta il numero di dispositivi che possono essere collegati, e un registro "cavo corrente" che tiene traccia del valore del cavo corrente. Si inizia aumentando il valore di 1, per la presa esistente. Quindi, per ogni cavo di prolunga, sottrae uno dal valore poiché viene presa una spina, quindi aumenta il valore del numero di spine.

La maggior parte degli interpreti online non funziona in modalità di input byte non elaborata. Per testarlo online, utilizzare questo codice:

+>,[->-[>+<-----]>---[-<+>]<[-<->]<[-<+>],]<.

— Ethan
fonte

Posso testare il programma da qualche parte?

— Pål GD,

Grazie, ho corretto quegli errori. Non sono a conoscenza di interpreti online che operano in modalità byte. Posso mettere insieme un'implementazione che sottrae '0' dagli input che verranno eseguiti su qualsiasi interprete online.

— Ethan,

Se vuoi testare il codice, eseguilo qui: copy.sh/brainfuck Non mettere spazi tra i valori numerici. Sfortunatamente, poiché funziona in modalità ASCII, il codice demo funzionerà solo su valori a una cifra. Tuttavia, la versione a 15 byte funzionerà correttamente su un valore <= 255. Dopo averlo eseguito, visualizzare il dump della memoria per visualizzare il valore finale.

— Ethan,

Un giorno BF avrà standard adeguati per l'IO previsto e potremo solo dire 'usando lo standard 3' invece di es. 'Input e output sono tutti asciii terminati da null char'.

— Pharap,

Presa elettrica

Esempi

Gelatina, 3 byte

Retina , 3 byte

Spiegazione

Esagonia , 18 14 byte

Python, 24 byte

Mathematica, 9 byte

Haskell, 17 15 byte

J, 6 byte

Labirinto , 9 byte

Pyth, 5 byte

ES6, 25 byte

MATL, 3 byte

Spiegazione

05AB1E , 4 byte

Stellato , 26 24 byte

Utilità Bash + GNU, 16

Pure Bash (senza utility esterne), 19

APL (NARS 2000), 13 10 byte

gs2, 5 byte

CJam, 7 byte

C, 60 59 55 byte

Perl 6, 14 byte

Scherzi a parte, 7 byte

Perl 6 , 20 byte

Uso:

Perl 5 23 + 2 = 25 o 19 + 2 = 21

F #, 25 byte

Come funziona:

𝔼𝕊𝕄𝕚𝕟, 5 caratteri / 7 byte

Spiegazione

Mornington Crescent , 1909 1873 1839 byte

Python 3, 79 byte

Rubino, 30 byte

PowerShell, 19 byte

Perl, 21 + 2 = 23 byte

Brainfuck, 15 byte