Cette liste peut-elle être équilibrée?

23

Pour vérifier si une liste d'entiers non négatifs est équilibrée , on peut imaginer mettre des poids respectifs sur une planche puis essayer d'équilibrer la planche sur un pivot de telle sorte que les poids relatifs résumés à gauche et à droite du pivot soient les mêmes. Le poids relatif est donné en multipliant le poids par sa distance au pivot (voir loi du levier ).

levier wikipedia (Source: wikipedia )

Cette image correspond à une liste [100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]. Cette liste est équilibrée car la 5distance de 20 au pivot, la 100distance de 1 et 5*20 = 100 = 100*1.

Exemples

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

Dans ce cas, le pivot est directement sous le 5, 3a la distance 2 et le 1et 7a la distance 1. Donc, les deux côtés gauche et droit du pivot se résument à 7( 3*2 + 1*1à gauche et 7*1à droite) et donc la liste [3, 1, 5, 7]est équilibrée.

Notez, cependant, que le pivot ne doit pas être placé sous l'un des éléments de la liste, mais peut également être placé entre deux éléments de la liste:

 6 3 1
#######
  ^

Dans ce cas, les distances deviennent 0.5, 1.5, 2.5, ...et ainsi de suite. Cette liste est également équilibrée car 6*0.5 = 3 = 3*0.5 + 1*1.5.

Le pivot ne peut être placé exactement en dessous d'un nombre ou exactement au milieu entre deux nombres, et non par exemple aux deux tiers entre deux nombres.

Tâche

Étant donné une liste d'entiers non négatifs dans n'importe quel format raisonnable, affichez une truthyvaleur si la liste peut être équilibrée et une falsyvaleur dans le cas contraire.

Vous pouvez supposer que la liste d'entrée contient au moins deux éléments et qu'au moins un élément est différent de zéro.

C'est un défi de code-golf , donc la réponse avec le moins d'octets dans chaque langue l'emporte.

Vrais tests

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

Valises de test de falsification

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

Beaucoup de défis connexes ont été trouvés alors que ce défi était en bac à sable : est-ce un nombre équilibré? , Index d'équilibre d'une séquence , Equilibrer un ensemble de poids sur une bascule , Mots d'équilibrage , Vais-je basculer? et où appartient le pivot?

code-golf  array-manipulation  decision-problem  physics 
— Laikoni
source
Le pivot peut-il être placé avant le premier numéro ou après le dernier numéro?
— Erik the Outgolfer
@EriktheOutgolfer Si tous les poids sont non négatifs, non.
Je pense que cela pourrait être une dupe. Ou était-il assis dans le bac à sable pendant un certain temps?
— Shaggy
liés . (cc @Shaggy Peut-être que c'était ce à quoi vous pensiez)
— M. Xcoder
2
@Giuseppe @Steadybox J'ai ajoutéYou can assume that the input list contains at least two elements and that at least one element is non-zero.
— Laikoni

Réponses:

7

Pyth, 12 10 octets

!%ys*VQUQs

Essayez-le en ligne

Enregistré 2 octets grâce à M. Xcoder et Erik l'Outgolfer.

Explication

!%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.
Vous pouvez utiliser yà la place de*2
— M. Xcoder
10 octets:!%ys*VQUQs
— Erik the Outgolfer
4

05AB1E , 6 octets

ƶO·IOÖ

Essayez-le en ligne!

Comment?

ƶO · IOÖ ~ Programme complet. I = entrée.

ƶ ~ Soulevez I. Multipliez chaque élément avec son index basé sur 1.
 O ~ Sum.
  · ~ Double. 
     Ö ~ Est-ce qu'un multiple de?
   IO ~ La somme de I.
— M. Xcoder
source
Semble échouer [1,1](devrait être véridique). Il semble que le doublement implicite ne soit pas réellement là.
— Zgarb
@Zgarb Fixed (?)
— M. Xcoder
2

Gelée , 6 octets

×JSḤọS

Essayez-le en ligne!

Eh bien, on dirait que Leaky Nun a souligné l'inutile.

Utilisation de l'approche Pyth de Mnemonic.

Renvoie un entier positif (véridique) ou zéro (falsifié).

— Erik le Outgolfer
source
Est- ce que cela fonctionnerait?
— Leaky Nun
@LeakyNun Pas si sûr, c'est pourquoi je LḶplace (bien qu'il serait réussir dans tous les cas de test). EDIT: Oooh, maintenant que j'y repense, il semble que oui ... ( b | a ⇔ b | a + b duh)
— Erik the Outgolfer
2

Japt , 10 octets

í* x*2 vUx

Essayez-le en ligne!

Explication:

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

Retourne 1pour la vérité, 0pour la fausse.

— Oliver
source
1

C,  140  137 octets

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

Essayez-le en ligne!

— Steadybox
source
1

Perl 6 , 23 octets

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

Essaye-le

Utilise l'algorithme de diverses autres entrées.

Étendu:

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

Japt, 11 10 8 octets

Inspiré à l'origine par la solution de Mnemonic

x* vUx*½

Essayez-le

1 3 octets économisés grâce à ETHproductions.

Explication

Entrée implicite du tableau U. Réduisez par addition ( x), multipliant chaque élément par son index de base 0 ( *) dans le processus. Vérifiez si le résultat est divisible de façon égale ( v) par la somme de l'entrée d'origine ( Ux), chaque élément étant multiplié par 0,5 ( *½).

— Hirsute
source
Enregistrez un octet avec m* x*2 vUx. Cela me fait me demander si l' m* x*2on peut réduire davantage ...
— ETHproductions
Merci, @ETHproductions; c'est un autre nouveau truc que j'ai appris aujourd'hui.
— Shaggy
Je l'ai, utilisez-le x*et vérifiez s'il est divisible par Ux*½:)
— ETHproductions
Oui, je ne pense pas que cette astuce soit documentée n'importe où ... Mais chaque fois que vous utilisez un opérateur binaire comme fonction automatique sans deuxième argument, il utilise l'index par défaut (comme si vous l'avez fait XY{X*Y})
— ETHproductions
Oh, maintenant, c'est juste ingénieux, @ETHproductions. :)
— Shaggy
1

C # , 71 octets

Golfé

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

Non golfé

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

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

    return 2 * S % s < 1;
};

Code complet

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

Communiqués

  • v1.0 - 71 bytes- Solution initiale.

Remarques

Je pourrais avoir, ou ne pas avoir, manifestement "emprunté" la solution Dennis Python 2 ...

— auhmaan
source
0

PHP , 139 128 octets

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

Essayez-le en ligne!

— Mic1780
source
1
À moins que je ne comprenne mal ce [ codegolf.meta.stackexchange.com/questions/2447/…, vous devriez pouvoir utiliser die(1)et die(0)enregistrer 4 octets en utilisant le code de sortie au lieu d'une chaîne imprimée.
— manassehkatz-Reinstate Monica
@manassehkatz Si vous utilisez die sans guillemets sur tio.run, il le traitera comme un code d'état (ce qu'il devrait) et ne le placera pas dans la section Sortie. J'ai donc juste ajouté des citations pour empêcher les gens de
— taquiner
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.