확장 배열

21

두 개의 양의 정수 p 와 q가 주어지면 다음 알고리즘을 적용하여 생성 된 배열 A 를 반환해야 합니다.

  1. 시작 A = [P, Q] 과 D = 2
  2. A 의 합이 d 로 나눌 수있는 연속 된 숫자의 각 쌍 (x, y) 에 대해 x 와 y 사이에 (x + y) / d를 삽입하십시오 .
  3. 일치하는 쌍이 하나 이상 발견되면 d를 증가 시키고 2 단계로 진행하십시오. 그렇지 않으면 중지하고 A를 반환하십시오 .

예

다음은 p = 1 및 q = 21 에 대한 프로세스의 세부 사항입니다 .

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

따라서 예상 출력 : [1, 1, 4, 3, 11, 8, 21]

설명 및 규칙

  • 입력과 출력은 합리적인 형식으로 처리 할 수 ​​있습니다. 정수 p 와 q 는 0보다 커야합니다. 이것이 도움이되면 q ≥ p 라고 가정 할 수 있습니다 .
  • 알고리즘의 두 번째 단계 는 동일한 반복에서 방금 삽입 된 요소에 재귀 적으로 적용 되지 않아야 합니다. 예를 들어, A = [1, 1] 및 d = 2 는 [1, 1, 1] (무한한 1의 목록이 아님)으로 이어져야합니다.
  • 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다!

테스트 사례

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

당신이 약간 더 큰 테스트 케이스에 코드를 테스트하려는 경우, 여기 에 대한 예상 출력은 다음과 같습니다

  • p = 12096 (2 6 * 3 3 * 7)
  • q = 24192 (2 7 * 3 3 * 7)
code-golf  array-manipulation 
— 아르나 울드
소스

답변:

6

05AB1E , 28 19 18 바이트

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

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

어, 확실히 하드 코어를 향상시킬 수 있습니다. 여전히 리팩토링하기 위해 노력하고 있습니다.

아마도 내가 얻는 것만 큼 좋을 것입니다.

Emigna 외에는 누구에게도 감사합니다! 스왑을 지적하기 위해 레지스터보다 잘 작동했습니다.

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

에 대한 디버그 덤프 [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

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

— 매직 문어 항아리
소스
오, 그래서 그것은 ü작동 하는 방법입니다 ... 이것은 내 이전 답변 중 하나를 향상시킬 수있었습니다 :-)
— scottinet
@scottinet [1,2,3,4] ü = [[1,2],[2,3],[3,4]], 또한 05AB1E를 실행할 때 인수에 "-d"를 추가하면 위에서 첨부 한 "디버그"출력이 생성됩니다. (위의 디버그 링크도 추가했습니다). pairwise가 깔끔한 이유는 자동으로 벡터화되는 명령의 경우 명령을 pairwise로 적용하기 때문입니다 ( ü)목록에서 실행 하면 잘 표시됨).
— 매직 문어 Urn
나는 그 대답 에 1 바이트를 저장할 수 있다고 생각했다 . 에 관해서 -d... 나는 함께 "디버깅"후, waaay 너무 늦게 그것에 대해 발견 ,q"인쇄 및 정지"로 설정합니다. 아 ful어요.
— scottinet
@scottinet 내가 :( 그것에 대해 학습하기 전에 전체 년 05AB1E를 사용하고 있었다 내가 사용. =이 팝업하지 않으며, 단지 스택에 푸시 마지막 항목이 인쇄 때문입니다.
— 매직 문어 항아리를
당신이 제거하면 U당신은 대체 할 수 있습니다 X로 Š.
— Emigna
8

Mathematica, 72 64 59 58 바이트

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

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

작동 원리

입력을 목록으로 가져옵니다 {p,q}. 반복 단계는 다음과 같이 재구성됩니다.

  1. 삽입 (a+b)/d사이 마다 두 요소 a와 b: (x+{##2,}&@@x)시퀀스 연산 a+b와의를 a+Null끝. 우리는에 의해 분할 d하고, Riffle각각의 삽입 (a+b)/d사이 a와 b. 증분 d.
  2. Integer결과 목록 의 요소를 선택 하십시오. (이것도 Null도입 된 것을 제거합니다 {##2,}.)

결과가 변경되지 않을 때까지이 과정이 반복됩니다 (정수는 없었기 때문에 모든 새로운 요소를 제거했기 때문에 발생할 수 있음).

@MartinEnder 덕분에 -8 바이트 덕분에 //.대신 사용 FixedPoint하고 목록으로 입력 할 수 있습니다.

ListConvolve실제로 그렇게 크지 않기 때문에 -6 더

— 미샤 라브 로프
소스
1
//.trumps FixedPoint, 나는 두 개의 개별 정수 대신 정수 쌍으로 입력을 취합니다.(d=2;#//.x_:>x~Riffle~ListConvolve[{1,1}/d++,x]~Cases~_Integer)&
— Martin Ender
감사! 나는 대체 잊고 유지 //.와 FixedPoint내가 정말 정말 좋아하기 때문에 FixedPoint.
— Misha Lavrov
1
64 바이트에 불과합니다. 내부에 두 개의 인쇄 불가능한 것을 삽입 한 것 같습니다 Integer.
— Martin Ender
다시 감사합니다! 변경 후 왜 내 코드가 계속 실패하는지 전혀 몰랐으며 실제로 차이를 만들지 않는 일을했을 때 다시 작동합니다.
— Misha Lavrov
1
주석의 코드 스 니펫에는 때때로 인쇄 할 수없는 문자가 포함됩니다 (특히 코드 스 니펫에 줄 바꿈이있는 경우). SE가 왜 삽입하는지 확실하지 않습니다.
— Martin Ender
4

하스켈, 85 81 바이트

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

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

입력은 예를 들어 목록으로 사용 [1,2]됩니다.

편집 : @Laikoni 덕분에 -4 바이트.

— 니미
소스
로 2 바이트를 저장하십시오 l%d|l==l#d=l|e<-d+1=l#d%e.
— Laikoni
@Laikoni : 실제로 4 바이트입니다. 감사!
— nimi
3

파이썬 (2) , 112 (110) 108 105 103 바이트

Jonathan Frech 덕분에 -2 바이트
, Outgolfer Erik 덕분에 -5 바이트

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

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

— 막대
소스
y+=[...]*(...);y+=b,와 같지 y+=[...]*(...)+[b]않습니까?
— Jonathan Frech
@JonathanFrech yes
— Rod
— Outgolfer Erik
@EriktheOutgolfer 나는 이것을하려고 노력하고 있었지만 110b @에 있었다. @
— Rod
3

파이썬 2 , 98 바이트

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

로 호출하십시오 f([p,q]). 온라인으로 사용해보십시오!

Jonathan Allan은 12 바이트를 절약했습니다. 고마워 ~!

설명

f재귀 함수입니다. f(A, B, d)그렇지 f(next_A, A, d+1)않으면로 A == B반환 A됩니다. (이것은 의해 처리 A*(A==B)or …하십시오 ≠ B 경우, A*(A==B)소위, 오 Y 인 빈리스트 인 …부분이 평가되고, A = B는 다음 경우 A*(A==B)이다 A비어 있으므로 truthy 인 및 반납 얻는다).

next_A 다음과 같이 계산됩니다.

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

이것은 예를 통해 가장 잘 설명됩니다. 때 예 d = 5 하고 A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]
— 린
소스
zip열거 대신에를 사용하여 의 초기 값 [A[0]]으로 8 바이트 를 저장하십시오sum .
— Jonathan Allan
재귀 함수를 사용하여 다른 4 개 저장
— Jonathan Allan
@JonathanAllan 니스! 나는 다음으로 대체 [A[0]]하는 다른 바이트를 저장 했습니다 A[:1]:)
— Lynn
1
그리고 이제 3 덕분에 3 바이트를 이끌고 A*(A==B)있습니다.
— Lynn
2

파이썬 2 , 111 바이트

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

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

Rod 덕분에 -8 . Lynn
덕분에 -2 .

— 아웃 골퍼 에릭
소스
— Rod
@Rod Nice (ab) use o: p
— Erik the Outgolfer
— Lynn
대안 111 : 전체 for루프를 다음으로 대체while A[o+1:]:o+=1;s=A[o-1]+A[o];b=s%d<1;A[o:o]=[s/d]*b;m|=b;o+=b
— Lynn
2

껍질 , 22 바이트

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

2 요소 목록을 가져와 정수 및 부동 목록을 반환합니다. 온라인으로 사용해보십시오!

설명

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.
— 자브
소스
1

망막 , 111 바이트

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

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

공백으로 구분 된 숫자로 입력을받습니다. 주어진 알고리즘을 순진하게 따르며, a숫자 중 하나가 유지되었을 때 주목할만한 유일한 기법은 마커 기호를 사용하는 것 입니다. Retina의 다소 제한된 루핑 기능과 함께 작동하는 데 사용됩니다.이 기능은 스테이지 세트가 해당 스테이지의 입력을 전반적으로 변경하지 않을 때까지만 반복 할 수 있습니다.

설명:

이것은 질문에서와 동일한 예를 사용합니다.

\d+
$*1;

숫자의 입력 배열을 세미콜론으로 구분 된 단항 배열로 변경하면 다음과 같습니다. 

1; 111111111111111111111;

^
11@

넣어 d우리를주고, 처음에 우리의 코드로 :

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

이것은 약간 더 복잡합니다. {고정 점에 도달 할 때까지 실행될 스테이지 그룹을 시작합니다. 그런 다음 +이 단계 자체가 고정 된 지점까지 실행되어야 함을 나타냅니다. 이 단계에서는 인접한 각 쌍을 추가하지만 추가 세미콜론없이 삽입합니다. 이제 우리는 :

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

다른 까다로운 단계 인이 단계는 첫 번째 캡처 그룹에 제수를 모으고 후행 세미콜론없이 숫자를로 나눈 값으로 목록의 모든 숫자를 바꿉니다 d. 또한 a이 숫자에 행간 을 추가하여 무언가가 보관 ;되었음을 나타내며, 배열과 영구적으로 관계가 있음을 나타냅니다. 이제 우리는 :

11@1; a11111111111; 111111111111111111111;

 1+

이렇게하면 d이 라운드 이전에 배열 로 나눌 수없는 숫자가 삭제됩니다 . 이 예에서는 변경 사항이 없습니다.

.*a
1&$

이것은 문자열의 시작부터 a입력 의 마지막 글자까지 탐욕스럽게 일치 합니다. 이는 최대 하나의 일치 항목이있을 수 있음을 의미합니다. 변경 사항이 있으면에을 추가 d하고 그렇지 않으면 루프를 종료 할 수 있도록 그대로 둡니다.

111@1; a11111111111; 111111111111111111111;


)`a

(가) )에 의해 시작 루프를 닫습니다 {(! 그것을 의심하지 않는다) 그렇지 않으면이 단계는 우리가 이전에 내려 놓고 마커를 제거합니다. 이것이 루프의 끝이므로 위의 단계를 여러 번 반복하지만 루프를 잊어 버린 것처럼 예제를 계속 진행하기 때문에 계속 진행할 것입니다.

111@1; 11111111111; 111111111111111111111;


1+@

이 단계는 출력에서 ​​제거됩니다.

1; 11111111111; 111111111111111111111;

1+
$.&

이 단계에서는 단항을 10 진수로 바꿉니다.

1; 11; 21;


;

마지막 단계는 세미콜론을 제거합니다.

1 11 21

분명히 루프에서 건너 뛰면 여기에 잘못된 결과가 생길 수 있지만 너무 혼란스럽지 않기를 바랍니다.

— FryAmTheEggman
소스
내 마크 업 미리보기는 내가보고있는 출력과 다소 다르게 보입니다. 누구나 아이디어가 있습니까? 특히 내가 생각하지 않을 때 많은 코드 블록이 합쳐집니다.
— FryAmTheEggman
1

자바 스크립트 (ES6), 89 87 82 바이트

-2 바이트와 5 바이트를 절약하는 데 도움을 준 @Arnauld 에게 감사 합니다.

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

입력을 배열로 f([p,q])받습니다 : .

테스트 사례

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")
<pre id=O></pre>
스 니펫 확장

— 저스틴 마리너
소스
나는 당신이 업데이트 할 수 있습니다 생각 v( v+=b[++i]대신 사용하는) s1 바이트를 저장합니다. |r대신 다른 바이트를 저장할 수 있습니다 &&r(안전하다고 생각하지만 다시 확인하지는 않았습니다).
— Arnauld
@Arnauld 감사합니다! 사용하여 |r실제로 모든 테스트 케이스를 통과했다.
— Justin Mariner
다음 은를 사용하는 85 바이트 변형 push()입니다.
— Arnauld
@Arnauld Nice, 나는 원래 push두 번이 아닌 한 번만 사용하는 것을 생각 했습니다. 그 아이디어를 다시 방문한 후 86 바이트 동안 이 작업 을 수행했습니다. 어쩌면 그것은 향상 될 수 있습니까?
— 저스틴 마리너
84 바이트에 대해 다시 push(v,...)사용할 수 있습니다 . v+=
— Arnauld
1

자바 8, 180 바이트

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

설명:

여기에서 시도하십시오.

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method
— 케빈 크루이 센
소스
1

C #, 280 바이트

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

전체 프로그램 인 코드 골프를 먼저 시도하십시오. 그것을 테스트

시도 2, 159 바이트

작업은 한 쌍의 숫자 (배열이 작동 함)를 가져 와서 배열을 반환 할 수있는 기능을 제공하기 때문에 스캐 폴딩을 제거합니다. Func <int [], int []> F 를 사용하여 요구 사항을 충족시킬 수 있다고 가정하면 F를 정의하십시오 .

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

전체 프로그램 테스트

일반 목록이 유효한 출력으로 간주되는 경우 더 작을 수 있습니다 (10 바이트를 절약하려면 .ToArray ()를 삭제하십시오).

입력을 수정할 수있는 경우 배열 대신 List <int>를 전달하면 출력을 초기화 할 필요가 없습니다 (126 바이트로 나타남).

한 걸음 더 나아가이 경우 실제로 반환 값이 필요하지 않습니다. 대신 Action을 사용하면 return 문에서 사용하는 9 바이트가 제거됩니다.

— 작은 가지
소스
PPCG에 오신 것을 환영합니다! 좋은 첫 번째 대답.
— Arnauld
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.