Załóżmy, że chcemy przesunąć tablicę, tak jak ma to miejsce w grze 2048 : jeśli mamy dwa równe kolejne elementy w tablicy, scal je w podwójny element wartości. Shift musi zwrócić nową tablicę, w której każda para kolejnych równych elementów jest zastępowana ich sumą, a pary nie powinny się przecinać. Przesunięcie jest wykonywane tylko raz, więc nie musimy ponownie łączyć uzyskanych wartości. Zauważ, że jeśli mamy 3 kolejne równe elementy, musimy zsumować skrajne prawe, więc na przykład [2, 2, 2]powinno się stać [2, 4], a nie [4, 2].

Zadanie polega na napisaniu najkrótszej funkcji, która pobiera tablicę i zwraca tablicę przesuniętą.

Możesz założyć, że wszystkie liczby całkowite będą ściśle dodatnie.

Przykłady:

[] -> []
[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]

Jestem również bardzo zainteresowany rozwiązaniem wykorzystującym redukcję :)

Galaretka , 10 9 8 bajtów

Œg+2/€UF

TryItOnline lub uruchom wszystkie przypadki testowe

W jaki sposób?

Œ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]

Haskell, 47 57 50 bajtów

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

Używa reduce(lub foldjak to się nazywa w Haskell, tutaj prawy fold foldr). Przykład użycia: map abs.foldr(#)[] $ [2,2,2,4,4,8]-> [2,4,8,8].

Edycja: +10 bajtów, aby działało również dla nieposortowanych tablic. Połączone liczby są wstawiane jako wartości ujemne, aby zapobiec ponownemu scaleniu. Są one poprawiane przez finał map abs.

Brain-Flak , 158 96

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

Wypróbuj online!

Wyjaśnienie:

1 Odwróć listę (przenosząc wszystko na inny stos, ale to nie ma znaczenia)

{({}<>)<>}<>
{        }   #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 Wykonaj kroki 3-6, aż na stosie nie pozostanie nic:

{                                                                                         }

3 Zduplikuj dwa górne elementy (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 Umieść 1 na górze, jeśli dwie pierwsze są równe, 0 w przeciwnym razie (z wiki)

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

5 Jeśli dwie górne były równe (niezerowe u góry), dodaj kolejne dwie i wciśnij wynik

{{}(<({}{})>)}{}
{            }   #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 Przenieś górny element na drugi stos

({}<>)<>

7 Przełącz na drugi stos i drukuj niejawnie

<>

PHP, 116 bajtów

<?$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);

lub

<?$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));

-4 Bajtów, jeśli wyjściem może być tablica print_rzamiast „kod_json”

176 bajtów, aby rozwiązać ten problem za pomocą Regex

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

Obejmuje +1 za -r
-3 Dzięki cyfrowej traumie
-1 Dzięki seshoumara

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

Wejścia i wyjścia to ciągi rozdzielone spacjami w jedności (w oparciu o ten konsensus ).

Wypróbuj online!

Retina , 32

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

rw linii 3 aktywuje dopasowanie wyrażenia regularnego od prawej do lewej. A to oznacza, że \1odniesienie musi pojawić się przed (1+)grupą przechwytującą, do której się odwołuje.

Wypróbuj online.

Perl, 41 bajtów

Obejmuje +1 dla -p

Podaj sekwencję wprowadzania na 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

Python, 61 bajtów

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

Boolean bsprawdza, czy dwa ostatnie elementy powinny się zwinąć, sprawdzając, czy są one równe w sposób bezpieczny dla list o długości 1 lub 0. Ostatni element, jeśli następnie jest dołączony z mnożnikiem 1równości lub 2nierówności. Jest dołączany do wyniku rekurencyjnego na liście z tak wieloma elementami odciętymi na końcu. Dzięki Dennis za 1 bajt!

Perl, 43 + 1 ( -p) = 44 bajty

Ton Hospel wymyślił 41 bajtów odpowiedzi , sprawdź to!

-4 dzięki @Ton Hospel!

Edycja : dodano \b, ponieważ bez niego nie udawało się na wejściu, tak jak 24 4na wyjściu 28.

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

Uruchom z -pflagą:

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

Nie widzę innego sposobu niż przy użyciu reversedwukrotnie do prawej-krotnie (jak tylko s/(\d+) \1/$1*2/gebędzie lewy-krotnie, czyli 2 2 2staną 4 2zamiast 2 4). Więc 14 bajtów utraconych dzięki reverse... Nadal myślę, że musi istnieć inny (lepszy) sposób (w końcu perl!), Daj mi znać, jeśli go znajdziesz!

JavaScript (ES6), 68 bajtów

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 bajtów ( 49 + 1 dla flagi)

Dzięki Ton Hospel za oszczędność 11 bajtów!

Rozwiązanie wolne od Regex, z -aflagą:

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

Wypróbuj tutaj!

JavaScript (ES6), 68 65 58 57 65 64 bajtów

Zapisano 1 bajt dzięki @ l4m2

Naprawiono nieposortowane tablice teraz, gdy wyjaśniono, że takich danych należy się spodziewać.

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 bajtów

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

Wypróbuj online!

Uogólnione kroki

1. Zmniejszaj przez odejmowanie, aby znaleźć różnice między kolejnymi elementami
2. Zmniejsz, odejmując indeksy tych miejsc, aby znaleźć długość kolejnych elementów
3. Podziel dane wejściowe na części o tych długościach
4. Podziel kawałki na pary
5. Zsumuj każdą parę
6. Odwróć każdy zsumowany fragment
7. Spłaszcz do listy 1-wymiarowej

Mathematica, 53 bajty

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

Wyjaśnienie

Split@#

Podziel dane wejściowe na listy podrzędne składające się z serii identycznych elementów. tzn . {2, 2, 2, 4, 8, 8}staje się {{2, 2, 2}, {4}, {8, 8}}.

#~Partition~UpTo@2

Podziel każdą podlistę na partycje o długości maksymalnie 2. tzn . Stanie {{2, 2, 2}, {4}, {8, 8}}się {{{2, 2}, {2}}, {{4}}, {{8, 8}}}.

Plus@@@

Łącznie każda partycja. tzn . {{{2, 2}, {2}}, {{4}}, {{8, 8}}}staje się {{4, 2}, {4}, {16}}.

Reverse

Odwróć wyniki, ponieważ Partitionpolecenie Mathematiki idzie od lewej do prawej, ale chcemy, aby partycje były w innym kierunku. tzn . {{4, 2}, {4}, {16}}staje się {{2, 4}, {4}, {16}}.

Join@@

Spłaszcz wynik. tzn . {{2, 4}, {4}, {16}}staje się {2, 4, 4, 16}.

Java 7, 133 bajty

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

Input jest ArrayList i po prostu zapętla się do tyłu, usuwając i podwajając w razie potrzeby.

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

Perl, 37 bajtów

Obejmuje +4 za -0n

Uruchom z danymi wejściowymi jako osobnymi liniami na 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

Haskell, 56 bajtów

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, 86 100 99 94 bajty

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

wymaga PHP 7.0; pobiera wartości z argumentów wiersza poleceń.

Uruchom -nrlub wypróbuj online .

Julia 205 bajtów

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)

Wywoływaną funkcją jest H

na przykład H([1,2,2,4,8,2,])

Nie jest to w żaden sposób najkrótszy sposób na zrobienie tego w Julii. Ale to jest tak fajne, że i tak chciałem się tym podzielić.

• t(a) jest typem wartości reprezentującym wartość (a).
• s(a) jest instancją tego typu wartości
• gjest funkcją, która wywołuje wartości różnic (przy użyciu typów wartości) i liczby jego parametrów. I to jest fajne
• Kpo prostu owija się gtak, że

Bardzo fajna część:

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

To definiuje ^operatora do zastosowania do funkcji. Tak, że K^s(2)(X)jest taki sam jak K(K(X)) tak Hjest po prostu dzwoniąc Kna Kpęczek razy - tyle razy, aby na pewno zwinąć żadnej zagnieżdżony przypadek

Można to zrobić znacznie krócej, ale ten sposób jest po prostu zabawny.

PowerShell v2 +, 81 bajtów

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

Pobiera dane wejściowe jako jawną tablicę $n, odwraca je $n[$n.count..0], -joins elementy wraz z przecinkiem, a następnie regex -replacesa pasującą parę cyfr z pierwszym elementem a *2i otoczoną znakami. Rurki, które wynikają (które @(2,2,4,4)będą wyglądać na wejściu (4*2),(2*2)) do iex(skrót dla Invoke-Expressioni podobne do eval), co konwertuje mnożenie na liczby rzeczywiste. Przechowuje wynikową tablicę w $b, hermetyzuje ją w parens, aby umieścić ją w potoku, a następnie odwraca za $bpomocą [$b.count..0]. Pozostawia powstałe elementy w potoku, a dane wyjściowe są niejawne.

Przypadki testowe

Uwaga: W programie PowerShell koncepcja „zwracania” pustej tablicy jest bez znaczenia - jest konwertowana do$nullmomentu, gdy opuści zakres - a więc jest to odpowiednik braku zwracania, co dzieje się tutaj w pierwszym przykładzie (po kilku złośliwie pełnych błędach). Dodatkowo dane wyjściowe są tutaj oddzielone spacjami, ponieważ jest to domyślny separator dla tablic strunowych.

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

JavaScript - 103 bajty

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 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

Python 2, 94 bajty

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

Wypróbuj online

Julia, 73 82 bajtów

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

Użyj prawej klapki, aby zbudować listę od tyłu do przodu (można również użyć klapki w lewo i odwrócić listę na początku i na końcu).

Jeśli nagłówek bieżącej listy nie jest równy następnemu elementowi do dodania, po prostu wstaw go.

W przeciwnym razie usuń nagłówek listy (brzmi trochę okrutnie) i wstaw element razy 2.

Przykład

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

Rakieta 166 bajtów

(λ(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))])))

Nie golfowany:

(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))]  
        ))))

Testowanie:

(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])

Wynik:

'()
'(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 bajtów

ò¦ ®ò2n)mxÃc

Wypróbuj online!

Rozpakowane i jak to działa

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

Wpadłem na pomysł z galaretką Jonathana Allana .

Mathematica, 51 bajtów

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

{Longest@a___,x_/;x>0,x_,b___}dopasowuje listę zawierającą dwie kolejne identyczne liczby dodatnie i przekształca te dwie liczby w -2x. Longestzmusza mecze do spóźnienia się.

Proces ilustruje krok po kroku:

   {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 bajtów

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

Makro, które regex wyszukuje wstecz pasujące kolejne liczby, i dodaje je do siebie.

Tablica wejściowa musi mieć jedną liczbę w wierszu. Ten format oszczędza mi uderzeń, co jest miłe, ale prawdziwym powodem jest obejście nakładających się dopasowań wyrażeń regularnych. Biorąc pod uwagę ciąg 222, jeśli /22dopasujesz tylko pierwszą parę, a nie nakładającą się drugą parę. Zasady nakładania się są różne, gdy dwie pary zaczynają się na różnych liniach. W tym wyzwaniu [2, 2, 2]staje się [2, 4], więc dopasowanie nakładającej się pary ma kluczowe znaczenie.

UWAGA: Wyzwanie wymagało tylko jednego podania. Z tego powodu musisz mieć :set nowrapscan. Z :set wrapscanMógłbym stworzyć wersję, która kończy pracę na wielu przejściach, chociaż to zapisane rozwiązanie nie zawsze to robi.

• <C-@>: Zwykle w wierszu polecenia należy wpisać literał <CR>bez uruchamiania polecenia, za pomocą którego trzeba by go uciec <C-V>. Ale możesz wpisać <C-@>nieskalowany, a zostanie on potraktowany jako <C-J>/ <NL>, co będzie jak <CR>podczas uruchamiania makra, ale nie podczas pisania. Spróbuj przeczytać :help NL-used-for-Nul.
• @=: Tym razem nie mogę łatwo użyć zarejestrowanego makra, ponieważ istnieje możliwość, że dane wejściowe mogą nie mieć pasujących par. Jeśli tak się stanie podczas uruchamiania makra, nieudane wyszukiwanie zakończy się niepowodzeniem. Ale jeśli zdarzy się to podczas (domyślnie pierwszego) przebiegu nagrywania, uruchomione zostaną pozostałe polecenia trybu normalnego, uszkadzając plik. Minusem @=jest to, że tracę bajt na rekurencyjnym wezwaniu; czasami można użyć @@jako wywołania rekurencyjnego, ale @"w tym przypadku byłoby to uruchamiane wcześniej z 4 bajtów.
• DJ@"<C-A>-: DJusuwa linię i umieszcza liczbę (bez nowej linii) w rejestrze, dzięki czemu mogę uruchomić ją jako makro dla argumentu liczby <C-A>. Muszę -później, żeby nie dostać drugiego meczu w takich przypadkach [4, 2, 2].

Perl6, 92 bajty

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

Prolog (SWI) , 97 87 bajtów

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

Wypróbuj online!