Ce défi a été publié sur le sous-programme DailyProgrammer, et j’ai pensé que ce serait un excellent candidat pour un défi de golf. Déterminer si une lettre est en équilibre est basé sur sa distance par rapport au point d'équilibre et la valeur de la lettre. La valeur d'une lettre peut être déterminée en prenant sa position indexée dans l'alphabet ou en soustrayant 64 de sa valeur ASCII. De plus, la valeur d'une lettre est multipliée par sa distance au point de la balance. Regardons un exemple STEAD:

STEAD   -> 19, 20, 5, 1, 4 ASCII values
           This balances at T, and I'll show you why!
S T EAD -> 1*19 = 1*5 + 2*1 + 3*4
           Each set of letters on either side sums to the same value, so
           T is the anchor.

Cependant, il convient de noter que tous les mots ne sont pas en équilibre. Par exemple, le mot WRONGne s'équilibre dans aucune configuration. De plus, les mots doivent être en équilibre sur une lettre et non entre deux lettres. Par exemple, SAASéquilibrerait s’il y avait une lettre au milieu des deux lettres A, mais comme il n’y en a pas, il n’y a pas d’équilibre.

La tâche

Vous devez créer un programme ou une fonction qui prend un mot majuscule en tant qu'argument d'entrée ou argument de fonction , puis génère l'un des deux résultats suivants:

1. Si le mot est équilibré, alors le mot doit être imprimé avec le côté gauche, un espace, la lettre d'ancrage, un autre espace et le côté droit.

   function (STEAD) -> S T EAD

2. Si le mot n’équilibre pas, vous devez l’imprimer, suivi de DOES NOT BALANCE

   function (WRONG) -> WRONG DOES NOT BALANCE

Vous pouvez supposer que toutes les entrées seront majuscules et qu'il n'y aura que des caractères alphabétiques.

Exemple I / O

function (CONSUBSTANTIATION) -> CONSUBST A NTIATION
function (WRONGHEADED)       -> WRO N GHEADED
function (UNINTELLIGIBILITY) -> UNINTELL I GIBILITY
function (SUPERGLUE)         -> SUPERGLUE DOES NOT BALANCE

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

Pyth, 49 octets

jd.xcz,Jhf!s*Vm-Cd64zr_TlzUzhJ,z"DOES NOT BALANCE

Manifestation.

Explication:

jd.xcz,Jhf!s*Vm-Cd64zr_TlzUzhJ,z"DOES NOT BALANCE

                                    Implicit: z = input(), d = ' '
         f                Uz        Filter T over range(len(z)).
              m     z               Map the characters in z to
               -Cd64                their ASCII values - 64.
            *V                      Vectorized multiplication by
                     r_Tlz          range(-T, len(z)).
                                    This is equivalent to putting the fulcrum at T.
           s                        Sum the weights.
          !                         Logical not - filter on sum = 0.
        h                           Take the first result.
                                    This throws an error if there were no results.
       J                            Save it to J.
      ,J                    hJ      Form the list [J, J+1].
    cz                              Chop z at those indices, 
                                    before and after the fulcrum.
  .x                                If no error was thrown, return the above.
                              ,z".. If an error was thrown, return [z, "DOES N..."]
jd                                  Join the result on spaces and print.

Pure bash (pas de coreutils ou d’autres utilitaires), 125

Calcul standard du centre de masse en utilisant des moments relatifs à l'origine:

for((;i<${#1};w=36#${1:i:1}-9,m+=w,M+=w*++i)){ :;}
((M%m))&&echo $1 DOES NOT BALANCE||echo ${1:0:M/m-1} ${1:M/m-1:1} ${1:M/m}

Test de sortie:

$ for t in \
> STEAD \
> CONSUBSTANTIATION \
> WRONGHEADED \
> UNINTELLIGIBILITY \
> SUPERGLUE
> do ./wordbal.sh $t; done
S T EAD
CONSUBST A NTIATION
WRO N GHEADED
UNINTELL I GIBILITY
SUPERGLUE DOES NOT BALANCE
$ 

Python 3, 124

w=input()
i=a=b=0
for c in w:n=ord(c)-64;a+=n;b+=n*i;i+=1
m=b//a
print(*[w[:m],w,w[m],"DOES NOT BALANCE",w[m+1:]][b%a>0::2])

Ce code ne teste pas les points d'appui potentiels, mais trouve plutôt le "centre de gravité" et vérifie s'il s'agit d'un entier. Pour ce faire, il fait la somme de la masse totale aet de la masse pondérée en fonction de la position bafin de déterminer le centre de masse m=b/a. Il imprime ensuite soit la chaîne fractionnée à la position m, soit la chaîne plus "DOES NOT BALANCE", choisie par le [_::2]trucage liste-tranchage.

CJam, 57 octets

l_,,_f{f-W$'@fm.*:+}0#:I){ISIW$=S++t}" DOES NOT BALANCE"?

Cela peut encore être joué au golf un peu.

Essayez-le en ligne ici

JavaScript (ES6), 211 200 160 octets

f=w=>{for(j=-w.length;j++;)if(![...w].reduce((p,v,i)=>p+(parseInt(v,36)-9)*(j+i),0))return w.slice(0,-j)+` ${w[-j]} `+w.slice(1-j);return w+` DOES NOT BALANCE`}

Tentative précédente, 200 octets

Merci à edc56 et nderscore de m’avoir aidé à jouer au golf cette

f=w=>{for(j=0,r=(a,z)=>[...a][z||`reverse`]().reduce((p,v,i)=>p+(parseInt(v,36)-9)*++i,0);j++<w.length;)if(r(a=w[s=`slice`](0,j))==r(b=w[s](j+1),s))return a+` ${w[j]} `+b;return w+` DOES NOT BALANCE`}

Démo

Firefox et Edge uniquement pour l'instant, car il s'agit de l'ES6

f=w=>{for(j=1-w.length;j++;)if(!([...w].reduce((p,v,i)=>p+(parseInt(v,36)-9)*(j+i),0)))return w.slice(0,-j)+` ${w[-j]} `+w.slice(1-j);return w+` DOES NOT BALANCE`}

// DEMO
console.log = function(a) {
  document.body.innerHTML += a + "<br>";
}

console.log(f('STEAD'));
console.log(f('CONSUBSTANTIATION'));
console.log(f('WRONGHEADED'));
console.log(f('UNINTELLIGIBILITY'));
console.log(f('SUPERGLUE'));

C, 236 198 192 188 180 180 173 octets

a,i,j,k,L;f(char*s){L=strlen(s);for(;i<L;i++){for(a=j=0;j<L;j++)a+=(s[j]-64)*(i-j);if(!a)break;}for(;k<L;k++)printf(k-i?"%c":" %c ",s[k]);if(a)printf(" DOES NOT BALANCE");}

Développé avec main ():

#define p printf    
a,i,j,k,L;
f(char*s)
{
    L=strlen(s);
    for(;i<L;i++){
        for(a=j=0;j<L;j++)
            a+=(s[j]-64)*(i-j);
        if(!a)
            break;
    }
    for(;k<L;k++)
        printf(k-i?"%c":" %c ",s[k]);
    if(a)
        printf(" DOES NOT BALANCE");
}
// 83 bytes below
int main(int argc, char **argv)
{
    f(argv[1]);
    printf("\n");
}

Vérification:

$ ./a.out CONSUBSTANTIATION
CONSUBST A NTIATION
$ ./a.out WRONGHEADED
WRO N GHEADED
$ ./a.out A
 A 
$ ./a.out WRONG
WRONG DOES NOT BALANCE
$ ./a.out SUPERGLUE
SUPERGLUE DOES NOT BALANCE

CJam, 50 octets

r_'@f-_ee::*:+\:+md"X DOES NOT BALANCEX"@?)/()@]S*

A l'aide de l'interpréteur Java, cela aboutit avec une erreur à STDERR pour les mots non équilibrés.

Si vous essayez le code dans l' interpréteur CJam , ignorez tout, sauf la dernière ligne de sortie.

Idée

Mon «idée originale» s’est avérée être la même approche que @xnor a publiée plusieurs heures avant moi. Néanmoins, ça y est:

Étant donné une liste de valeurs (v ₀ ,… v _n ) , nous avons que v_t est l'ancre de la liste si et seulement si l'une des conditions suivantes est remplie, les conditions équivalentes étant remplies:

• tv ₀ +… + 1v _t-1 == 1v _{t + 1} +… tv _n

• (0 - t) v ₀ +… + (n - t) v _n == 0

• 0v ₀ +… + nv _n == t (v ₀ +… + v _n )

• t: = (0v ₀ +… + nv _n ) / (v ₀ +… + v _n ) est un entier.

Code

r     e# Read a whitespace separated token from STDIN.
_'@f- e# Push a copy and subtract '@' from each char (pushes code point - 64). 
_ee   e# Push a copy of the array of values and enumerate them.
::*   e# Multiply each value by its index.
:+    e# Add all results.
\:+   e# Add the unmodified values.
md    e# Perform modular division. Pushes quotient and residue.

"X DOES NOT BALANCEX"

@     e# Rotate the quotient on top of the string.
?     e# If the residue is 0, select the quotient. Otherwise, select the string.

Dans cette partie, nous commençons à nous amuser un peu avec des opérateurs surchargés.

Pour le quotient, cela se produit:

)     e# Add 1 to the quotient.
/     e# Split the input string into chunks of that length.
(     e# Shift out the first chunk.
)     e# Pop the last character of the first chunk.
@     e# Rotate the rest of the string on top of the stack.
]S*   e# Wrap all three parts in an array and join them, separating by spaces.

Pour la chaîne, cela se produit:

)     e# Pop out the last char: "X DOES NOT BALANCE" 'X'
/     e# Split the remainder at X's: ["" " DOES NOT BALANCE"]
(     e# Shift out the first chunk: [" DOES NOT BALANCE"] ""
)     e# Pop out the last char.

À ce stade, une erreur d'exécution se produit car elle ""n'a pas de dernier caractère. La pile est imprimée et l'exécution est immédiatement abandonnée.

Julia, 122 octets

s->(v=[int(i)-64for i=s];m=dot(v,1:length(s))/sum(v);m==int(m)?join([s[1:m-1],s[m],s[m+1:end]]," "):s*" DOES NOT BALANCE")

Cela crée une fonction non nommée qui accepte une chaîne en entrée et retourne une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

Nous traitons le mot comme un système unidimensionnel pour lequel nous devons trouver le centre de gravité. Le centre de masse est calculé comme le produit scalaire des masses avec leur emplacement, divisé par la masse totale du système. Si le centre calculé est un entier, il correspond à l'une des lettres du mot. Sinon, le mot ne s'équilibre pas.

Ungolfed + explication:

function f(s)
    # Create a vector of ASCII code points -- these are the "masses"
    v = [int(i)-64 for i in s]

    # Compute the center of mass, taking the locations to be the indices
    m = dot(v, 1:length(s)) / sum(v)

    # Check whether the center corresponds to a letter's position
    if m == int(m)
        join([s[1:m-1], s[m], s[m+1:end]], " ")
    else
        m * " DOES NOT BALANCE"
    end
end

Exemples:

julia> f("WRONG")
"WRONG DOES NOT BALANCE"

julia> f("STEAD")
"S T EAD"

julia> f("CONSUBSTANTIATION")
"CONSUBST A NTIATION"

PHP, 249 174 octets

Prend un argument de ligne de commande.

<?for($i=-$l=strlen($w=$argv[1]);$i++;){for($k=$q=0;$l>$k;)$q+=($i+$k)*(ord($w[$k++])-64);$q?:exit(substr($w,0,-$i)." {$w[-$i]} ".substr($w,1-$i));}echo"$w DOES NOT BALANCE";

Tentative initiale:

<?function r($a){for($i=$q=0;strlen($a)>$i;){$q+=(ord($a[$i])-64)*++$i;}return$q;}for($i=0;$i++<strlen($w=$argv[1]);)(strlen($w)<2?exit($w):(r(strrev($a=substr($w,0,$i)))==r($b=substr($w,$i+1)))?exit("$a {$w[$i++]} $b"):0);echo"$w DOES NOT BALANCE";

Haskell, 161 135 octets

a#b=a*(fromEnum b-64)
v=sum.zipWith(#)[1..]
h![]=h++" DOES NOT BALANCE"
h!(x:y)|v(reverse h)==v y=h++' ':x:' ':y|1<2=(h++[x])!y
f=([]!)

Exemple d'utilisation:

*Main> putStr $ unlines $ map f ["CONSUBSTANTIATION","WRONGHEADED","UNINTELLIGIBILITY","SUPERGLUE"]
CONSUBST A NTIATION
WRO N GHEADED
UNINTELL I GIBILITY
SUPERGLUE DOES NOT BALANCE

Comment ça marche: fappelle la fonction d'assistance !qui prend deux paramètres, la partie gauche et droite du mot à une position donnée. Il s’arrête si les deux parties ont le même poids (fonction v) ou s’appelle de manière récursive avec la première lettre de la partie droite déplacée vers la gauche. Il se termine par le DOES NOT BALANCEmessage si la partie droite est vide.

C, 183 134 octets

h,i,a=1;c(char*s){for(;s[i++]&&a;)for(a=h=0;s[h];)a+=(s[h]-64)*(h++-i);printf(a?"%.*s DOES NOT BALANCE":"%.*s %c %s",i,s,s[--i],s+i);}

Nouvelle version expliquée:

Comme les deux autres entrées, il utilise l’addition constante d’un côté et la soustraction de l’autre pour atteindre, espérons-le, la valeur zéro, ce qui est l’indication de l’équilibre. Ma sortie originale est réutilisée de la première réponse, bien que légèrement modifiée.

l,h,i,a,b;c(char*s){for(l=strlen(s);h++<l&&(a^b|!a);)for(i=a=b=0;i<l;i++)i==h?a=b,b=0:(b+=(s[i]-64)*abs(i-h));printf(a==b?"%.*s %c %s":"%.*s DOES NOT BALANCE",a==b?h:l,s,s[--h],s+h);}

Ancienne version expliquée:

La première boucle (h) est l'itérateur principal de la longueur de la chaîne. La deuxième boucle (i) s'accumule (b) jusqu'à ce que h == i. Une fois que cela se produit, (b) est stocké dans (a), remis à 0, puis continue jusqu'à la fin de la chaîne, où (a) est comparé à (b). S'il y a une correspondance, la boucle de l'itérateur principal est cassée et la sortie est imprimée.

Ruby 175

F=->s{v=->s{(0...s.size).map{|i|(i+1)*(s[i].ord-64)}.inject :+}
r="#{s} DOES NOT BALANCE"
(0...s.size).map{|i|b,a=s[0...i],s[i+1..-1]
v[b.reverse]==v[a]&&r=b+" #{s[i]} "+a}
r}

Testez-le en ligne: http://ideone.com/G403Fv

Ceci est une implémentation assez simple de Ruby. Voici le programme lisible:

F=-> word {
  string_value = -> str {
    (0...str.size).map{|i|(i+1) * (str[i].ord - 64)}.inject :+
  }

  result = "#{word} DOES NOT BALANCE"

  (0...word.size).map {|i|
    prefix, suffix = word[0...i], word[i+1..-1]
    if string_value[prefix.reverse] == string_value[suffix]
      result = prefix + " #{word[i]} " + suffix
    end
  }

  result
}

R, 190 octets

En tant que fonction non nommée. Je pense pouvoir en obtenir un peu plus, mais cela devra attendre.

function(A){D=colSums(B<-(as.integer(charToRaw(A))-64)*outer(1:(C=nchar(A)),1:C,'-'));if(!length(E<-which(B[,D==0]==0)))cat(A,'DOES NOT BALANCE')else cat(substring(A,c(1,E,E+1),c(E-1,E,C)))}

Ungolfed un peu avec une brève explication

function(A){
D=colSums(  #column sums of the outer function * character values
    B<-(
       as.integer(charToRaw(A))-64)    # character values
       * outer(1:(C=nchar(A)),1:C,'-') # matrix of ranges eg -3:2, -1:4, etc
       )
if(!length(
    E<-which(B[,D==0]==0) # where the colsum = 0, get the index of the zero
    ))
    cat(A,'DOES NOT BALANCE')
else 
    cat(substring(A,c(1,E,E+1),c(E-1,E,C)))  #cat the substrings
}

Cela ne met pas une nouvelle ligne à la fin.

Essai

> f=
+ function(A){D=colSums(B<-(as.integer(charToRaw(A))-64)*outer(1:(C=nchar(A)),1:C,'-'));if(!length(E<-which(B[,D==0]==0)))cat(A,'DOES NOT BALANCE')else cat(substring(A,c(1,E,E+1),c(E-1,E,C)))}
> 
> f('CONSUBSTANTIATION')
CONSUBST A NTIATION
> f('WRONGHEADED')
WRO N GHEADED
> f('UNINTELLIGIBILITY')
UNINTELL I GIBILITY
> f('SUPERGLUE')
SUPERGLUE DOES NOT BALANCE
> 

C, 142 octets

Crédit à un utilisateur de m'avoir battu :)

i,l=1,j;g(char*v){for(;v[i]&&l;++i)for(j=l=0;v[j];++j)l+=(i-j)*(v[j]-64);printf(l?"%.*s DOES NOT BALANCE":"%.*s %c %s",l?i:--i,v,v[i],v+i+1);}

Java, 240 octets

String b(String s){for(int i=-1,a=s.length(),l=0,r,m;++i<a;){for(r=i;--r>=0;l+=(s.charAt(r)-64));for(m=r=0;++m+i<a;r+=(s.charAt(m+i)-64)*m);if(l==r)return s.substring(0,i)+" "+s.charAt(i)+" "+s.substring(i+1);}return s+" DOES NOT BALANCE";}