밸런싱 법

시소 ( '이것'을 의미하는 프랑스어 'ci-ça'에서 유래)는 유사하게 유비쿼터스 한 슬라이드 및 스윙과 함께 놀이기구 장비의 삼위 일체를 형성합니다. 시소는 각 측면의 모멘트의 합이 동일한 경우에만 완벽한 균형을 유지합니다. 따라서 모멘트 합계가 낮은쪽에 특정 중량을 추가하여 시소의 균형을 맞출 수 있습니다. 이것을 달성하는 것이이 도전의 목표입니다.

도전

당신의 도전은 시소를 입력으로 묘사하고 다시 출력하고, 시소의 한쪽 끝에 무게를 더해 균형을 맞추는 것입니다.

입력

프로그램은 합리적인 형식으로 다음과 같은 ASCII 시소를 가져와야합니다.

100             100
-------------------
         ^         

첫 번째 줄에는 시소의 무게를 나타내는 두 개의 숫자가 있습니다. 정확히 하나의 무게가 각 측면에 존재하며, 각각은 판자의 측면의 맨 끝에 작용합니다. 가중치는 정수로 보장되며 항상 판자의 해당 끝과 정렬됩니다. 이 숫자는 받침점 ( ^)과 겹치지 않습니다 .

두 번째 줄은 시소의 '판'을 나타냅니다. 각 대시 ( -)는 길이 ^가없는 받침점 ( ) 바로 위의 대시를 제외하고 서로 대시와 동일한 길이를 나타냅니다 .

세 번째 줄은 시소의 받침을 나타냅니다. 이 받침점은이 줄에 공백이 아닌 유일한 문자 인 곡절 ( '^')로 표시됩니다. 받침점은 무게를 나타내는 숫자가 받침점 또는 받침점에서 받침점과 겹치지 않도록 충분한 공간이 남아있는 한 유효한 입력에서 널빤지 길이를 따라 임의의 위치에 배치 할 수 있습니다.

입력은 세 줄을 가지며 시소를 구성하는 문자 앞이나 뒤에 공백이 없어야합니다 (물론 세 번째 줄은 제외).

산출

출력을 위해 동일한 시소 그림을 표준 출력으로 인쇄해야하지만 시소의 균형을 유지하기 위해 하나의 무게로 더 큰 무게로 교체해야합니다. 입력은 정수만 사용하여이를 가능하게합니다. 따라서 가중치는 소수점이나 다른 유사한 표기법없이 표시해야합니다. 귀하의 언어가 stdout을 사용하지 않는다면 출력에 대한 커뮤니티 / 메타 합의를 거쳐야합니다. 후행 줄 바꿈은 괜찮지 만 묘사 형식의 다른 변경 사항은 아마 올바르지 않습니다.

예증

테스트 입력 및 해당 출력

입력 1

12                22
--------------------
             ^      

출력 1

12                26
--------------------
             ^      

입력 2

42       42
-----------
     ^     

출력 2

42       42
-----------
     ^     

입력 3

3             16
----------------
        ^      

출력 3

14            16
----------------
        ^      

입력 4

1                56
-------------------
    ^              

출력 4

196              56
-------------------
    ^              

참조 구현-Python 3

# Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])

규칙

• 이것은 code-golf 이므로 가장 짧은 코드는 바이트 단위로 계산됩니다. 언어에서 바이트 수를 계산하는 것이 어색한 경우 메타를 확인하십시오.

• 표준 규칙 / 허점이 적용됩니다.

• 적절한 형식으로 입력해야합니다. 적절한 형식의 전체 목록은 다음과 같습니다.

  • 줄 바꿈 문자로 구분 된 줄이있는 단일 문자열
  • 각 문자열은 한 줄을 나타내는 문자열 목록
  • 문자의 2D 배열 또는 매트릭스

관련 도전

• 시소 에 무게의 균형 을 잡으십시오-samgak의 2015 년 8 월 제안

05AB1E ,60 51 50 49 47 45 바이트

Emigna 덕분에 10 바이트를 절약하고 Adnan 덕분에 1 바이트를 절약했습니다.

모든 입력 줄의 문자 수는 같아야합니다.

#õKD³'^¡€gDŠ*¬-Os÷1®‚*D0›*+¬?DJg²gs-ð×?¤,²,³,

#                                             Split the first input line on spaces
 õKD                                          Push [first weight, second weight] twice
    ³'^¡€gD                                   Push both lengths from either side of the pivot '^' as an array [left, right] twice
           Š*                                 Multiply by weights to get torque
             ¬-O                              Evaluate rightTorque-leftTorque
                s÷                            Divide by each side's length to get the weights to add: [deltaLeft, deltaRight], keep integer values
                  1®‚                         Push [1,-1]
                     *D                       Yield [deltaLeft, -deltaRight]
                       0›*                    Replace the negative value by 0
                          +                   Add weights: old + deltaWeight
                           ¬?                 Print left weight
                             DJg              Take the size of total decimal representation
                                ²gs-ð×?       Print a string composed of filler spaces between both new weights
                                       ¤,     Print right weight and newline
                                         ²,³, Print the last two lines from input (unchanged)

온라인으로 사용해보십시오!

"05AB1E 코드가 40 바이트보다 길면 잘못했을 수 있습니다"와 같은 규칙이 있어야합니다. 너무 골프 타는 것 같습니다. 어떤 아이디어라도 환영합니다!

자바 스크립트 (ES6), 136

Chrome은 비정형 할당 및 기본 매개 변수를 사용하므로 Chrome에서 작동하지 않을 수 있습니다.

표준 JS 출력 방법 alert은 사용 된 비례 글꼴로 인해 작업에 특히 적합하지 않습니다.

(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

덜 골프

( m,n,o, // input parameters, 3 strings
  // default parameters used as local variables
  [p,q] = m.split(/ +/), // left and right weight
  l = n.length, // bar length
  h = o.indexOf`^`, // left length
  g = l-h-1, // right length
  // p*h left torque
  // q*g right torque
  c = p*h<q*g ? q*g : p*h // max torque
) => alert( (c/h+o).slice(0,h)+(o+c/g).slice(h-l) // o has enough spaces to pad left and right
     +`\n${n}\n`+o )

테스트

F=
(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

function go()
{
  var [a,b,c]=I.value.split('\n')
  if(a.length!=b.length || a.length < c.length)
    alert('The strings are not of the same length')
  else 
  {  
    if (a.length > c.length)
      c = c+' '.repeat(a.length-c-length)
    F(a,b,c)
  }  
}

<textarea id=I>3             16
----------------
        ^      </textarea>
<button onclick='go()'>go</button>

Perl, 149 + 2 = 151 자

명령 줄 옵션 -p0이 필요합니다 (프로그램 자체의 149 바이트 위에 2 바이트 페널티가 부여됩니다).

($_,$b,$c,$d)=map length,/(\d+) +(.+)
(-+)
( +)/;$r=$d/($c-$d-1);($x,$y)=$1*$r>$2?($1,$1*$r):($2/$r,$2);$_="$x$,$y",$,.=$"while$c>length;$\="
$3
$4^"

설명:

• -p0스위치는 제 NUL 바이트 또는 EOF까지 전체 입력을 판독한다. 이 문제는 NUL을 허용하지 않으므로 $_기본적으로 정규 표현식 등에 사용되는 변수의 전체 입력을 얻습니다 .
• 입력을 구문 분석하는 정규식으로 시작합니다 (첫 번째 슬래시와 두 번째 슬래시 사이). 첫 번째 가중치를 구문 분석 할 수있는 몇 가지 방법이 .+?있지만 (예를 들어 ) 3 자 미만으로 얻을 수 없으므로 명백한을 사용할 수도 있습니다 \d+. 두 번째 숫자는 줄의 끝에 있으므로 .+(2 자) 로 구문 분석 할 수 있습니다 . 중심선은 스케일의 넓이를 결정하는 데 사용됩니다. 그것은 -+(다른 많은 표현들이 효과가 있습니다) 로 구문 분석되었습니다 . 마지막 줄에서 캐럿 앞의 공백은 +입니다. 캐럿 (또는 실제로 비 공백)이 나타나면 나머지 입력을 무시합니다.
• 펄 자동으로 정규식의 네 그룹 (캐럿 전에 제 중량 초 중량, 하이픈의 행 공간)을 포착 $1, $2, $3, $4. 정규식을 인수로 제공하면 map추가로 해당 그룹의 배열을 배열로 사용하여 매핑됩니다. 그러므로 우리는 그들의 길이를 취합니다. 이의 길이를 저장하는 편리한 방법 $3등을 $4작성하지 않고도 length두 번. 우리는 또한 $_길이를 덮어 씁니다 $1. 우리는 실제로이 값 (왼쪽 입력의 자릿수는 쓸모가 없습니다)에 관심이 없지만 짧습니다 ( $_'길이는 이제 자릿수의 자릿수입니다. 첫 번째 무게는 저울의 너비와 비교할 때 반드시 매우 작습니다).
• 우리 $r는 스케일이 나누어지는 비율 을 측정합니다 .
• $1*$r>$2어느 쪽이 더 무거운 지 확인합니다. 우리는 새로운 가중치 저장 $x및 $y; 가중치의 비율이 알려지면 계산이 매우 간단합니다.
• 우리는 연결하여 $x, $,그리고 $y으로 $_상단 행을 생성 한 후 추가 공간 (유지 $"기본적으로 하나의 공간을 포함하고, 문자 그대로의 공간이보다 짧은 ' '것) 위에 $,그 중간 행과 같은 길이 될 때까지 (즉, 길이 $c). ( $,이 컨텍스트에서 안전하게 변경할 수 있고 기본적으로 비어있는 내장 변수 이므로 변수 를 선택했습니다 .) 기본적으로 length작동 $_하므로 명시 적으로 인수를 제공 할 필요가 없습니다. Yoda 조건부를 사용했습니다. 구문을 올바르게 구문 분석하는 데 상당히 명확하지 않은 구문이 필요하기 때문입니다.
• 마지막으로, 출력 줄 끝 규칙 ( $\) 에 대한 Perl의 아이디어를 재정 의하여 나머지 스케일 세트를 포함하도록 (입력과 동일하므로 간단히 사용 $3하고 $4직접 대량을 생성 할 수 있음). 이것은 세 번째 줄에 후행 공백이 없음을 의미합니다. 추가하면 프로그램이 약간 길어지고 목적을 달성하지 못하는 것 같으므로 생략했습니다.
• 프로그램이 끝나면 -p스위치가 다시 트리거됩니다. 이번에 $_는 "newline"( $\) 이 출력 됩니다 . 출력 줄 바꿈을 재정의 했으므로이 두 개의 암시 적 인쇄는 그 사이에 새로운 배율 세트를 생성합니다 (부수 효과이지만 출력에는 줄 바꿈이 없음).
• -p스위치는 이제 다시 입력을 읽으려고하지만 EOF를 읽고 프로그램을 종료 그래서 우리는 이미, 전체 파일을 slurped.

PHP, 212 (209) 205 바이트

아마 골프

preg_match("#(\d+)( +)(\d+)\s*(-+)[\r\n]+( +)\^#",$s=$argv[1],$m);echo preg_replace("#\d+( +)\d+#",(($r=$m[3])>($q=$m[1]*($p=strlen($m[5]))/(-$p-1+$e=strlen($m[4])))?$r*$e/($p+1)-$q=$r:$m[1]).$m[2].$q,$s);

명령 행 인수에서 입력을받습니다. 개행을 피하십시오. 로 실행하십시오 -r.

자리 표시 자로 교체해도 예상대로 작동하지 않았습니다. 그래서 첫 정규 표현식에 더 많은 parens를 추가해야했습니다.

일러스트레이션, 223 217 바이트

&:00p&10p~$0>~#<2#+%#1_:20p0~>8#~%#+!#1_:3v
v\g01/g03*g01_v#!\g04`*g01g04:*g03p04-1-p0<
>#g>#0>#0>#/>#<:.2\5>5>#\+/#1:#\_$50p:50g\5>5>#\+/#1:#\_$20g\-v>
1#,>#*-#4:#8_$.55+,20g>:#,1#*-#9\#5_55+,30g>:#,1#*-#8\#4_"^",@>>

온라인으로 사용해보십시오!

파이썬 2, 184 183 바이트

확실히 골프 가능

i=raw_input
j=int
w=map(j,i().split())
W=len(i())
I=i().find('^')
R=W-I-1
a=[w[1]*R/I,w[0]*I/R]
h=a[1]>w[1]
w[h]=j(a[h])
k='\n'
print(' '*(W-len(str(w))+4)).join(map(str,w))+k+'-'*W+k+' '*I+'^'

꽤 직설적 인. 양쪽을 조정하기 위해 조정 된 분동을 취하고, 어느 쪽이 원본보다 큰지 확인하고, 그 중 하나를 변경하여 출력하십시오.

정수 나누기가 사악하기 때문에 곱셈과 나눗셈을 바꿨습니다 (이 사실을 알고 @JonathanAllan에게 감사드립니다)

EDIT -1 바이트 변경됨 i().index('^')에 i().find('^')(@JonathanAllan 덕분 [다시!])

C ++ 14, 482 바이트

include<iostream>#include<string>#include<math.h>usingnamespacestd;intmain(){stringa,b,c,d;intj=0;inte[2];getline(cin,a);getline(cin,b);getline(cin,c);for(inti=0;i<a.size();i){if(isdigit(a.at(i))){while(i<a.size()&&isdigit(a.at(i))){d=a.at(i);i;}e[j]=stoi(d);d="";}}strings(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,'');intl1=(c.size()-1);intl2=(b.size()-c.size());intl=e[0]*l1;intr=e[1]*l2;if(l>r)e[1]=l/l2;elsee[0]=r/l1;cout<<e[0]<<s<<e[1]<<endl;cout<<b<<endl;cout<<c;return0;}

더 읽기 쉬운 버전 :

#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int main() {
    string a,b,c,d;
    int j=0;
    int e[2];
    // input
    getline(cin,a);// 1st line
    getline(cin,b);// 2nd line
    getline(cin,c);// 3rd line
    for (int i=0;i<a.size();i++) {
        if(isdigit(a.at(i))){
            while(i<a.size() && isdigit(a.at(i))){
                d+=a.at(i);
                i++;
            }
            e[j++]=stoi(d);
            d="";
        }
    }
    // amount of white space in between 2 numbers
    string s(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,' ');
    int l1 = (c.size()-1);
    int l2 = (b.size()-c.size());
    int l = e[0]*l1;
    int r = e[1]*l2;
    // change the side with smaller torque
    if (l>r)
        e[1]=l/l2;
    else
        e[0]=r/l1;
    // output
    cout<<e[0]<<s<<e[1]<<endl;// 1st line
    cout<<b<<endl;// 2nd line
    cout<<c;// 3rd line
    return 0;
}

Python 3, 235230 바이트 (최소 참조)

코드 골프에 익숙하지 않기 때문에 참조를 최소화했습니다.

def s(l):
 w,i,t=[int(z.strip())for z in l[0].split()],len(l[1]),l[2].find("^");k,o=i-1-t,w[0]*t;p=w[1]*k
 if o>p:w[1]=o//k
 else:w[0]=p//t
 w=[str(z)for z in w];s=" "*(i-sum(len(z)for z in w));l[0]=w[0]+s+w[1];print("\n".join(l))

예제와 정확히 동일하게 사용하지만 s대신 함수 입니다 balance_seesaw.