이 도전 과제는 DailyProgrammer subreddit에 게시되었으며 코드 골프 도전에 대한 훌륭한 후보가 될 것이라고 생각했습니다. 문자 균형을 결정하는 것은 균형점으로부터의 거리와 문자 값을 기반으로합니다. 문자의 값은 알파벳에서 하나의 색인 위치를 취하거나 ASCII 값에서 64를 빼서 결정할 수 있습니다. 또한 문자의 값에 균형점으로부터의 거리가 곱해집니다. 예를 살펴 보겠습니다 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.

그러나 모든 단어가 균형을 이루는 것은 아닙니다. 예를 들어, 구성에서 단어의 WRONG균형이 맞지 않습니다. 또한 단어는 두 글자가 아닌 글자의 균형을 유지해야합니다. 예를 들어, SAAS두 글자 가운데에 글자가 있으면 균형을 잡을 수 A있지만 균형이 맞지 않습니다.

작업

대문자 또는 단어 를 입력 또는 함수 인수 로 사용하여 다음 두 출력 중 하나를 생성하는 프로그램 또는 함수 를 작성해야 합니다.

1. 단어의 균형이 맞으면 왼쪽, 공백, 고정 문자, 다른 공백 및 오른쪽으로 단어를 인쇄해야합니다.

   function (STEAD) -> S T EAD

2. 단어의 균형이 맞지 않으면 단어를 인쇄 한 다음 DOES NOT BALANCE

   function (WRONG) -> WRONG DOES NOT BALANCE

모든 입력이 대문자이고 알파벳 문자 만 있다고 가정 할 수 있습니다.

예제 I / O

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

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

Pyth, 49 바이트

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

데모.

설명:

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.

순수 배쉬 (coreutils 또는 기타 유틸리티 없음), 125

원점에 대한 모멘트를 사용한 표준 질량 중심 계산 :

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}

테스트 출력 :

$ 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
$ 

파이썬 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])

이 코드는 잠재적 fulcrums을 테스트하지 않고 "질량 중심"을 찾아서 정수인지 확인합니다. 총 질량 a과 위치 가중 질량 을 합하여 질량 b중심을 찾습니다 m=b/a. 그런 다음 위치 분할 문자열 분할 m또는 목록 슬릭 트릭으로 "DOES NOT BALANCE"선택한 문자열 더하기 를 인쇄합니다 [_::2].

CJam, 57 바이트

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

이것은 여전히 ​​약간 골프를 칠 수 있습니다.

여기에서 온라인으로 사용해보십시오

자바 스크립트 (ES6) 211 200 160 바이트

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

이전 시도, 200 바이트

골프를 도와 주신 edc56과 nderscore 덕분에

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

데모

ES6이므로 Firefox 및 Edge 만 해당

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 173 바이트

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

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

확인:

$ ./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 바이트

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

Java 인터프리터를 사용하면 균형이 맞지 않는 단어에 대해 STDERR에 오류가 발생하여 종료됩니다.

CJam 인터프리터 에서 코드를 시도하면 마지막 출력 줄을 제외한 모든 것을 무시하십시오.

생각

내 "원래 아이디어"는 @xnor가 몇 시간 전에 게시 한 것과 동일한 접근법으로 판명되었습니다 . 그럼에도 불구하고 여기에 간다.

값 목록을 감안할 때 (V ₀ ... V의 _N ) , 우리는 한 v_t는 다음 중 하나라도 해당 조건이 보유하고있는 경우에만 경우 목록의 앵커는 다음과 같습니다

• 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 ) 은 정수입니다.

암호

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.

이 부분에서는 오버로드 된 연산자로 약간의 재미를 느끼기 시작합니다.

몫의 경우 다음이 발생합니다.

)     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.

문자열의 경우 다음이 발생합니다.

)     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.

이때 ""마지막 문자가 없으므로 런타임 오류가 발생합니다 . 스택이 인쇄되고 실행이 즉시 중단됩니다.

줄리아, 122 바이트

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")

문자열을 입력으로 받아들이고 문자열을 반환하는 명명되지 않은 함수를 만듭니다. 호출하려면 이름을 지정하십시오 (예 :) f=s->....

우리는 단어를 질량 중심을 찾아야하는 1 차원 시스템처럼 취급합니다. 질량 중심은 위치를 가진 질량의 내적을 시스템의 총 질량으로 나눈 값으로 계산됩니다. 계산 된 중심이 정수인 경우 단어의 문자 중 하나에 해당합니다. 그렇지 않으면 단어의 균형이 맞지 않습니다.

언 골프 + 설명 :

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

예 :

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

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

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

PHP, 249 174 바이트

하나의 명령 줄 인수를 사용합니다.

<?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";

초기 시도 :

<?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";

하스켈, 161135 바이트

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=([]!)

사용 예 :

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

작동 방식 : 주어진 위치에서 단어의 왼쪽과 오른쪽의 두 가지 매개 변수를 취하는 f도우미 함수 !를 호출합니다 . 두 부분의 무게가 같 v거나 (function ) 오른쪽 부분의 첫 글자가 왼쪽으로 이동하면서 재귀 적으로 호출 되면 중지됩니다 . DOES NOT BALANCE오른쪽 부분이 비어 있으면 메시지로 끝납니다 .

C, 183134 바이트

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

새로운 버전 설명 :

다른 두 항목과 마찬가지로 한쪽에 일정한 덧셈을 사용하고 다른쪽에 뺄셈을 사용하면 균형을 나타내는 0에 도달 할 수 있습니다. 내 원래 출력은 약간 수정되었지만 첫 번째 답변에서 재사용됩니다.

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

구버전 설명 :

첫 번째 루프 (h)는 문자열 길이의 기본 반복기입니다. 두 번째 루프 (i)는 h == i가 될 때까지 누적합니다 (b). 그런 다음 (b)는 (a)에 저장되고 0으로 재설정 된 다음 (a)가 (b)와 비교되는 문자열의 끝에 도달 할 때까지 계속됩니다. 일치하는 경우 기본 반복기의 루프가 끊어지고 출력이 인쇄됩니다.

루비 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}

온라인 테스트 : http://ideone.com/G403Fv

이것은 매우 간단한 Ruby 구현입니다. 읽을 수있는 프로그램은 다음과 같습니다.

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 바이트

명명되지 않은 함수로. 좀 더 얻을 수있을 것 같지만 기다려야합니다.

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

간단한 설명으로 조금 풀다

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
}

끝에 줄 바꿈을 넣지 않습니다.

시운전

> 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 바이트

나를 때리는 것에 대한 일부 사용자의 신용 :)

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

자바, 240 바이트

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