산술 진행


11

당신의 임무는 산술 시퀀스 인 경우 n 번째 항에 대한 공식을 입력하고 출력하여 수식을 출력하는 것입니다. 그렇지 않으면 "NAAP"를 인쇄해야합니다.


입력

입력 (STDIN에서)은 4-10 개의 숫자로 구성되며, 각 숫자는 -1000에서 1000 사이의 범위에 있으며 구분 기호 (공백 또는 쉼표 또는 세미콜론으로 구분됨) 선호도]). 다음은 입력 예입니다.

12,14,16,18       //valid
-3 4 5 1 -2 -4    //valid
45;35;-35         //invalid (only three numbers are present instead of the minimum of 4 numbers)
2,32;21,321       //invalid (it uses two different delimiters: `,` and `;`)

산출

프로그램은 먼저 입력이 산술 진행 인지 여부를 확인해야합니다 .

간단히 말해서 산술 진행 (AP) : 모든 AP에는 공통의 차이가 있습니다. 이것은 $ n $와 $ {n-1} $의 용어의 차이입니다 (기본적으로 $ a (n + 1) a-a (n) $ ). 이 차이는 AP의 $ n $에 대해 동일하게 유지됩니다. 공통적 인 차이가 없으면 산술 시퀀스 가 아닙니다 . n 번째 항의 값을 계산하려면이 수식 $ a (n) = a (1) + (n-1) d $를 사용하십시오. 여기서 $ a (1) $는 첫 번째 항이고 $ d $는 공통입니다 차.

산술 진행 이 아닌 경우 프로그램은 "NAAP"오류 메시지 ( "산술 진행이 아님"의 줄임말)를 인쇄해야합니다.

이 경우 산술 진행하고 프로그램 표준 출력 순서의 간략화 n 번째 항을 인쇄한다.

예:

> 1,3,5,7,9
2n-1

설명 : 이것은 공통된 차이 ($ 3-1 = 2 $)가 있기 때문에 AP입니다. 그런 다음 공식 $ a (n) = a (1) + (n-1) d $를 사용합니다

an=a1+(n1)d

an=1+(n1)2

an=1+2n2

an=2n1

따라서 출력은 2n-1(공백이 없다는 것을 알 수 있습니다)


표준 허점은 기본적으로 허용되지 않습니다.

원하는 경우 숫자 배열을 매개 변수로 사용하여 함수를 만들 수 있습니다. 그렇지 않은 경우 입력을 문자열 또는 배열로 가져 와서 그에 따라 출력 하는 전체 프로그램을 작성해야합니다 .

테스트 사례 :

1.

1,3,5,7,9
2n-1

2.

1 3 12312 7 9
NAAP

삼.

-6;8;22;36;50
14n-20

4.

5,1,-3,-7,-11,-15
-4n+9

5.

-5,-7,-9,-11,-13,-15
-2n-3

6.

3,3,3,3,3,3,3,3,3
0n+3

7.

-4,-5,-6,-7
-1n-3

이것은 이므로 바이트 단위의 가장 짧은 코드가 이깁니다! (나쁜 수학 jax 죄송합니다)

어떤 제안이라도 환영합니다!


4
당신은 아마 1 시간 이상 샌드 박스에 게시물을 보관해야합니다 ...
Mego

3
한 시간은 정말 짧은 시간입니다. 모든 사람이 샌드 박스를 지속적으로 확인하는 것은 아닙니다. 최소 24 시간이 적당합니다.
Mego

8
죄송하지만 MathJax는 Meta에서 작동하지만 기본 PPCG 사이트에서는 작동하지 않습니다 ...
ETHproductions

1
시퀀스가 감소하는 테스트 사례를 추가해야합니다.
lirtosiast

2
인가 0,0,0,03,1,-1,-3,-5등차 수열? 그렇다면 내가 시도한 방법을 위반했기 때문에 테스트 사례가 좋을 것이라고 생각합니다.
xnor December

답변:


5

Pyth, 30 바이트

?tJ{-VtQQ"NAAP"+hJ%"n%+d"-hQhJ

테스트 스위트

산술 행렬인지 확인하기 위해 각 요소와 이전 요소 사이의 벡터화 된 빼기를 사용합니다 -VtQQ. 삼항은 결과에 여러 값이 있는지 확인 ?tJ{하고 ( ) NAAP그렇다면 인쇄 합니다. 그런 다음 오른쪽 +또는 -오른쪽 을 얻기 위해 mod 형식 %+d이 사용됩니다.


3

하스켈, 103 바이트

z=(tail>>=).zipWith
f l@(a:b:_:_:_)|and$z(==)$z(-)l=show(b-a)++'n':['+'|b-a<=a]++show(a+a-b)
f _="NAAP"

사용 예 :

f [-6,8,22,36,50]   ->   "14n-20"
f [60,70,80,90]     ->   "10n+50"
f [2,3,4,6,7,8]     ->   "NAAP"

Haskell에서 항상 그렇듯이 멋진 출력 형식 (예 : 숫자와 문자열 혼합)은 많은 바이트를 소비합니다 (약 40). 프로그램 논리는 매우 간결합니다.

f l@(a:b:_:_:_)           -- pattern match an input list with at least 4 elements,
                          -- call the whole list l, the first two elements a and b
z=(tail>>=).zipWith       -- the helper function z takes a function f and a list l
                          -- and applies f element wise to the tail of l and l

           z(-)l          -- make a list of neighbor differences
     z(==)                -- then compare these differences for equality
 and                      -- and see if only True values occur

       show ...           -- if so format output string

f _="NAAP"                -- in all other cases ( < 4 elements or False values)
                          -- return "NAAP"

2

TI-BASIC, 70 바이트

Input X
ΔList(∟X->Y
If variance(Ans
Then
∟X(1)-min(Ans
Text(0,0,min(∟Y),"n",sub("+-",(Ans<0)+1,1),abs(Ans
Else
"NAAP

TI-BASIC의 숫자-문자열 변환 부족을 해결하기 위해 Text(진행률이 산술 인 경우 그래프 화면의 출력 ( )을 사용 하여 인수를 자동으로 연결합니다.

이것은 이진수 빼기 부호가 아니라 TI-BASIC의 높은 빼기 부호 문자 (약간 비슷 함 )를 사용하여 음수가 입력되었다고 가정합니다 . 그러나 출력은 이진 빼기 부호를 사용합니다.


2

Japt , 60 52 51 바이트

V=N¤£X-NgY+1};W=Vg;Ve_¥W} ?W+'n+'+sU<W +(U-W :"NAAP

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

인터프리터가 설계된 방식이므로 원하는 구분 기호로 입력 할 수 있습니다.)

언 골프와 설명

V=N¤  £    X-NgY+1};W=Vg;Ve_  ¥ W} ?W+'n+'+sU<W +(U-W :"NAAP
V=Ns2 mXYZ{X-NgY+1};W=Vg;VeZ{Z==W} ?W+'n+'+sU<W +(U-W :"NAAP

            // Implicit: N = list of inputs, U = first input
V=Ns2       // Set variable V to N, with the first 2 items sliced off,
mXYZ{       // with each item X and index Y mapped to:
X-NgY+1}    //  X minus the item at index Y+1 in N.
            // This results in a list of the differences (but the first item is NaN).
W=Vg;       // Set W to the first item in V (the multiplication part).
VeZ{Z==W}   // Check if every item in V is equal to W.
?W+'n+      // If true, return W + "n" +
'+sU<W      //  "+".slice(U<W) (this is "+" if U >= W, and "" otherwise)
+(U-W       //  + (U minus W [the addition part]).
:"NAAP      // Otherwise, return "NAAP".
            // Implicit: output last expression

1

Matlab, 103 바이트

x=str2num(input('','s'));y=diff(x);if range(y) disp('NAAP'),else fprintf('%gn%+g\n',y(1),x(1)-y(1)),end

1

CJam, 38 바이트

{:T2ew::-):U-"NAAP"UW*"n%+d"T0=U+e%+?}

이것은 스택의 배열을 입력으로 사용하고 스택의 문자열을 출력으로 남겨 두는 익명 함수입니다. 테스트를위한 추가 I / O 코드와 함께 온라인 으로 사용해보십시오 .

설명:

:T      Save a copy of input in variable T for output generation.
2ew     Generate list of pairs of sequential elements.
::-     Reduce all pairs with subtraction operator.
)       Pop last value from list of differences.
:U      Save difference value in variable U for output generation.
-       Set difference. This will leave an empty list (falsy) if all values are the same.
"NAAP"  First value for ternary operator, for case where not all values are the same.
UW*     Start generating output for success case. Need to flip sign of difference saved
        in variable U, since it was 1st value minus 2nd, and we need the opposite.
"n%+d"  Push format string for printf operator. The + sign in the format specifies that
        the sign is always generated, saving us from needing different cases for the
        value being negative or positive.
T0=     Extract first value from original input saved in variable T.
U+      Add the difference (with the "wrong" sign) to it.
e%      "printf" operator.
+       Concatenate two parts of result.
?       Ternary operator for picking one of the two output cases.

1

자바 스크립트 (ES6), 91 바이트

x=>(s=x.split`,`,m=s[1]-s[0],a=s[0]-m,s.some((n,i)=>n!=m*i+m+a)?"NAAP":m+"n"+(a<0?a:"+"+a))

설명

x=>(
  s=x.split`,`,       // s = array of input numbers
  m=s[1]-s[0],        // m = the multiplication part of the formula
  a=s[0]-m,           // a = the addition part of the formula
  s.some((n,i)=>      // check if the rest of the numbers follow this sequence
    n!=m*i+m+a
  )?"NAAP":
  m+"n"+(a<0?a:"+"+a) // output the formula
)

테스트

<input type="text" id="input" value="5,1,-3,-7,-11,-15" /><button onclick='result.innerHTML=(

x=>(s=x.split`,`,m=s[1]-s[0],a=s[0]-m,s.some((n,i)=>n!=m*i+m+a)?"NAAP":m+"n"+(a<0?a:"+"+a))

)(input.value)'>Go</button><pre id="result"></pre>


1

펄 6 123 102 101 바이트

편집 : 차이를 부정하지 마십시오

편집 : 익명 하위, 논리 연산자 및 문자열 보간을 사용하십시오. 감사합니다 브래드 길버트 b2gills

sub{my@b=@_.rotor(2=>-1).map({[-] $_}).squish;$_=@_[0]+@b[0];@b.end&&"NAAP"||"@b[0]n{'+'x($_>=0)}$_"}

테스트 프로그램 (stdin에서 읽음) :

my $f = <the code above>
$f(split(/<[;,]>/, slurp)).say

설명:

my @b =
  @_.rotor(2=>-1)  # sliding window of 2: (1,2,3,4) => ((1,2),(2,3),(3,4))
  .map({[-] $_})  # calculate difference (subtract all elements and negate)
  .squish;         # remove adjacent elements that are equal

@b.end        # @b.end is last index, @b.end = 0 means @b has only 1 element
&& "NAAP"     # true branch
|| "@b[0]n{'+'x($_>=0)}$_" # string for an+b, 
        # {'+'x($_>=0)} inserts a plus sign using the repetition operator x

일반적으로을 제거 할 수 있도록 람다 식 양식 중 하나를 사용합니다 sub f. 또한 @_대신에 사용 @a하면 몇 바이트를 절약 할 수 있습니다. {my@b=@_.rotor.... 또한 당신이의 상태 주위에 괄호를 넣으면 안됩니다 if당신이 변경 한 경우 문이 펄 5 아닙니다 if@b.end&&"NAAP"||$_=...당신이 몇 가지 더 바이트를 저장합니다. 4 바이트를 절약하면서 대신 if사용한 마지막 문을 제거 할 수도 있습니다 "@b[0]n{'+'x($_>=0)}$_".
브래드 길버트 b2gills

sub처음에는 익명의 블록이 아니라면 필요하지 않습니다 . 또한 당신도 알다시피, 나는 .map({[-] $_})아마 ».map(*-*).flat더 오래 사용했을 것이라고 생각하지 않았을 것입니다 . 이제 당신의 트릭으로 그것을 줄일 수 있는지 확인하려면 내 자신의 항목을 살펴 봐야합니다.
Brad Gilbert b2gills

1

루비, 95 78 76 바이트

->s{i,j=s;puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"}

78 바이트

->s{puts s.reduce(:+)==s.size*(s[-1]+i=s[0])/2?"%dn%+d"%[v=s[1]-i,i-v]:"NAAP"}

95 바이트

->s{puts s.reduce(:+)==s.size*(s[0]+s[-1])/2?"#{v=s[1]-s[0]}n#{"+"if (i=s[0]-v)>0}#{i}":"NAAP"}

언 골프 드 :

-> s {
  i,j=s
  puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"
}

용법:

->s{i,j=s;puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"}[[-6,8,22,36,50]]

=> 14n-20

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.