¿Se puede equilibrar esta lista?

23

Para verificar si una lista de enteros no negativos está equilibrada , uno puede imaginar poner los respectivos pesos en un tablero y luego tratar de equilibrar el tablero en un pivote de modo que los pesos relativos resumidos a la izquierda y a la derecha del pivote sean los mismos. El peso relativo se da multiplicando el peso con su distancia al pivote (vea la ley de la palanca ).

palanca de Wikipedia (Fuente: wikipedia )

Esta imagen corresponde a una lista [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Esta lista está equilibrada porque 5tiene una distancia de 20 al pivote, 100una distancia de 1 y 5*20 = 100 = 100*1.

Ejemplos

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

En este caso, el pivote está directamente debajo de 5, 3tiene la distancia 2 y el 1y 7tiene la distancia 1. Por lo tanto, ambos lados izquierdo y derecho del pivote se suman 7( 3*2 + 1*1a la izquierda y 7*1a la derecha) y, por lo tanto, la lista [3, 1, 5, 7]está equilibrada.

Sin embargo, tenga en cuenta que el pivote no tiene que colocarse debajo de uno de los elementos de la lista, sino que también puede ubicarse entre dos elementos de la lista:

 6 3 1
#######
  ^

En este caso las distancias se vuelven 0.5, 1.5, 2.5, ...y así sucesivamente. Esta lista también está equilibrada porque 6*0.5 = 3 = 3*0.5 + 1*1.5.

El pivote solo se puede colocar exactamente debajo de un número o exactamente en el medio entre dos números, y no, por ejemplo, en dos tercios entre dos números.

Tarea

Dada una lista de enteros no negativos en cualquier formato razonable, generar un truthyvalor si la lista se puede equilibrar y un falsyvalor de lo contrario.

Puede suponer que la lista de entrada contiene al menos dos elementos y que al menos un elemento no es cero.

Este es un desafío de , por lo que gana la respuesta con la menor cantidad de bytes en cada idioma.

Casos de prueba de la verdad

[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]

Falsy Testcases

[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]

Se encontraron muchos desafíos relacionados mientras este desafío estaba encerrado : ¿Es un número equilibrado? , Índice de equilibrio de una secuencia , Equilibrar un conjunto de pesas en un balancín , Equilibrar palabras , ¿Me volcaré? y ¿A dónde pertenece el pivote?

Laikoni
fuente
¿Se puede colocar el pivote antes del primer número o después del último número?
Erik the Outgolfer
@EriktheOutgolfer Si todos los pesos no son negativos, no.
Creo que esto podría ser un engaño. ¿O estuvo sentado en el Sandbox por un tiempo?
Shaggy
relacionados . (cc @ Shaggy Tal vez esto era lo que estabas pensando)
Sr. Xcoder
2
@Giuseppe @Steadybox agreguéYou can assume that the input list contains at least two elements and that at least one element is non-zero.
Laikoni

Respuestas:

7

Pyth, 12 10 bytes

!%ys*VQUQs

Pruébalo en línea

Ahorré 2 bytes gracias a Mr. Xcoder y Erik the Outgolfer.

Explicación

!%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.

fuente
Puede usar yen lugar de*2
Mr. Xcoder
10 bytes:!%ys*VQUQs
Erik the Outgolfer
4

Wolfram Language (Mathematica) , 36 bytes

IntegerQ[2#.Range[t=Tr[1^#]]/(t-1)]&

Este es un problema de centro de masa en un sistema de coordenadas con el origen en uno de los puntos y luego determina si el CM cae en un punto de red donde el ancho de red = 1/2.

Pruébalo en línea!

Kelly Lowder
fuente
4

05AB1E , 6 bytes

ƶO·IOÖ

Pruébalo en línea!

¿Cómo?

ƶO · IOÖ ~ Programa completo. I = entrada.

Lift ~ Elevación I. Multiplica cada elemento con su índice basado en 1.
 O ~ Sum.
  · ~ Doble. 
     Ö ~ ¿Es múltiplo de?
   IO ~ La suma de I.
Sr. Xcoder
fuente
Parece fallar [1,1](debería ser sincero). Parece que la duplicación implícita no está realmente allí.
Zgarb
@Zgarb Fixed (?)
Mr. Xcoder
2

Jalea , 6 bytes

×JSḤọS

Pruébalo en línea!

Bueno, parece que Leaky Nun señaló lo inútil.

Usando el enfoque Pyth de Mnemonic.

Devuelve un entero positivo (verdad) o cero (falso).

Erik el Outgolfer
fuente
¿Funcionaría esto ?
Leaky Nun
@LeakyNun No estoy tan seguro, por eso lo usé en su LḶlugar (aunque sería exitoso para todos los casos de prueba). EDITAR: Oooh, ahora que lo pienso de nuevo, parece que sí ... ( b | a ⇔ b | a + b duh)
Erik the Outgolfer
2

Japt , 10 bytes

í* x*2 vUx

Pruébalo en línea!

Explicación:

 í* 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

Vuelve 1por la verdad, 0por la falsedad.

Oliver
fuente
2

Python 2 , 41 bytes

S=s=0
for n in input():S-=s;s-=n
1>>2*S%s

La salida es a través del código de salida, por lo que 0 es verdadero y 1 es falso.

Pruébalo en línea!

Dennis
fuente
2

Ruby , 47 bytes

Guardado 2 bytes gracias al Sr. Xcoder

->k{(k.map.with_index{|x,i|x*i*2}.sum%k.sum)<1}

Pruébalo en línea!

Tom Lazar
fuente
1
Bienvenido a PPCG! Buena primera respuesta. 47 bytes
Sr. Xcoder
1

C,  140  137 bytes

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;}

Pruébalo en línea!

Steadybox
fuente
1

Perl 6 , 23 bytes

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

Pruébalo

Utiliza el algoritmo de varias otras entradas.

Expandido:

{  # 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
fuente
1

Japt, 11 10 8 bytes

Originalmente inspirado en la solución de Mnemonic

x* vUx*½

Intentalo

1 3 bytes guardados gracias a ETHproductions.


Explicación

Entrada implícita de la matriz U. Reduzca mediante la suma ( x), multiplicando cada elemento por su índice basado en 0 ( *) en el proceso. Verifique si el resultado es divisible ( v) por la suma de la entrada original ( Ux) con cada elemento multiplicado por 0.5 ( ).

Lanudo
fuente
Guardar un byte con m* x*2 vUx. Esto me hace preguntarme si m* x*2se puede reducir aún más ...
ETHproductions
Gracias, @ETHproductions; Ese es otro truco nuevo que he aprendido hoy.
Shaggy
Lo tengo, solo use x*y verifique si es divisible por Ux*½:)
ETHproductions
Sí, no creo que ese truco esté documentado en ninguna parte ... Pero cada vez que usa un operador binario como una función automática sin un segundo argumento, usa el índice por defecto (como si lo hiciera XY{X*Y})
ETHproductions
Oh, ahora, eso es simplemente ingenioso, @ETHproductions. :)
Shaggy
1

C # , 71 bytes


Golfed

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

Sin golf

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

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

    return 2 * S % s < 1;
};

Código 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();
        }
    }
}

Lanzamientos

  • v1.0 - 71 bytes- Solución inicial.

Notas

Podría tener, o podría no haberlo hecho, "tomar prestada" descaradamente la solución de Dennis Python 2 ...

auhmaan
fuente
0

Pitón 2 , 78 75 bytes

gracias al Sr. Xcoder por -3 bytes

lambda l:0in[sum(v*(i-y*2)for y,v in enumerate(l))for i in range(len(l)*2)]

Pruébalo en línea!

ovs
fuente
2
No hay necesidad de espacio 0 in. Además, no hay necesidad de que el 0en range(0,len(l)*2)..
Sr. Xcoder
0

PHP , 139 128 bytes

<?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);}?>

Pruébalo en línea!

Mic1780
fuente
1
A menos que entienden mal esta [ codegolf.meta.stackexchange.com/questions/2447/... usted debería ser capaz de utilizar die(1)y die(0)y guardar 4 bytes utilizando el código de salida en lugar de una cadena impresa.
manassehkatz-Reinstate Monica
@manassehkatz Si usa morir sin comillas en tio.run, lo tratará como un código de estado (que debería) y no lo colocará en la sección Salida. Así que acabo de agregar citas para evitar que las personas se
burlen