Conteggio a somma zero

25

Scrivere un programma o una funzione che, dato n ≥ 1, riporta il numero di soluzioni a ± 1 ± 2 ± 3 ± ... ± n = 0.

Per n = 6 non ci sono soluzioni, quindi la risposta è 0. Per n = 4 ci sono due soluzioni, quindi la risposta è 2 (le due soluzioni sono 1 - 2 - 3 + 4 = -1 + 2 + 3 - 4 = 0).

Questa è la sequenza OEIS A063865 . Alcuni esempi di input / outpus sono:

n       a(n)
1       0
2       0
3       2
4       2
5       0
6       0
7       8
8       14
9       0
10      0
11      70
12      124
13      0
14      0
15      722
16      1314

Vince il codice più breve in byte.

code-golf math arithmetic

— orlp
fonte

2

Correlati

— Manish Kundu

1

@ManishKundu Hm, direi che a me assomiglia molto a un possibile bersaglio duplicato, basta virare "lunghezza" alla fine o invece di "filtrare per somma equivale a" fare "somma ciascuno quindi contare" per dare una risposta a questo .

— Erik the Outgolfer,

2

@EriktheOutgolfer Non ero a conoscenza di quella sfida, ma la risposta a questa può essere sostanzialmente diversa, vedi la mia per esempio.

— orlp,

2

@ManishKundu Ho appena spiegato come questa sfida sia diversa ...

— orlp

2

Sì, l'ho visto. Anche se è un peccato che tu abbia accidentalmente martellato la tua stessa domanda, non dovresti essere costretto a esprimere un voto con cui non sei d'accordo.

— Dennis,

Risposte:

10

JavaScript (ES6), 35 byte

Salvato 1 byte grazie a @tsh

f=(n,s)=>n--?f(n,n-~s)+f(n,n+~s):!s

Provalo online!

— Arnauld
fonte

9

Wolfram Language (Mathematica) , 33 byte

Count[{1,-1}~Tuples~#.Range@#,0]&

Conta le n-tuple di 1 e -1 il cui punto con prodotto Range[n]è 0.

Provalo online!

— alephalpha
fonte

9

Haskell , 42 byte

f n=sum[1|0<-sum<$>mapM(\x->[x,-x])[1..n]]

Provalo online!

Questo è 2 1 byte più corto di qualsiasi funzione ricorsiva che potrei scrivere.

— H.PWiz
fonte

6

05AB1E , 10 byte

X®‚sã€ƶO_O

Provalo online!

Spiegazione

X®‚          # push [1,-1]
   sã        # cartesian product with input
     €ƶ      # multiply each element in each list with its 1-based index
       O     # sum each list
        _    # logical negation of each sum
         O   # sum

— Emigna
fonte

1

+1 per O_O...

— Esolanging Fruit

Il codice .. mi sta fissando. Cosa faccio?

— caird coinheringaahing

5

C (gcc), 45 62 52 50 byte

f(n,r){n=n?f(n-1,r+n)+f(n-1,r-n):!r;}F(n){f(n,0);}

La risposta Java 8 di Port of Kevin Cruijssen .

Provalo online qui .

Si noti che a causa dei miglioramenti suggeriti nei commenti, il codice produce un comportamento indefinito al punto da non funzionare quando compilato con clang.

Grazie a etene per il golf 3 byte. Grazie a Kevin Cruijssen per aver giocato a golf altri 10 byte. Grazie a Christoph per aver giocato a golf altri 2 byte.

Versione non golfata:

f(n, r) { // recursive function - return type and parameter type are omitted, they default to int
    n = // instead of returning, we set n - dirty trick
        n ? // if n is not 0, recurse
        f(n-1,r+n) // +n
       +f(n-1,r-n) // -n
        !r; // else if r != 0 return 0 else return 1
}
F(n) { // function to start the recursion; again implicitly int(int)
    n = f(n, 0); // call the recursive function; this time we simply don't return
}

— OOBalance
fonte

1

È possibile radere 3 byte sostituendo r?0:1con !r. 42 byte

— etene,

2

Sembra che tu stia prendendo ulteriori input qui per impostare il valore iniziale di r, che non è permesso.

— Shaggy

1

@etene Ben individuato, grazie!

— OOBalance,

2

@KevinCruijssen meglio ancora il secondo n=non è necessaria neanche: f(n,r){n=n?f(n-1,r+n)+f(n-1,r-n):!r;}F(n){f(n,0);}.

— Christoph,

2

@OOBalance il trucco è un complemento a due . Ciò significa che -x = ~x+1e quindi ~x = -x-1.

— Christoph,

5

05AB1E , 9 8 byte

Grazie a Emigna per aver salvato un byte!

Codice:

LæO·sLO¢

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

L           # Create the list [1, 2, .., input]
 æ          # Compute the powerset of this list
  O         # Sum each list
   ·        # Double each element
    sLO     # Compute the sum of [1, 2, .., input]
       ¢    # Count the number of occurrences

— Adnan
fonte

4

MATL , 14 13 byte

[la]Z^G:!Y*~s

Grazie a @Giuseppe per aver salvato 1 byte!

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera n = 3come esempio. Lo stack viene mostrato sottosopra, ovvero il più recente appare di seguito.

[la]   % Push array [1 -1]
       % STACK: [1 -1]
Z^     % Cartesian power with inplicit input n
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1]
G:     % Push n, range: gives [1 2 ... n]
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1  2  3]
!      % Transpose
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1
                  2
                  3]
Y*     % Matrix multiplication
       % STACK: [6
                 0
                 2
                -4
                 4
                -2
                 0
                -6]
~      % Logical negation
       % STACK: [0
                 1
                 0
                 0
                 0
                 0
                 1
                 0]
s      % Sum of vector. Implicit display
       % STACK: 2

— Luis Mendo
fonte

4

Gelatina , 8 byte

ŒPS€ċÆṁ$

Provalo online!

Come funziona

ŒPS€ċÆṁ$  Main link. Argument: n

ŒP        Take the powerset of [1, ..., n].
  S€      Take the sum of each subset.
       $  Combine the two links to the left into a monadic chain.
     Æṁ       Compute the median of the sums, i.e, (1 + ... + n)/2.
    ċ         Count the occurrences of the median.

— Dennis
fonte

3

Python 2, 74 byte

def f(n):l=k=1;exec"l+=l<<n*k;k+=1;"*n;return(l>>n*n*-~n/4)%2**n*(~-n%4>1)

Più di una presentazione divertente, calcolo della funzione di generazione diretta.

— orlp
fonte

3

Ottava (con pacchetto di comunicazioni), 39 byte

@(n)sum((2*de2bi(0:2^n-1)-1)*(1:n)'==0)

Provalo online!

Spiegazione:

Prendi un intervallo 0 ... n ^ 2-1 e convertilo in binario. Questo dà una matrice con tutte le combinazioni di 0 e 1 . Moltiplicare per 2 e sottrarre 1 per ottenere una matrice con tutte le combinazioni di -1 e +1 .

Prendi il punto-prodotto con un intervallo 1 ... n per ottenere tutte le combinazioni di ± 1 ± 2 ... ± n . Conta quanti sono zero.

Fondamentalmente la stessa cosa, lo stesso numero di byte:

@(n)nnz(~((2*de2bi(0:2^n-1)-1)*(1:n)'))

— Stewie Griffin
fonte

3

APL (Dyalog) , 31 22 byte

9 byte salvati grazie a @ H.PWiz

1⊥0=⊂∘⍳+.×¨∘,3-2×∘⍳⍴∘2

Provalo online!

— Uriel
fonte

3

Python 2 e 3, 50 byte

Approccio ricorsivo come la maggior parte delle risposte:

f=lambda n,r=0:f(n-1,r+n)+f(n-1,r-n)if n else r==0

La doppia chiamata ricorsiva richiede troppi byte ... Probabilmente c'è un modo per semplificarla.

— ETENE
fonte

3

Java 8, 72 71 70 byte

n->f(0,n)int f(int r,int n){return n>0?f(r+n,--n)+f(r+~n,n):r==0?1:0;}

Porta della risposta JavaScript (ES6) di @Arnauld .
-2 byte grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

n->                 // Method with integer parameter and integer return-type
  f(0,n)            //  Call the recursive method with 0 and this parameter

int f(int r,int n){ // Recursive method with integer as both two parameters and return-type
  return n>0?       //  If `n` is not 0 yet:
    f(r+n,--n)      //   Recursive call with `r+n` (and `n` lowered by 1 first with `--n`)
    +f(r+~n,n)      //   + Recursive call with `r-n` (and `n` also lowered by 1)
   :r==0?           //  Else-if `r` is 0
     1              //   Return 1
    :               //  Else:
     0;}            //   Return 0

— Kevin Cruijssen
fonte

3

Haskell , 55 byte

Un approccio semplice per calcolare tutte quelle somme e controllare quante sono zero.

f 0=[0]
f n=[(n+),(n-)]>>=(<$>f(n-1))
g x=sum[1|0<-f x]

Provalo online!

EDIT: @ H.PWiz ha una soluzione più breve e molto più elegante usando mapM!

— flawr
fonte

3

Utilità Bash + GNU, 63 byte

Probabilmente Bash può fare di meglio con funzioni ricorsive, ma non posso resistere a questo tipo di evalmostruosità / escape / espansione:

p=eval\ printf\ %s
$p\\\\n \$[$($p \\\{+,-}{1..$1})]|grep -c ^0

Provalo online!

Aggiornamento: non credo che bash possa fare di meglio con le funzioni ricorsive. Questo è il massimo che potrei fare per un punteggio di 90 . evaldiavolo lo è allora.

— Trauma digitale
fonte

3

Brachylog , 12 byte

⟦₁{{ṅ|}ᵐ+0}ᶜ

Provalo online!

Spiegazione

⟦₁               The range [1, …, Input]
  {       }ᶜ     Count the number of times the following predicate succeeds on that range:
   {  }ᵐ           Map for each element of the range:
    ṅ                Negate
     |               Or do nothing
        +0         The sum of the elements after the map is 0

— Fatalize
fonte

2

Ottava , 42 byte

@(n)sum((dec2bin(0:2^n-1)*2-97)*(1:n)'==0)

Provalo online!

— Luis Mendo
fonte

Bene, +1 immagino. :) Non l'avevo visto quando ho pubblicato il mio.

— Stewie Griffin,

Eh. Nemmeno io avevo mai visto i tuoi fino ad ora

— Luis Mendo il

2

J , 32 byte

1#.0=1#.1+i.*"1[:<:@+:@#:[:i.2^]

Provalo online!

C'è sicuramente molto spazio per il golf. Seguirà l'espansione.

— Galen Ivanov
fonte

2

Haskell , 41 byte

(%0)
n%k|n<1=0^k^2|m<-n-1=m%(k+n)+m%(k-n)

Provalo online!

— XNOR
fonte

Bello, ho avuto lo stesso, ma 0^abs k.

— H.Piz,

1

Gelatina , 10 byte

RżN$ŒpS€ċ0

Provalo online!

— Perdente Suora
fonte

1

Perl 5 , `-p`35 byte

#!/usr/bin/perl -p
$_=grep!eval,glob join"{+,-}",0..$_

Provalo online!

— Ton Hospel
fonte

1

Pari / GP , 30 byte

n->Pol(prod(i=1,n,x^i+x^-i))%x

Provalo online!

— alephalpha
fonte

1

Prolog (SWI) , 99 byte

p(0,0,1).
p(0,_,0).
p(X,Y,Z):-A is X-1,B is Y+X,p(A,B,C),D is Y-X,p(A,D,E),Z is C+E.
X*Y:-p(X,0,Y).

Provalo online!

— Emigna
fonte

1

Pyth, 14 13 byte

lf!s.nT*F_BRS

Spiegazione

lf!s.nT*F_BRS
            SQ  Take the list [1, ..., <implicit input>].
         _BR    Get the pairs [[1, -1], [2, -2], ...].
       *F       Take the Cartesian product.
 f!s.nT         Find the ones where the flattened sum is 0.
l               Take the length.

1

CJam , 25 byte

ri,:)_Wf*:a.+:m*:e_1fb0e=

Provalo online!

Questa è una traduzione abbastanza diretta della soluzione 05AB1E di @ emigna. È certamente golfabile.

— Esolanging Fruit
fonte

1

Stax , 9 byte

è%é┐╬@₧╠¬

Esegui ed esegui il debug

~~Una delle risposte più brevi finora~~ sconfitte da Jelly.

Sento che controllare esplicitamente quali segni somma a zero non è molto golfy, quindi prendo il powerset e controllo quanti set nel powerset hanno la somma della metà dell'ennesimo numero triangolare. Questo metodo non è, sorprendentemente, della stessa complessità temporale del controllo di quali segni si sommano a zero.

Equivalente ASCII:

RS{|+Hmx|+#

— Weijun Zhou
fonte

0

Pyth , 10 byte

/mysdySQsS

Provalo online.In alternativa, verificare tutti i casi di test contemporaneamente .

spiegazione:

/mysdySQsS    Implicit: Q=input()
      SQ      Generate range [1...Q]
     y        Generate powerset of above
 m            Map d in the above over...
  ysd         ... double the sum of d
        sS    Sum of range [1...Q] (final Q is implicit)
/             Count the matches (implicit output)

— Sok
fonte

0

J , 28 byte

(*>:){1j3#1+//.@(*/)/@,.=@i.

Utilizza l'altra definizione di OEIS dove a(n) = coefficient of x^(n(n+1)/4) in Product_{k=1..n} (1+x^k) if n = 0 or 3 mod 4 else a(n) = 0 .

Provalo online!

Spiegazione

(*>:){1j3#1+//.@(*/)/@,.=@i.  Input: n
                          i.  Range [0, n)
                        =     Self-Classify. Forms an identity matrix of order n
          1           ,.      Stitch. Prepend 1 to each row
                    /         Reduce using
                                Convolution
                 */               Product table
           +//.                   Sum along anti-diagonals
      1j3#                    Copy each once, padding with 3 zeroes after
     {                        Index at n*(n+1)
  >:                            Increment n
 *                              Times n

— miglia
fonte

0

Buccia , 9 byte

#½Σḣ¹mΣṖḣ

Provalo online!

Spiegazione

#½Σḣ¹mΣṖḣ  Implicit input
        ḣ  [1..input]
       Ṗ   Powerset
     mΣ    Sum each list
#          Count occurrence of
   ḣ¹        [1..input]
 ½Σ          Half of sum

— Fyr
fonte

0

Gol> <> , 26 byte

:IFPlMF2K+}:@-}||0lMF$z+|h

Provalo online! oppure Esegui i casi di test da 1 a 16!

Come funziona

:IFPlMF2K+}:@-}||0lMF$z+|h

Main outer loop
:IFPlMF ...... ||
:        Duplicate top; effectively generate two explicit zeroes
         Top is the loop counter `i`;
         the rest is the generated 2**i sums
 I       Take input as number
  F ........... |  Pop n and loop n times
   P     i++
    lM   Push stack length - 1, which is 2**(i-1)
      F ...... |   Loop 2**(i-1) times

Main inner loop: generate +i and -i from 2**(i-1) previous sums
2K+}:@-}
          Stack: [... x i]
2K        [... x i x i]    Copy top two
  +}      [x+i ... x i]    Add top two and move to the bottom
    :@    [x+i ... i i x]  Duplicate top and rotate top 3
      -}  [i-x x+i ... i]  Subtract and move to the bottom

Counting zeroes
0lMF$z+|h
0lM        Push zero (zero count) and 2**n (loop count)
   F...|   Loop 2**n times
    $z+    Swap top two; Take logical not; add to the count
        h  Print top as number and halt

— bubbler
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.