Questo elenco può essere bilanciato?

23

Per verificare se un elenco di numeri interi non negativi è bilanciato , si può immaginare di mettere i rispettivi pesi su una tavola e quindi provare a bilanciare la tavola su un perno in modo tale che i pesi relativi riepilogati a sinistra e a destra del perno siano gli stessi. Il peso relativo viene dato moltiplicando il peso per la sua distanza dal perno (vedere la legge della leva ).

leva di Wikipedia (Fonte: Wikipedia )

Questa immagine corrisponde a un elenco [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Questo elenco è bilanciato perché 5ha una distanza di 20 dal perno, 100una distanza di 1 e 5*20 = 100 = 100*1.

Esempi

 3 1 5 7
#########
     ^

In questo caso il perno si trova direttamente sotto il 5, il 3ha distanza 2 e il 1e 7hanno distanza 1. Quindi entrambi i lati sinistro e destro del perno si sommano a 7( 3*2 + 1*1a sinistra ea 7*1destra) e quindi l'elenco [3, 1, 5, 7]è bilanciato.

Si noti, tuttavia, che il pivot non deve essere posizionato sotto uno degli elementi dell'elenco, ma potrebbe anche essere posizionato tra due elementi dell'elenco:

 6 3 1
#######
  ^

In questo caso le distanze diventano 0.5, 1.5, 2.5, ...e così via. Questo elenco è anche bilanciato perché 6*0.5 = 3 = 3*0.5 + 1*1.5.

Il perno può essere posizionato esattamente esattamente al di sotto di un numero o esattamente al centro tra due numeri e non ad esempio a due terzi tra due numeri.

Compito

Dato un elenco di numeri interi non negativi in ​​qualsiasi formato ragionevole, genera un truthyvalore se l'elenco può essere bilanciato e un falsyvalore in caso contrario.

Si può presumere che l'elenco di input contenga almeno due elementi e che almeno un elemento sia diverso da zero.

Questa è una sfida di code-golf , quindi vince la risposta con il minor numero di byte in ogni lingua.

Verità Testcases

[1, 0]
[3, 1, 5, 7]
[6, 3, 1]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]
[10, 4, 3, 0, 2, 0, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[7, 7, 7, 7]

Testals Falsy

[1, 2]
[3, 6, 5, 1, 12]
[0, 0, 2, 0, 1, 0]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[6, 3, 2, 4, 0, 1, 2, 3]
[4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]

Molte sfide correlate sono state trovate mentre questa sfida è stata inscatolata : è un numero equilibrato? , Indice di equilibrio di una sequenza , equilibrio una serie di pesi su un'altalena , Bilanciamento parole , Will ho ribaltarsi? e dove appartiene il perno?

code-golf  array-manipulation  decision-problem  physics 
— Laikoni
fonte
Il perno può essere posizionato prima del primo numero o dopo l'ultimo numero?
— Erik the Outgolfer,
@EriktheOutgolfer Se tutti i pesi non sono negativi, no.
Penso che questo potrebbe essere un imbecille. O è stato seduto nella Sandbox per un po '?
— Shaggy,
correlati . (cc @Shaggy Forse questo era quello a cui stavi pensando)
— Mr. Xcoder il
2
@Giuseppe @Steadybox Ho aggiuntoYou can assume that the input list contains at least two elements and that at least one element is non-zero.
— Laikoni il

Risposte:

7

Pyth, 12 10 byte

!%ys*VQUQs

Provalo online

Salvato 2 byte grazie a Mr. Xcoder e Erik the Outgolfer.

Spiegazione

!%ys*VQUQs
    *VQUQ    Multiply each input by its index.
  ys         Take twice the sum (to handle half-integer positions).
!%       sQ  Check if that's a multiple of the total weight.
Puoi usare yal posto di*2
— Mr. Xcoder il
10 byte:!%ys*VQUQs
— Erik the Outgolfer,
4

05AB1E , 6 byte

ƶO·IOÖ

Provalo online!

Come?

ƶO · IOÖ ~ Programma completo. I = input.

Lift ~ Lift I. Moltiplica ogni elemento con il suo indice basato su 1.
 O ~ Sum.
  · ~ Doppio. 
     Ö ~ È un multiplo di?
   IO ~ La somma di I.
— Mr. Xcoder
fonte
Sembra fallire [1,1](dovrebbe essere vero). Sembra che il raddoppio implicito non sia effettivamente lì.
— Zgarb,
@Zgarb Risolto (?)
— Mr. Xcoder il
2

Gelatina , 6 byte

×JSḤọS

Provalo online!

Beh, sembra Leaky Nun sottolineato l'inutile.

Utilizzando l'approccio Pyth di Mnemonic.

Restituisce un numero intero positivo (verità) o zero (falsa).

— Erik the Outgolfer
fonte
Sarebbe questo lavoro?
— Leaky Nun,
@LeakyNun Non sono così sicuro, è per questo che l'ho usato LḶinvece (anche se sarebbe riuscito per tutti i casi di test). EDIT: Oooh, ora che ci ripenso, sembra così ... ( b | a ⇔ b | a + b duh)
— Erik the Outgolfer
2

Japt , 10 byte

í* x*2 vUx

Provalo online!

Spiegazione:

 í* x*2 vUx
U            // Implicit Input                 [3, 1, 5, 7]
 í           // Pair the input with its index  [[3,0],[1,1],[5,2],[7,3]]
  *          // Multiply each item             [0,1,10,21]
    x        // Sum                            32
     *2      // Double                         64
        v    // Divisible by:
         Ux  //   Sum of Input                 16
             // Explicit Output                1

Ritorna 1per la verità, 0per la falsità.

— Oliver
fonte
1

C,  140  137 byte

float l,r;i,j,t;f(L,n)int*L;{for(i=t=-1;++i<2*n;t*=l-r)for(l=r=j=0;j<n;++j)l+=j<i/2.?L[j]*(i/2.-j):0,r+=j>i/2.?L[j]*(j-i/2.):0;return!t;}

Provalo online!

— Steadybox
fonte
1

Perl 6 , 23 byte

{sum(1..*Z*$_)*2%%.sum}

Provalo

Utilizza l'algoritmo da varie altre voci.

Allargato:

{  # bare block lambda with implicit parameter ｢$_｣

    sum(

        1 .. *  # Range starting from 1

      Z*        # Zip using &infix:«*»

        $_      # the input

    ) * 2

  %%            # is divisible by

    .sum        # the sum of the input (implicit method call on ｢$_｣)
}
— Brad Gilbert b2gills
fonte
1

Japt, 11 10 8 byte

Originariamente ispirato alla soluzione di Mnemonic

x* vUx*½

Provalo

1 3 byte salvati grazie a ETHproductions.

Spiegazione

Input implicito di array U. Riduci per addizione ( x), moltiplicando ciascun elemento per il suo indice basato su 0 ( *) nel processo. Controlla se il risultato è uniformemente divisibile ( v) per la somma dell'input originale ( Ux) con ogni elemento moltiplicato per 0,5 ( *½).

— ispido
fonte
Salva un byte con m* x*2 vUx. Questo mi fa chiedere se m* x*2può essere ulteriormente ridotto ...
— ETHproductions
Grazie, @ETHproductions; questo è un altro nuovo trucco che ho imparato oggi.
— Shaggy,
Ho capito, basta usare x*e controllare se è divisibile per Ux*½:)
— ETHproductions il
Sì, non credo che il trucco sia documentato ovunque ... Ma ogni volta che usi un operatore binario come funzione automatica senza nessun secondo argomento, usa l'indice di default (come se lo facessi XY{X*Y})
— ETHproductions
Oh, ora, è geniale, @ETHproductions. :)
— Shaggy,
1

C # , 71 byte

golfed

a=>{int i,s,S=s=i=0;while(i<a.Length){S-=s;s-=a[i++];}return 2*S%s<1;};

Ungolfed

a => {
    int
        i, s, S = s = i = 0;

    while( i < a.Length ) {
        S -= s;
        s -= a[ i++ ];
    }

    return 2 * S % s < 1;
};

Codice completo

using System;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            Func<Int32[], Boolean> f = a => {
                int
                    i, s, S = s = i = 0;

                while( i < a.Length ) {
                    S -= s;
                    s -= a[ i++ ];
                }

                return 2 * S % s < 1;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new Int32[] {1, 0},
                    new Int32[] {3, 1, 5, 7},
                    new Int32[] {6, 3, 1},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                    new Int32[] {10, 4, 3, 0, 2, 0, 5},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
                    new Int32[] {7, 7, 7, 7},

                    new Int32[] {1, 2},
                    new Int32[] {3, 6, 5, 1, 12},
                    new Int32[] {0, 0, 2, 0, 1, 0},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9},
                    new Int32[] {6, 3, 2, 4, 0, 1, 2, 3},
                    new Int32[] {4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( $"{{ {String.Join(", ", testCase)} }}\n{f( testCase )}" );
            }

            Console.ReadLine();
        }
    }
}

Uscite

  • v1.0 - 71 bytes- Soluzione iniziale.

Gli appunti

Avrei potuto o meno "palesemente" preso in prestito la soluzione di Dennis Python 2 ...

— auhmaan
fonte
0

PHP , 139 128 byte

<?php $a=explode(',',fgets(STDIN));for($i=0;$i<count($a)-.5;$i+=.5){$z=0;foreach($a as $k=>$v)$z+=($k-$i)*$v;if($z==0)die(1);}?>

Provalo online!

— Mic1780
fonte
1
A meno che non mi fraintendere questo [ codegolf.meta.stackexchange.com/questions/2447/... si dovrebbe essere in grado di utilizzare die(1)e die(0)e salvare 4 byte utilizzando il codice di uscita invece di una stringa stampata.
— manassehkatz-Reinstate Monica,
@manassehkatz Se usi die senza virgolette su tio.run, lo tratterà come un codice di stato (che dovrebbe) e non lo inserirà nella sezione Output. Quindi ho appena aggiunto delle citazioni per impedire alle persone di fare il
— pignolo
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.