2048 게임 에서와 같이 배열을 이동한다고 가정합니다. 배열에 동일한 두 개의 연속 요소가 있으면 값 요소의 두 배로 병합합니다. Shift는 연속 된 동일한 요소의 모든 쌍이 합으로 바뀌고 쌍이 교차하지 않아야하는 새 배열을 반환해야합니다. 이동은 한 번만 수행되므로 결과 값을 다시 병합 할 필요가 없습니다. 우리가 3 개 연속 동일한 요소가있는 경우, 우리는 예를 들어, 그래서, 오른쪽 것들을 요약해야한다는주의 [2, 2, 2]가되어야 [2, 4]하지 [4, 2].

이 작업은 배열을 가져와 시프트 된 배열을 반환하는 가장 짧은 함수를 작성하는 것입니다.

모든 정수가 엄격하게 양수라고 가정 할 수 있습니다.

예 :

[] -> []
[2, 2, 4, 4] -> [4, 8]
[2, 2, 2, 4, 4, 8] -> [2, 4, 8, 8]
[2, 2, 2, 2] -> [4, 4]
[4, 4, 2, 8, 8, 2] -> [8, 2, 16, 2]
[1024, 1024, 512, 512, 256, 256] -> [2048, 1024, 512]
[3, 3, 3, 1, 1, 7, 5, 5, 5, 5] -> [3, 6, 2, 7, 10, 10]

또한 reduce를 사용하는 솔루션에 매우 관심이 있습니다 :)

젤리 , 10 9 8 바이트

Œg+2/€UF

TryItOnline 또는 모든 테스트 사례 실행

어떻게?

Œg+2/€UF - Main link: a                 e.g. [2,2,2,4,4,8]
Œg       - group runs of equal elements      [[2,2,2],[4,4],[8]]
   2/€   - pairwise reduce for each with
  +      -     addition                      [[4,2],[8],[8]]
      U  - reverse (vectorises)              [[2,4],[8],[8]]
       F - flatten list                      [2,4,8,8]

하스켈, 47 57 50 바이트

e#l|a:b<-l,e==a= -2*a:b|1<2=e:l
map abs.foldr(#)[]

사용합니다 reduce(또는 foldHaskell에서 오른쪽 폴더 foldr). 사용 예 : map abs.foldr(#)[] $ [2,2,2,4,4,8]-> [2,4,8,8].

편집 : 정렬되지 않은 배열에서도 작동하도록 +10 바이트. 병합 된 숫자는 두 번째 병합을 방지하기 위해 음수 값으로 삽입됩니다. 그들은 최종에 의해 수정됩니다 map abs.

브레인 플락 , 158 96

{({}<>)<>}<>{(({}<>)<><(({})<<>({}<>)>)>)({}[{}]<(())>){((<{}{}>))}{}{{}(<({}{})>)}{}({}<>)<>}<>

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

설명:

1 목록을 뒤집습니다 (모든 것을 다른 스택으로 옮기지 만 중요하지 않습니다)

{({}<>)<>}<>
{        }   #keep moving numbers until you hit the 0s from an empty stack
 ({}<>)      #pop a number and push it on the other stack
       <>    #go back to the original stack
          <> #after everything has moved, switch stacks

2이 스택에 아무것도 남지 않을 때까지 3-6 단계를 수행하십시오.

{                                                                                         }

3 상단 두 요소 복제 (2 3-> 2 3 2 3)

(({}<>)<><(({})<<>({}<>)>)>)

(({}<>)<>                   #put the top number on the other stack and back on the very top
         <(({})             #put the next number on top after:
               <<>({}<>)>   #copying the original top number back to the first stack
                         )>)

4 상위 2 개가 같으면 1을, 그렇지 않으면 0 (위키)

({}[{}]<(())>){((<{}{}>))}{}

5 상단 2가 같으면 (상단 0이 아님) 다음 2를 더하고 결과를 누릅니다

{{}(<({}{})>)}{}
{            }   #skip this if there is a 0 on top
 {}              #pop the 1
   (<      >)    #push a 0 after:
     ({}{})      #pop 2 numbers, add them together and push them back on 
              {} #pop off the 0

6 상단 요소를 다른 스택으로 이동

({}<>)<>

7 다른 스택으로 전환하고 암시 적으로 인쇄

<>

PHP, 116 바이트

<?$r=[];for($c=count($a=$_GET[a]);$c-=$x;)array_unshift($r,(1+($x=$a[--$c]==$a[$c-1]))*$a[$c]);echo json_encode($r);

또는

<?$r=[];for($c=count($a=$_GET[a]);$c--;)$r[]=$a[$c]==$a[$c-1]?2*$a[$c--]:$a[$c];echo json_encode(array_reverse($r));

출력 print_r이 'json_encode'대신 배열 일 수있는 경우 -4 바이트

정규식으로 이것을 해결하는 176 바이트

echo preg_replace_callback("#(\d+)(,\\1)+#",function($m){if(($c=substr_count($m[0],$m[1]))%2)$r=$m[1];$r.=str_repeat(",".$m[1]*2,$c/2);return trim($r,",");},join(",",$_GET[a]));

GNU sed, 41 38 37

디지털 외상
덕분 에 -r -3에 +1 포함 -sshoumara 덕분에

:
s,(.*)(1+) \2\b,\1!\2\2!,
t
y,!, ,

입력과 출력은 단항으로 공백으로 구분 된 문자열입니다 ( 이 합의에 따라 ).

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

망막 , 32

\d+
$*
r`\b\1 (1+)\b
$1$1
1+
$.&

r3 행에서 오른쪽에서 왼쪽으로 정규 표현식 일치를 활성화합니다. 그리고 이것은 \1참조가 참조하는 (1+)캡처 그룹 보다 먼저 참조가 필요 하다는 것을 의미합니다 .

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

펄, 41 바이트

에 +1 포함 -p

STDIN에 입력 시퀀스를 제공하십시오.

shift2048.pl <<< "2 2 2 4 4 8 2"

shift2048.pl:

#!/usr/bin/perl -p
s/.*\K\b(\d+) \1\b/2*$1.A/e&&redo;y/A//d

파이썬, 61 바이트

def f(l):b=l[-2:-1]==l[-1:];return l and f(l[:~b])+[l[-1]<<b]

부울 b은 마지막 두 요소가 길이 1 또는 0의 목록에 대해 안전한 방식으로 동일한 지 확인하여 축소해야하는지 여부를 확인합니다. 그런 다음 마지막 요소 1는 같거나 2같지 않은 승수로 추가됩니다 . 그것은 많은 요소가 끝에서 잘린 목록의 재귀 결과에 추가됩니다. 1 바이트의 Dennis에게 감사합니다!

펄, 43 + 1 ( -p) = 44 바이트

Ton Hospel은 41 바이트의 답을 찾았습니다 .

@Ton Hospel 덕분에 -4!

편집 : 추가 \b하지 않고 24 4출력이 있었던 것처럼 입력에서 실패했습니다.28 .

$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge

-p플래그로 실행 :

perl -pe '$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge' <<< "2 2 2 4 4"

내가 사용하는 것보다 다른 방법이 표시되지 않는 reverse(것처럼 오른쪽 배에 두 번 s/(\d+) \1/$1*2/ge배를 왼쪽 것, 즉 2 2 2될 것 4 2대신에 2 4). 14 바이트로 인해 잃어 버렸습니다 reverse... 여전히 다른 (더 나은) 방법이 있어야한다고 생각합니다 (결국 펄입니다!), 당신이 그것을 찾으면 알려주십시오!

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

f=a=>a.reduceRight((p,c)=>(t=p[0],p.splice(0,c==t,c==t?c+t:c),p),[])
    
console.log([
  [],
  [2, 2, 4, 4],
  [2, 2, 2, 4, 4, 8],
  [2, 2, 2, 2],
  [4, 4, 2, 8, 8, 2],
  [1024, 1024, 512, 512, 256, 256],
  [3, 3, 3, 1, 1, 7, 5, 5, 5, 5],
].map(f))

Perl 5.10, 61 50 바이트 ( 플래그의 경우 49 + 1)

덕분에 11 바이트를 절약 한 Ton Hospel 에게 합니다!

-a플래그가있는 정규식없는 솔루션 :

@a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"

여기를보십시오!

자바 스크립트 (ES6), 68 65 58 57 65 64 바이트

@ l4m2 덕분에 1 바이트 절약

정렬되지 않은 배열에 대해 이러한 입력이 예상된다는 것이 명확 해졌습니다.

f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]

console.log(f([2, 2, 4, 4]));
console.log(f([2, 2, 2, 4, 4, 8]));
console.log(f([2, 2, 2, 2]));
console.log(f([4, 2, 2]));

05AB1E , 26 바이트

D¥__X¸«DgL*ê¥X¸«£vy2ôO})í˜

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

일반화 된 단계

1. 연속 요소가 다른 곳을 찾으려면 빼기로 줄이십시오.
2. 연속 된 요소의 길이를 찾기 위해 해당 위치의 인덱스를 뺄셈으로 줄입니다
3. 입력을 해당 길이의 청크로 분할
4. 청크를 쌍으로 분할
5. 각 쌍을 합산
6. 합산 된 각 청크 반전
7. 1 차원 목록으로 병합

수학, 53 바이트

Join@@(Reverse[Plus@@@#~Partition~UpTo@2]&/@Split@#)&

설명

Split@#

입력을 동일한 요소의 런으로 구성된 서브리스트로 분할하십시오. 즉 {2, 2, 2, 4, 8, 8}이된다 {{2, 2, 2}, {4}, {8, 8}}.

#~Partition~UpTo@2

최대 2. 즉 파티션 길이에 하위 목록의 각 파티션 {{2, 2, 2}, {4}, {8, 8}}이된다 {{{2, 2}, {2}}, {{4}}, {{8, 8}}}.

Plus@@@

각 파티션을 합산하십시오. 즉 {{{2, 2}, {2}}, {{4}}, {{8, 8}}}이된다 {{4, 2}, {4}, {16}}.

Reverse

Mathematica의 Partition명령이 왼쪽에서 오른쪽으로 이동 하기 때문에 결과를 반대로 바꾸십시오 . 그러나 파티션이 다른 방향으로 가고 싶습니다. 즉 {{4, 2}, {4}, {16}}이된다 {{2, 4}, {4}, {16}}.

Join@@

결과를 평평하게하십시오. 즉 {{2, 4}, {4}, {16}}이된다 {2, 4, 4, 16}.

자바 7, 133 바이트

Object f(java.util.ArrayList<Long>a){for(int i=a.size();i-->1;)if(a.get(i)==a.get(i-1)){a.remove(i--);a.set(i,a.get(i)*2);}return a;}

입력은 ArrayList이며, 필요한 경우 제거하고 배가하면서 뒤로 순환합니다.

Object f(java.util.ArrayList<Long>a){
    for(int i=a.size();i-->1;)
        if(a.get(i)==a.get(i-1)){
            a.remove(i--);
            a.set(i,a.get(i)*2);
        }
    return a;
}

펄, 37 바이트

에 +4 포함 -0n

STDIN에서 입력을 별도의 행으로 실행하십시오.

perl -M5.010 shift2048.pl
2
2
2
4
4
8
2
^D

shift2048.pl :

#!/usr/bin/perl -0n
s/\b(\d+
)(\1|)$//&&do$0|say$1+$2

하스켈, 56 바이트

g(a:b:r)|a==b=a+b:g r|l<-b:r=a:g l
g x=x
r=reverse
r.g.r

PHP, 86100 9994 바이트

for($r=[];$v=+($p=array_pop)($a=&$argv);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);

PHP 7.0이 필요합니다. 명령 행 인수에서 값을 가져옵니다.

온라인으로 실행 -nr하거나 사용해보십시오 .

줄리아 205 바이트

t(x)=Val{x}
s(x)=t(x)()
f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))
g()=[]
g{a}(::t(a))=[a]
g{a}(::t(a),B...)=[a;g(B...)]
g{a}(::t(a),::t(a),B...)=[2a;g(B...)]
K(A)=g(s.(A)...)
H(A)=(K^s(length(A)))(A)

호출 할 함수는 H

예 : H([1,2,2,4,8,2,])

이것은 줄리아에서 가장 짧은 방법은 아닙니다. 그러나 그것은 너무 시원해서 어쨌든 공유하고 싶었습니다.

• t(a) 값 (a)를 나타내는 값 유형입니다.
• s(a) 해당 값 유형의 인스턴스입니다
• g차이 값 (값 유형 사용)과 해당 매개 변수의 숫자를 전달하는 함수입니다. 그리고 그것은 멋지다
• K단지 랩 g있도록

매우 멋진 부분 :

f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))

^함수에 적용 할 연산자를 정의합니다 . 그래서 그 K^s(2)(X)와 동일 K(K(X)) 하므로 H단지 호출 K에 K시간의 무리 - 충분한 시간이 확실히 중첩 된 사건을 축소하려면

이 작업은 훨씬 짧아 질 수 있지만이 방법은 정말 재미 있습니다.

PowerShell v2 +, 81 바이트

param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count..0]

명시적인 배열로의 입력을 받아 $n이를 반전 $n[$n.count..0], -join쉼표 요소를 함께 s가 다음 정규식 -replace제 소자, 디지트 쌍으로 매칭 SA *2및 괄호에 둘러싸인. 결과물 (입력 용 )이 (약칭 형 및 유사 @(2,2,4,4)형 (4*2),(2*2)) 파이프 로 곱셈을 실제 숫자로 변환합니다. 상점에 결과 배열은 , 괄호에 다음 반전, 파이프 라인에 배치하는 것을 캡슐화 와 함께 . 결과 요소를 파이프 라인에 남겨두고 출력은 암시 적입니다.iexInvoke-Expressioneval$b$b[$b.count..0]

테스트 사례

NB-- PowerShell에서 빈 배열을 "반환"한다는 개념은 의미가 없습니다.$null범위를 벗어나 자마자변환되므로 아무것도 반환하지 않는 것과 같습니다. (사악한 장황한 오류 후). 또한 출력은 문자열 배열의 기본 구분 기호이므로 공백으로 구분됩니다.

PS C:\Tools\Scripts\golfing> @(),@(2,2,4,4),@(2,2,2,4,4,8),@(2,2,2,2),@(4,4,2,8,8,2),@(1024,1024,512,512,256,256),@(3,3,3,1,1,7,5,5,5,5)|%{"$_ --> "+(.\2048-like-array-shift.ps1 $_)}
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:67
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+                                                                   ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

Cannot index into a null array.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:13
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

 --> 
2 2 4 4 --> 4 8
2 2 2 4 4 8 --> 2 4 8 8
2 2 2 2 --> 4 4
4 4 2 8 8 2 --> 8 2 16 2
1024 1024 512 512 256 256 --> 2048 1024 512
3 3 3 1 1 7 5 5 5 5 --> 3 6 2 7 10 10

자바 스크립트-103 바이트

v=a=>{l=a.length-1;for(i=0;i<l;i++)a[l-i]==a[l-1-i]?(a[l-i-1]=a[l-i]*2,a.splice(l-i,1)):a=a;return a}

Brain-Flak , 60 바이트

{({}<>)<>}<>{(({}<>)<>[({})]){((<{}>))}{}{({}<>{})(<>)}{}}<>

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

설명:

{({}<>)<>}<>   Reverse stack

{   While input exists
  (
    ({}<>)   Push copy of last element to the other stack
    <>[({})] And subtract a copy of the next element
  )   Push the difference
  {   If the difference is not 0
    ((<{}>)) Push two zeroes
  }{}  Pop a zero
  {   If the next element is not zero, i.e the identical element
    ({}<>{})  Add the element to the copy of the previous element
    (<>)      Push a zero
  }{}    Pop the zero
}<>  End loop and switch to output stack

파이썬 2, 94 바이트

def f(a,r=[]):
 while a:
    if len(a)>1and a[-1]==a[-2]:a.pop();a[-1]*=2
    r=[a.pop()]+r
 print r

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

줄리아, 73 82 바이트

f(l)=l==[]?[]:foldr((x,y)->y[]==x?vcat(2x,y[2:end]):vcat(x,y),[l[end]],l[1:end-1])

오른쪽 접기를 사용하여 목록을 뒤에서 앞으로 만듭니다 (하나는 왼쪽 접기를 사용하여 시작과 끝에서 목록을 뒤집을 수도 있음).

현재 목록의 머리글이 앞에 붙일 다음 요소와 같지 않으면 앞에 붙입니다.

그렇지 않으면 목록의 머리를 제거하고 잔인한 소리를냅니다.

예

f([3,3,3,1,1,7,5,5,5,5]) 
returns a new list:
[3,6,2,7,10,10]

라켓 166 바이트

(λ(l)(let g((l(reverse l))(o '()))(cond[(null? l)o][(=(length l)1)(cons(car l)o)]
[(=(car l)(second l))(g(drop l 2)(cons(* 2(car l))o))][(g(cdr l)(cons(car l)o))])))

언 골프 드 :

(define f
  (λ (lst)
    (let loop ((lst (reverse lst)) 
               (nl '()))
      (cond                            ; conditions: 
        [(null? lst)                   ; original list empty, return new list;
               nl]
        [(= (length lst) 1)            ; single item left, add it to new list
              (cons (first lst) nl)]
        [(= (first lst) (second lst))  ; first & second items equal, add double to new list
              (loop (drop lst 2) 
                    (cons (* 2 (first lst)) nl))]
        [else                          ; else just move first item to new list
              (loop (drop lst 1) 
                    (cons (first lst) nl))]  
        ))))

테스트 :

(f '[])
(f '[2 2 4 4]) 
(f '[2 2 2 4 4 8]) 
(f '[2 2 2 2]) 
(f '[4 4 2 8 8 2])
(f '[1024 1024 512 512 256 256]) 
(f '[3 3 3 1 1 7 5 5 5 5])
(f '[3 3 3 1 1 7 5 5 5 5 5])

산출:

'()
'(4 8)
'(2 4 8 8)
'(4 4)
'(8 2 16 2)
'(2048 1024 512)
'(3 6 2 7 10 10)
'(3 6 2 7 5 10 10)

Japt , 12 바이트

ò¦ ®ò2n)mxÃc

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

포장 풀기 및 작동 방식

Uò!= mZ{Zò2n)mx} c

Uò!=    Partition the input array where two adjacent values are different
        i.e. Split into arrays of equal values
mZ{     Map the following function...
Zò2n)     Split into arrays of length 2, counting from the end
          e.g. [2,2,2,2,2] => [[2], [2,2], [2,2]]
mx        Map `Array.sum` over it
}
c       Flatten the result

Jonathan Allan의 Jelly 솔루션 에서 아이디어를 얻었습니다 .

수학, 51 바이트

Abs[#//.{Longest@a___,x_/;x>0,x_,b___}:>{a,-2x,b}]&

{Longest@a___,x_/;x>0,x_,b___}두 개의 연속 된 동일한 양수를 포함하는 목록과 일치하고이 두 숫자를로 변환합니다 -2x. Longest경기가 가능한 한 늦게 발생하도록합니다.

프로세스는 단계별로 설명됩니다.

   {3, 3, 3, 1, 1, 7, 5, 5, 5, 5}
-> {3, 3, 3, 1, 1, 7, 5, 5, -10}
-> {3, 3, 3, 1, 1, 7, -10, -10}
-> {3, 3, 3, -2, 7, -10, -10}
-> {3, -6, -2, 7, -10, -10}
-> {3, 6, 2, 7, 10, 10}

Vim, 28 바이트

G@='?\v(\d+)\n\1<C-@>DJ@"<C-A>-@=<C-@>'<CR>

정규 표현식이 일치하는 연속 번호를 찾기 위해 뒤로 검색하고 함께 더하는 매크로입니다.

입력 배열은 라인 당 하나의 숫자 여야합니다. 이 형식을 사용하면 스트로크를 절약 할 수 있지만 실제로는 중복되는 정규 표현식 일치 문제를 해결해야합니다. 문자열을 감안 222하면 경우에, /22당신은 첫 번째 쌍되지 겹치는 두 번째 쌍을 일치하는 것입니다. 겹침 규칙은 두 쌍이 다른 줄에서 시작될 때 다릅니다. 이 도전 [2, 2, 2]하게 [2, 4]되므로 중첩 쌍을 매칭하는 것은 중요하다.

참고 : 이 문제는 단일 패스 만 요구했습니다. 이런 이유로을 (를) 가지고 있어야 :set nowrapscan합니다. 와 :set wrapscan나는 작성된이 솔루션은 항상 그렇게하지 않지만, 여러 패스에 작업을 완료 버전을 만들 수 있습니다.

• <C-@>: 일반적으로 명령 행 <CR>에서 명령을 실행하지 않고 리터럴을 입력 하려면 이스케이프 처리해야합니다.<C-V> . 그러나 <C-@>이스케이프 처리되지 않은 유형을 입력 하면 매크로로 실행할 때 와 같지만 입력 할 때는 아닌 <C-J>/ 로 취급 됩니다. 읽어보십시오 .<NL><CR>:help NL-used-for-Nul
• @=: 입력에 일치하는 쌍이 없을 가능성이 있기 때문에 이번에는 기록 된 매크로를 쉽게 사용할 수 없습니다. 매크로를 실행하는 동안 이러한 상황이 발생하면 검색에 실패하면 매크로가 실패합니다. 그러나 (암시 적 첫 번째) 기록 단계에서 발생하면 나머지 일반 모드 명령이 실행되어 파일이 손상됩니다. 단점은 @=재귀 호출에서 바이트를 잃는다는 것입니다. 때로는 @@재귀 호출로 사용할 수 있지만 @"이 경우 4 바이트에서 실행 됩니다.
• DJ@"<C-A>-: DJ행을 삭제하고 숫자에 줄 바꿈 없음을 레지스터에 넣으므로 숫자 인수에 대한 매크로로 실행할 수 있습니다 <C-A>. 나는 -같은 경우에 두 번째 경기를하지 않도록 나중에 해야합니다 [4, 2, 2].

Perl6, 92 바이트

{my @b;loop ($_=@^a-1;$_>=0;--$_) {@b.unshift($_&&@a[$_]==@a[$_-1]??2*@a[$_--]!!@a[$_])};@b}

프롤로그 (SWI) , 97 87 바이트

[N,N|T]+[O|Q]:-O is N*2,T+Q.
[N|T]+[N|Q]:-T+Q.
R+R.
L-R:-reverse(L,M),M+Q,reverse(Q,R).

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